* feat(studio): timeline select and selection refresh read an opaque preview over its channel
On a preview frame Studio cannot script, timeline select, a selection
refresh and a group refresh build the selection from the runtime's element
descriptions. The rules that pick the element (group capture and drill-in,
the clip ancestor, the walk to an addressable element, timeline-locked, the
lookups and the master-view root fallback) move to a pure module over an
ancestor chain, used by both paths, so both select the same element.
Same-origin frames keep their direct reads.
The editing port gains `ancestors` (each handle's chain, parent first) and
`query` (a selector's matches with their source facts), and
`computed-styles` also names its element by handle. An opaque selection
carries the element's handle; its `element` is a tag-only stand-in in a
document with no window.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore(studio): keep the selection rules' comment share at the package's
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
First slice of moving Studio's selection and overlay readers off the
preview frame's DOM. Same-origin frames keep their direct reads; only a
frame Studio cannot script takes the new paths.
- Runtime editing port: a validated computed-styles request, answered
with the same logical opacity Studio reads (moved to core).
- Element picker: on an opaque frame, the picked element's computed
styles come from the runtime. Picker posts are taken only from an
origin the posting frame can have.
- Composition rect: an opaque frame's declared size comes from the
runtime's stage-size post, mirrored only for registered frames and
their origins.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* feat(studio): record the layer name on each history entry's target
* feat(studio): record the clip's name on timeline move and resize entries
* chore(studio): drop doc comments the names already carry
* feat(studio): show the agent's storyboard in a Storyboard tab beside the preview
The board an agent writes per the storyboard recipe (boards/storyboard.html,
or a root storyboard.html) now shows in Studio the way HyperFrames Desktop
shows it: a Preview | Storyboard strip over the preview panel, only while the
project has a board. Studio reads the page's class="frame" boxes into a board
of stills, with acts, titles, times and words, and one frame at a time with
arrow keys. A page with no frames shows as written in a script-less iframe.
A board written while Studio is open brings its tab to the front, as Desktop
does at the agent's stop. A rewrite of the page, a still beside it or
STORYBOARD.md reloads it in place, and a dot marks a rewrite seen from the
preview. "Show in preview" goes back to the film at the frame's start.
Notes, drawings and the go belong to Desktop's agent, so the board's bar
carries the desktop-app button. Its funnel events now say which button was
pressed (placement: header or storyboard).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HebQXPiLcYKQfvPWB3Fgxy
* refactor(studio): split the storyboard view and its frame reader into smaller parts
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HebQXPiLcYKQfvPWB3Fgxy
* docs(skills): the agent's storyboard stop points at the Storyboard tab, not the file
With the board shown beside the preview in Studio as in Desktop, the recipe's
stop and style-sampling's stop 1 tell the person to look in the Storyboard
tab, and to start a preview and give its link when none is running, instead
of handing over boards/storyboard.html to open from disk.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HebQXPiLcYKQfvPWB3Fgxy
* fix(studio): the storyboard listens on Studio's own file-change channel, and its notes are trimmed
The board opened its own /api/events stream, which the Vite dev server
behind the runtime smoke does not serve. It now subscribes through
subscribeFileChanges, the one channel picker the external-change
coordinator already uses (test adapter, Vite HMR, then SSE), so dev and
built Studio deliver the same changes to both.
The new files' comments are cut to the package's share, and the recipe's
Storyboard-tab line moves to the paragraph that names the board, leaving
the stop step as it was.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HebQXPiLcYKQfvPWB3Fgxy
* fix(studio): the board hears file changes through the coordinator, not a second subscription
The external-change coordinator stays the one subscriber to the file-change
transport (HMR in dev, SSE when built), as externalFileChangeOwnership
asserts. It announces each decoded change through fileChangeFanout, and the
storyboard listens there. Mounting EditorShell alone, as its tests do, no
longer opens an EventSource, and the coordinator file stays under the line cap.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HebQXPiLcYKQfvPWB3Fgxy
* feat(studio): the storyboard's Open in desktop app asks the app to open on the board, and its card says why
- The storyboard bar's button posts `doc: "storyboard"` with its page id. The preview server passes only that value
on, and `openInDesktop` writes it into `.hyperframes/desktop-cta.json` beside the page id, so the app can open the
project on its Storyboard tab with Build in sight (hyperframes-internal reads it).
- The guide card opened from the storyboard says "Approve this storyboard in the desktop app" and "Comment on a frame,
draw on it, then press Build", and its last step says the app opens on this storyboard. The header's card is
unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HebQXPiLcYKQfvPWB3Fgxy
* feat(studio): approve the storyboard in Studio; comments on frames stay in the desktop app
A Studio user without the desktop app had no way to approve the board from the tab, and the bar said approval was
in the desktop app, so the tab read as a dead end. Studio talks to the person's own agent through their chat, so the
bar's Approve copies "The storyboard is approved. Build the video from it." for them to paste to it, and says so in
a toast (or spells the words out when the clipboard refuses). Commenting and drawing on frames stay in the desktop
app. The storyboard recipe tells the agent those pasted words are the person's go.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HebQXPiLcYKQfvPWB3Fgxy
* fix(studio): the storyboard's desktop card offers commenting, since approving now happens in Studio
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HebQXPiLcYKQfvPWB3Fgxy
* fix(studio): hand-off intent before dispatch, steady film under the board, stills outside the board folder
- openInDesktop writes desktop-cta.json before sending the folder, so a running
app reads the storyboard ask on arrival; a plain or header open drops an
earlier storyboard ask; a failed open puts the earlier record back.
- PreviewStage keeps the film at one place in the tree with or without a board,
so a board appearing never remounts it; the automatic switch goes through the
same pause as a click, and a play while the board is up is paused.
- The board reloads when a still it draws changes, including a root board's
stills/ and a boards/ page's ../assets.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HebQXPiLcYKQfvPWB3Fgxy
* chore(cli): fit the Storyboard tab in the CLI's size budget; reword a record helper's doc
The CLI tarball carries Studio's build, which now holds the Storyboard tab; merged
with main it measures 7,982,002 bytes packed, 7 bytes past the 1% tolerance.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HebQXPiLcYKQfvPWB3Fgxy
* fix(studio): hold the player while the storyboard covers the film
A pause after the fact let J's reverse loop schedule its next frame, so the
hidden film kept seeking. The stage now takes the player's own hold while the
board is up (and only when no one else holds it), so J, Space and playback
requests are refused before they start; Preview releases it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HebQXPiLcYKQfvPWB3Fgxy
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* feat(studio): alt marquee removes the covered items from the selection
Shift already adds marquee hits to the selection on the canvas and the
timeline; there was no way to take a few items back out of a large
selection. Both marquee paths now carry a MarqueeSelectionMode
(replace | add | subtract) resolved from the pointer modifiers in one
helper, with Alt winning over Shift. Subtracting the primary re-anchors
on a surviving member; subtracting everything clears the selection. The
band and candidate outlines turn the danger colour while subtracting.
Closes#5586
* fix(studio): same alt marquee rules on the canvas and the timeline
Both surfaces now let the modifiers held at release decide: the timeline
re-applies the marquee from the pointerup event before it finishes, so
letting go of Alt mid-drag turns a subtract back into a replace, as the
canvas already did. Alt at pointerdown no longer bakes a timeline base
mode; Cmd/Ctrl still sets add. While subtracting, the canvas outlines
only candidates that are in the current selection, so the band never
suggests removing something that is not selected. The timeline commit
helpers move to timelineMarqueeCommit.ts to keep the hook under the
file-size cap.
* feat(studio): shortcut combos in the key resolver
* feat(studio): every editor shortcut is a remappable combo
* refactor(studio): playback keys dispatch through one table
* fix(studio): combo parsing without backtracking, symbol keys match, fewer comments
* style(studio): format the shortcut files
* chore(studio): drop a doc comment the ratchet counts
* chore(studio): drop a doc comment the ratchet counts
* fix(studio): modifier combos fire for playback keys, caption guard and held stop key follow the map
* fix(studio): an undo or redo counts as a preview change from its key, not from its reload
* refactor(studio): count a history step from its key with the page flag on noteIdle
* fix(studio): a timeline edit on a clip the file lacks says how the clip was looked up
* fix(studio): name only the lookups a missing clip was really found by
* refactor(studio): split the missing-clip lookup words into small helpers
* refactor(studio): fit the missing-clip lookup words under the no-visible-change size
* fix(studio): a timeline edit that lands on the clip's own values saves nothing instead of failing
* chore: re-run checks against the updated PR description
* fix(core): preview seeks land on the composition's own frame rate
* fix(studio): frame step, frame readout and ruler use the composition's frame rate
* fix(studio): an end trim previews the clip's last frame at the composition's frame rate
* refactor(studio): ruler labels follow the ticks' frame rate and fps parsing splits by form
* style(studio): format the ruler label helper and its test
* chore(inspector): raise the package size budget to the measured size plus headroom
* feat(studio): zoom the timeline to the selected clips
Toolbar action and Z fit the selected clips to the visible width, with the
range margin, and stay disabled until something is selected.
* fix(studio): gate zoom-to-selection on a resolvable clip
The scroll clamp already lives in the timeline zoom request. Drop the
unused copy, and disable the button and Z unless the selection matches
a timeline clip with duration. A collapsed timeline cancels
zoomTimelineToRange instead of laying out a percent the view cannot show.
* fix(studio): keep a zoom step when the timeline is collapsed
A collapsed timeline has no track for a range zoom, so zoom in and out
step the percent directly. Z is consumed only when that zoom actually
starts, and zoom-to-selection no longer builds the span three times.
* ci: retrigger checks after workflow approval
The approved run was cancelled during checkout, so the required checks
never executed.
* perf(core): skip rendering preview scenes far from the playhead
* refactor(core): split the far-scene pass into small helpers
* perf(core): a first render reveals only the clips it reaches
* fix(core): reveal the clips holding first-rendered tweens, wherever their window is
* feat(core): a scene may load a project helper and wait for fonts and still swap
* perf(core): the preview mounts only the scenes near the playhead
* perf(core): a seek waits only for the scene it lands in; neighbours mount one per turn
* feat(studio): selecting a clip in an unmounted scene mounts that scene first
* fix(core): a source a play and a seek both need is fetched and decoded once
* fix(core): a scene mounting during play joins the mix without restarting what plays
* fix(studio): selecting a clip waits on a scene mount only in a preview that unmounts scenes
* fix(core): far scenes still mount after an edit, and an edit to a parked scene keeps its styles
* perf(core): web audio schedules a clip only as the playhead comes near it
* chore(studio): trim the scene hold helper's comments to its package's share
* fix(core): a scene the preview unmounts is freed, not kept by audio, caches or old roots
* fix(studio): an unmounted scene's rows and their state come from the markup it mounts with
* perf(core): the preview mounts scenes ahead of play and keeps recent ones mounted
* refactor(core): keep the far-scene neighbour rule private to its module
* style(core): format the far-scene neighbour rule
* perf(core): the preview unmounts scenes the playhead leaves, as kept ones slowed each mount
* fix(core): scenes that measure text, call their own animate or wait on font loads can unmount
* fix(core): each preview scene carries the helpers it loads, so it mounts on its own
* fix(core): a mounted scene shows though its stand-in was hidden by display
* fix(core): a helper scenes share runs once for the film, and a remounted scene keeps showing
* fix(core): a scene that also publishes its timeline under another id stays mounted
* feat(core): scenes that draw in 2D or chain the timeline they register can unmount
* perf(core): a play frame that draws nothing new skips the hidden-clip lookup
* fix(core): a GSAP file copied into a project counts as the library for scene unmounting
* style(core): drop an unneeded escape in the registered-chain pattern
* chore: core and producer size budgets make room for the preview scene window
* fix(core): a scene that draws on a 2D canvas stays mounted
* fix(core): a scene the preview unmounts lets go of timelines it built after a font wait
* perf(core): a scene leaving the playhead keeps its last rendered size, no forced layout at the cut
* refactor(core): the far-scene skip keeps last-render boxes in their own helper
* fix(core): a mounting scene never records the runtime's root timeline as its own
* chore(producer): raise the size budget to the measured size with the preview runtime inlined
* docs(core): keep the far-scene and scene-memory comments within the comment limits
* perf(core): style each hidden clip visible once ahead of its cut, so the cut frame does not
* fix(core): a seek into a scene still mounting as a neighbour waits for that mount
* chore(core): keep comment share and size budgets to main plus the measured core growth
* perf(core): Safari stops re-serializing inline styles on every GSAP write in a playing film
* perf(core): declare the clip-reveal subpath in its descriptor and cut added comment lines
* fix(shader-transitions): shader transitions across a scene boundary keep the scene's contents
Every revealer now goes through one core helper that shows the clip and
lifts the runtime's hidden mark together; the page-side compositor's scene
copies were still carrying the mark. The contents rule keeps its old weight.
* fix(core): films on an older shader-transitions build keep their transition scenes
Published shader builds reveal scenes by inline style without lifting the
hidden mark. When one is on the page, the runtime keeps the inline-style
rules; builds that lift the mark declare it on load and keep the fast rules.
* test(core): pin the hidden-clip contents rule's weight on its selector
* style(core): format the reveal test and move hidden-clip rule notes into names
* test(producer): pin hidden-clip behaviours in real Chrome under the mark-keyed rules
* test(producer): read the forced restyle's result so lint accepts the restyle test
* feat(studio): motion blur panel with Off / Subtle / Strong
One three-way control in the right dock. Subtle is the default blur
(240 deg shutter, samples sized to the smear); Strong is 720 deg and 64
samples. Writes the root data-motion-blur attributes through the SDK so
renders match and undo works; reads live attributes from the preview.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* fix(studio): motion blur panel edits the file's own root
The edits were worked out against the preview DOM but written to the file,
so a stale preview (undo inside the hold, a slow reload) could save a level
other than the one picked. They are now computed inside the mutation from
the candidate's root. While locked to a sub-composition no level is shown.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* fix(studio): shorten the motion blur tab so the dock strip fits
Five tabs overflowed the default dock width by 10px and clipped a label
(Studio: load smoke). The tab is now titled Blur.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(studio): real-Chrome tests recover from a stuck Chrome launch or close
* test(studio): retry a stuck Chrome launch that Windows reports as already running
* fix(studio): a deselect made while an edit saves stays deselected
A save resyncs the selection it started with once the write returns. It now
does so only while that element is still the one selected, so a deselect or
a different pick made during the save is no longer undone. The preview-reload
sync now routes through the same resync instead of a copy of it.
* refactor(studio): drop two comments the names already say
* fix(studio): a lost preview server or a superseded edit no longer files as a crash
* fix(studio-server): a render's scratch files no longer stream changes or list as compositions
* feat(studio): record video state, edit targets and artifact cleanup
* fix(studio): clear video-state CI gates
* fix(studio-server): pin cleanup reads to file descriptors
* chore: account for cleanup descriptor code in package budget
Move the keyframe rest-value table into @hyperframes/core/keyframe-defaults
and import it from the SDK backfill and Studio's gsapShared, replacing the two
hand-synced copies.
Closes#5387
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(core): an element its script hides stays hidden while studio preview plays
* fix(core): a stamped element re-timed in the timeline hides outside its new window
Studio timing edits drop the runtime-stamped mark, and a script-hidden stamped
container no longer holds back its images.
* fix(core): a preview-only stamp copied into a project no longer changes the render
Only the Studio preview honours the stamp, copied live markup drops it, and a
lane-only move makes a stamped element authored like the save does.
* fix(studio): text in Studio reads without em or en dashes
* fix(studio): the dash check also catches HTML entities, and peak reads Unavailable
* test(studio): the dash check test covers every entity form
* fix(studio): messages Studio shows from lint, sdk, core and the renderer drop dashes too
* fix(producer): the gate check stops early on the engine's new fallback wording
* fix(studio): a stalled font or asset no longer leaves the preview empty or drops reloads
* fix(studio): a page's own late load no longer counts as replaced content
* refactor(studio): one announcement owns when a preview page has loaded
* fix(studio): let hosts with their own player announce a new preview page
* fix(studio): a late ready from the replaced preview page no longer claims the new page
* refactor(studio): keep the Player doc comment on Player
* fix(studio): a resized corner stays on the pointer when the size rounds to whole pixels
Resized sizes stay on whole CSS pixels (GSAP centres a -50% translate from the
integer offset size), so the centre-anchored resize left the grabbed corner up to
a third of a pixel times the element's scale off the pointer: 0.53 px on a 1.5x
scaled layer. The centre pin now takes half the rounding remainder along the
element's rendered edges, so the grabbed corner lands where the wanted size puts
it while the written size stays whole.
* fix(studio): a scale resize saves the box exactly where it was dropped
finalizeScaleResizeCommit skipped its position correction whenever the box sat
within 0.5 px of the drop point on each axis, so a sub-pixel drop (now the
norm, with the grabbed corner on the pointer) saved up to half a pixel off.
It now skips only when the correction rounds to nothing at the precision the
file is written in.
* fix(studio): a scale resize lands centred on the box that was dropped
finalizeScaleResizeCommit lined the committed box up with the drop by its
top-left corner. When one scale cannot reproduce the dragged width and height
(the draft rounds each to whole pixels), that put the whole gap on the far
edges, up to half a pixel. The resize is centre-anchored, so it now lines up
centres and the gap splits evenly.
* chore(studio): keep the complexity note on the resize intercept, not the new helper
* test(studio): bank the two scaled resize cases that now pass the edit accuracy bench
* fix(studio): a scale resize leaves animated positions alone and mirrored corners track
* test(studio): bank only the two newly passing scaled resize cases
* fix(studio): a mirrored or parent-rotated layer's resize corner tracks the pointer
* fix(studio): a resize corner on a skewed layer picks its side from the box's own edges
* fix(studio): resizing a layer that renders with no area moves nothing
* fix(studio): clip strips resize on the next frame, ending ResizeObserver loop errors
* test(studio): verify strip resize frame scheduling deterministically
* fix(studio): a menu set to render inline opens beside its trigger
* fix(studio): a popover set to render inline opens beside its trigger
* fix(studio): a remounted clip strip keeps its own size instead of a queued one
* test(studio): zoom thumbnail tests run resize frames on fake timers
* test(studio): zoom preview test runs the resize frame it guards
* fix(studio): serve files whose name has a bare percent sign
A browser sends src="100%.png" with the % unescaped, and decoding the whole path threw, so Studio answered 500. Only well-formed escapes are decoded now.
* fix(cli): serve files with a bare percent sign from the check and snapshot server
One shared decode rule for request paths; the image thumbnail route's malformed-escape 400 could no longer fire, so a name that is not a file is a 404.
* fix(cli): name a failed file with a bare percent sign in check
* fix(studio): keep apostrophes and dollar signs in file names when editing attributes
An attribute value is matched by its own quote kind, so src="it's.png" is replaced instead of duplicated, and every insert uses a function replacer, so $1 or $& in a file name is written as is.
* fix(studio): rename references spelled with %20 or & and read quoted media sources
WIP: not yet tested; see the resume note.
* fix(studio): match whole attribute names when editing media sources
* fix(studio): compare decoded names and escape replacement references
* fix(studio): preserve file references across URL and string consumers
* docs: clarify raw file references and URL fields
* fix(studio): keep raw path identity distinct from URL spelling
* fix: share attribute grammar and decode media URLs at their readers
* fix: preserve local filename identity in HTML URL output
* fix: decode entity references before rename candidate matching
* style: format rename entity handling and regressions
* fix: preserve platform file identity when renaming references
* fix(core): decode CSS escapes before rebasing asset URLs
* fix(core): consume CSS continuations before URL encoding
* fix(core): preserve CSS URL identity and escape rebased suffixes
* fix(core): express CSS suffix controls with Unicode categories
* fix(core): preserve URL backslash identity while rebasing
* test(core): respect platform backslash filename semantics
* fix(studio): a dropped file with %, # or ? in its name loads, and an encoded reference renames
* fix(studio): read an authored src as a URL so dropped files with spaces, %, # or ? load
* fix(studio): media routes find files named with ? or #, and the probe reads a src as a URL
* fix(studio-server): one rule for request file paths, so loudness finds files named with %, # or ?
* chore: drop the design note from the change
* fix(core): rename replaced clips whose src is URL-encoded
* perf(studio): reuse filmstrip frames when a zoom changes a strip's width
A zoom that changed a strip's frame count decoded the whole strip again
on the main thread, and showed the clip's single poster frame until it
landed. Frames are now sampled at each slice's left edge, so a strip
twice as long holds every frame of the shorter one; decoded frames are
shared per source and time, so zooming out decodes nothing and zooming in
decodes only the new half. The strip on screen stays until the new width
is ready.
* perf(studio): redraw only the waveforms on or near the screen after a zoom
A zoom resizes every mounted clip, and every mounted waveform redrew in
that same frame, on screen or not. A waveform now draws only while it is
on or near the screen (one shared observer, a screen of margin each side)
and draws when it comes near if a zoom changed it meanwhile.
* perf(studio): never start a beat-analysis stage while the timeline zooms
Analyzing a long music track runs for over a second on the main thread,
and when it started late it landed inside a zoom. The analysis now awaits
an optional pause before each long stage; Studio's waits for the timeline
to rest and the browser to go idle. Results are unchanged. The tempo
detector's stage is one call, so a zoom that starts inside it still waits
for it.
* fix(studio): reuse a filmstrip frame only where its own strip would show it
A shared frame was keyed by the time a strip asked for, not the time it
was decoded at, so a coarse strip's keyframe-early frame could land in a
finer strip and run its frames backwards. A frame now carries its decoded
time and is reused only when the strip would have accepted that keyframe
itself. The frame-count ladder now tops out at a power of two (32), so
its top step shares frames with the one below instead of none.
* feat(studio): show the clip's last frame at the end of every filmstrip
Left-edge sampling never showed a clip's final slice, so an end card or a
fade-out was missing from its strip. Each strip now also decodes the
clip's last frame (at its own time, never an earlier keyframe), shared
across zoom steps like the others, and the last tile shows it.
The strip on screen is now held per clip and range, not per props: a
clip crossing between on and off screen keeps it, and a clip narrowed to
one frame lets it go, so widening again never re-decodes a dropped width.
* docs(studio): keep the filmstrip files at or under main's comment share
The comment ratchet allows no file a higher share of comment lines than on
main; the added explanations move to the PR description.
* fix(studio): keep a held filmstrip leased so a full cache cannot evict it mid-zoom
The hold leased the strip on screen only once a new width was requested,
so for one commit it had no lease; with the cache over budget it was
evicted, the poster showed, and the old width decoded again. The strip on
screen is now leased for as long as it is the clip's, and shown only while
held. A frame that fails to decode takes the frame before it, so every
slot keeps its time and the last tile still shows the end.
* refactor(studio): one owner for which clip a held filmstrip belongs to
The hold checked the clip twice, in its lease and again before showing
it; the lease alone decides now, and the cross-clip test pins it. A test
now also pins that a filled frame is not charged to the cache.
* fix(core): hold the tempo detector until idle after a slow import
* fix(studio): scope shared video frames to timeline sessions
* chore(core): keep beat analysis comments within the ratchet
* fix(studio): recover previews after missed file changes
* fix(studio): keep queued reloads with the current owner
* fix(studio): keep a queued outside change when switching compositions
* test(cli): the project watcher closes its parent folder's watch too
* fix(studio): keep the project-folder change out of the shared signature check
* fix(studio): keep the edited file's draft and reload every session after a reconnect
A reconnect or replaced folder is a project-wide change: every open SDK session reloads, a failed save is recorded against the file the draft belongs to, and two queued changes to different files merge into one project-wide reload.
* fix(studio): refresh the preview cache when the .hyperframes folder is replaced
* fix(cli): report the files of a folder moved into the project
Replacing a populated folder such as .hyperframes/ now reaches the signature cache through its files, so the shared signature rule stays as on main and Studio's own writes inside .hyperframes/ still invalidate nothing.
* refactor(studio): name the merged file-change payload and share the test sender
* fix(studio): keep a failed draft's recovery copy until that file itself saves
* style(studio): rewrap the merged payload line after the rename
* fix(studio): deliver a held change's full reload when its block clears
A clean save, Use external and Keep Studio now all deliver the merged scope a blocked change owes, and a moved-in .hyperframes folder reports its manifests so a dropped one still clears the cached signature.
* fix(studio): keep restored drafts out of the reload scope and clear the lint gates
* fix(studio): retain held reload scope before React renders
* perf(studio): coalesce timeline zoom to one write per frame and zoom to a range
* perf(studio): coalesce timeline zoom to one write per frame and zoom to a range
Every zoom input goes through one owner that writes the store once per frame.
zoomTimelineToRange eases to a time range; the zoom buttons use it.
* feat(studio): zoom-to-range reports done or cancelled and is not a person zoom
* perf(studio): place clips in percent of a one-second layer so zoom restyles nothing
A zoom step rewrites one width per row; clip thumbnails start decoding at rest.
* perf(studio): a zoom step re-renders only clips whose drawing it changes
Clip handlers read the lane callbacks when pressed, so a skipped clip never acts on a stale zoom.
* refactor(studio): move at-rest waveform and thumbnail work to its own change
* perf(studio): draw waveforms and decode thumbnails when the timeline rests
Waveforms draw only the visible span of a clip.
A zoom or scroll step stretches what is drawn until the timeline rests.
* test(studio): fade handles measure the clip only while they show
* test(studio): waveforms draw their visible span and redraw at rest
* feat(studio): export currentTimelineRange, the inverse of zoomTimelineToRange
* perf(studio): zoom gestures scale the drawn timeline and lay it out once at rest
No layout or render per gesture frame; past 0.67x or 2x the preview is laid out and continues.
* perf(studio): rebase a zoom preview only past 0.5x or 4x
Clips stay mounted half a viewport each side, so a zoom-out preview to 0.5x shows no gaps.
* fix(studio): keep the zoom readout, edges and Fit right during a preview
The slider and its percent follow a zoom while it is previewed. A zoom in
from below Fit no longer jumps when it lands: the preview now uses the
width the timeline will really have. A zoom-out lays out as soon as it
would show time with no clips mounted, so edges never show empty strips.
Fit, a press or a scroll on the timeline end a pending zoom first. An
older abort no longer cancels a newer zoom-to-range, and an instant one
lands on the next frame instead of inside its caller. Range selection and
gap tints scale with the preview.
* fix(studio): keep a pending zoom when the timeline re-registers its view
The timeline registers its scroll view again whenever clips are added or
removed, which used to drop a zoom still waiting to be laid out. Now only
a real unmount drops it, and unmounting one timeline leaves a newer
timeline's registration alone.
* refactor(studio): share the zoom geometry helpers the timeline already has
Zoom scales come from getTimelinePixelsPerSecond, the range margins from one
helper, and a zoom step starts from the same playhead anchor every zoom uses.
The clip minimum width is named and shared with the drag ghost.
* fix(studio): keep a zoom preview through scrolls and past the content end
A scroll during a zoom preview, including the one a laid-out zoom makes
itself, used to lay the next preview out at once, so a pinch or eased zoom
fell back to a full layout every frame. A scroll now only rescales what it
mounted. Zooming out also lays out before the preview shows past where the
ruler and beat lines are drawn, not only past the mounted clips.
* fix(studio): keep a moved audio clip's waveform drawn where it shows
A waveform now draws the stretch of its clip that the shared strip tracker
reports near the screen, the tracker the filmstrip already uses. It follows
scrolls, resizes and moves (a drag or ripple that shifts the clip), so a
moved clip no longer shows a blank stretch, and a zoom redraws it once.
* perf(studio): lay a zoom-out step out once, at its start
An eased zoom-out (a Zoom out click, or zooming out to a range) used to
lay out partway, once the shrinking preview reached time with nothing
mounted, and again at the end. It now lays the target out first and eases
by scaling that layout down from the old view, so each click lays out
once. Each eased frame also draws its preview in that frame.
* fix(studio): keep previewing a zoom at the content's end and over new rows
The preview now lays out only once it would show past the window the
timeline draws clips, ruler ticks and beat lines in, with two pixels of
slack, so rounding at the content's end no longer lays out every frame.
Rows mounted into the timeline during a preview are scaled before they
paint.
* fix(studio): redraw a waveform when its clip's width changes or it moves
A waveform drawn whole kept its old bars, stretched, after a zoom changed
its clip's width; it now redraws on any resize. A long clip also marks
its undrawn ends for the strip tracker, so a move without a scroll (a
ripple, a drop, an undo) re-measures it instead of leaving a blank
stretch.
* perf(studio): skip the layout when a zoom preview ends on its own scale
An eased zoom-out lays its target out first, so its preview ends on the
scale already laid out. Landing it now only sets the scroll, instead of
writing the same zoom again and counting the person's zoom twice.
* fix(studio): measure filmstrips and waveforms after a zoom preview ends
The strip tracker measured clip boxes while a zoom preview scaled them,
so after a Zoom out click a long clip's filmstrip or waveform could stay
blank across part of the screen. Reads during a preview now wait, and the
tracker re-measures every strip once the preview ends. A zoom-out lays its
target out in its first frame rather than inside the caller, and only when
the new view holds the old one.
* perf(studio): watch a waveform's undrawn ends only when it has some
A clip drawn whole has no undrawn ends, so it no longer mounts the two
empty markers the strip tracker watches; with hundreds of short audio
clips that saved an observer entry each.
* fix(studio): measure strips each time a zoom preview is laid out
A zoom-out lays its target out partway into the ease, after which the
strip tracker kept the stretch it measured before the zoom, so a long
filmstrip or waveform went partly blank near the end of the ease. Every
layout of a preview now re-measures the strips.
* docs(studio): keep the zoom-to-range doc comment within four lines
* docs(studio): keep the zoom files' comment share at or under main's
The comment ratchet failed on ten files this branch touches. Comments are
cut or folded into one line; no code changes.
* test(studio): launch real-Chrome tests like the e2e launcher, bounded by the test budget
* test(studio): share the real-Chrome page setup between the two runtime tests
* test(studio): keep the real-Chrome test helper with the other test helpers
* perf(studio): parse the saved file once to sync the composition length after a timeline edit
* perf(studio): keep empty duration updates free of parsing
* test(studio): pin one parse for rootless moves and the delete length readout
* test(studio): check the delete's length readout before its save lands
* test(studio): bench moves pressed right after Add keyframe
* fix(studio): an undo that reloads the preview keeps the selection, so a drag after it moves
* fix(studio): a drag started while a resize saves keeps its animations paused
* fix(parsers): an edit pins no position on a keyframed tween it did not touch
* fix(studio): a move pressed while the preview changes lands on the new preview, at the time pressed
* test(studio): bench waiting presses, a held box resized twice, and reloads at the last playhead
* refactor(studio): tidy the waiting press, bound its wait, and freeze edit stamps after early exits
* test(studio): load the property panel once so its first test stops timing out
* fix(studio): presses queued on a held box keep their release, hover and newest outline
* test(studio): judge bench undo by the history groups Studio claims, not by file writes
* refactor(studio): one waiting-box lookup in the bench and one raf-pause write per release
Behaviour-identical tidy of the waiting-press work: the bench reads the waiting
box through one helper, releaseActiveGesture sets the raf pause once, clearPointerState
writes the false it always computed, and previewGestureStarts calls the opts setters
directly instead of through aliases named like the gesture hook's gated setters.
* fix(studio): a queued press lands on the element it pressed and survives a window switch
* fix(studio): undo cancels a waiting press, a stuck save stops holding presses, scene swaps hold them
* refactor(studio): keep the complexity waiver on clearPointerState itself
* fix(studio): undo of a queued press leaves nothing waiting, and hosts keep their own undo
* fix(studio): a waiting press keeps the box still after a blur, and undo reports what it took back
* style(studio): bring the PR's comments within the comment limits
* fix(studio): bank the four bench cases this fixes and meet the comment, complexity and duplication gates
* test(studio): pin that a waiting press is never a pending edit, and name the new duplication waivers
* fix(studio): an offline preview says GSAP could not load instead of an unhandled Event
* fix(studio): the preview error list survives a second capture attach without duplicates
* fix(studio): the console capture keeps listening after a long early error list
* refactor(studio): the console capture owns every reset of its findings
* fix(parsers): dragging a keyframe keeps the keyframes' ease
* fix(parsers): splitting a keyframed tween into groups keeps its eases
* fix(studio): keyframed tweens keep their eases when Studio rewrites them
Extending a keyframed tween to the playhead and merging a gesture recording into it now carry the tween's eases and each keyframe's own ease. The parsers no longer report a tween-level easeEach, which GSAP ignores, as the keyframes' ease.
* fix(studio): a gesture merged into a tween writes rounded keyframe percentages
* fix(studio): a gesture merged into an eased tween plays at the times it was recorded
Merged keyframes are placed through the tween's run ease, as the extend path already does, and recorded constant-speed segments stay linear.
* fix(studio): the ease card describes a keyframed tween by its keyframes and eases
The summary line read 'no properties yet using a none curve' for every keyframed tween. It now names the keyframed properties, the keyframe count, the segment ease and the run ease that GSAP plays.
* fix(studio): a gesture merged over a strong ease-out keeps its keyframes and the ones before it
The merge keeps or replaces old keyframes by when they play, and rounds percentages only when the run ease does not warp time.
* fix(studio): the ease card labels an unset segment with the ease GSAP plays
* fix(studio): the ease card header shows the segment ease its rows play
The header shows the one ease every segment plays, or Mixed, and a run ease other than none gets its own line.
* fix(parsers): keyframe percentages are written as decimal keys the parsers read back
A percentage below 1e-6 printed as '1.28e-7%', which both parsers reject. One plainPercentKey owner now writes every percentage key in both writers and the unroller.
* fix(studio): the ease card's segment rows show rounded percentages
* fix(studio): a size edit right after a resize is its own undo step
* fix(studio): a nudge still saving is recorded before the next edit
* fix(studio): published types name cn by its package, not a node_modules path
* fix(studio): drop baseUrl so declarations never name a node_modules path
* fix(studio): an edit started inside the save of another edit never flushes
* fix(studio): an edit made while a nudge is still saving writes after it
* fix(studio): a later edit never overtakes one still waiting on a nudge save
* fix(studio): undoing a gsap.set clears what it applied from the preview
* fix(studio): an edit never waits on itself behind a nudge save
* fix(studio): a second nudge burst saves when its commit runs behind the first
* fix(studio): undoing a W on an animated box clears the width it set live
* fix(studio): any GSAP edit that drops a live-applied set clears it from the preview
* fix(studio): a soft reload clears exactly the set props a live patch applied
* fix(studio): name width and height as set-patch props
* test(studio): bench a plain element animated through auto-record and Add keyframe
* fix(studio): seed a first tween from the offset a plain move left in CSS translate
* test(studio): bench resize then drag on a GSAP tween, root and nested
* fix(studio): a resize under auto-record keys size at the playhead, held at all times
* fix(studio): keyframe tweens Studio writes end on their last key, so a seek matches playback
* test(studio): keep the plain-to-keyframes moves inside the nested frame
* fix(studio): a resize moves its anchor from the drag stamp it read at release
* fix(studio): an undo shown in place is no longer replaced by an older reload
* refactor: split the trailing keyframe trim and drop an unused GSAP reader
* test(studio): settle the resize-then-drag bench steps so a two-save resize is one undo
* fix(studio): a preview reload waits for an undo shown before its write lands
* fix(studio): Add keyframe reads a subtracted calc() translate with its sign
* refactor: tidy the keyframe hold, trim and resize code after review
* fix(parsers): the keyframe trim leaves looping, chained and relatively placed tweens alone
* fix(parsers): a size hold pins only a lone key, so an edit never changes frames left alone
* fix(studio): every undo applied in place counts as a preview change, script-only ones too
* fix(studio): a resize keys size only when a move or size is keyframed, not a fade
* test(studio): a bench step whose save never lands fails the case
* fix(parsers): holds and trims change only the tweens an edit touches
* test(studio): bank the plain-to-keyframes and resize-then-drag bench cases
* fix(studio): a host can claim its writes under the key Studio's edit history uses
* fix(studio): drop the claimKey comment, the comment share may not rise
* perf(studio): move the live tweens in place after a timeline move instead of re-running the script
* fix(studio): pair a live retime with the script's own tweens, not the nested composition timelines
* fix(studio): leave the runtime's filler tweens out of a live retime's pairing
* refactor(studio): move the live tweens in their own step of the timing sync
* perf(studio): read nested files only when a timing edit re-runs the script
* fix(studio): move live tweens only when the live timeline is exactly what the script parser read
* fix(core): a rebound timeline is padded and timed like a fresh load
* refactor(studio): decide unknown tween lengths in the plan and check order swaps only on a move
* fix(studio): re-run the script whenever moving the live tweens could differ from a fresh load
* fix(studio): keep trims and reformatted scripts on the fast path, re-run for delays and hosts
* fix(studio): re-run for tweens inside a sub-composition host or that change order on an element
* fix(studio): ignore layout inside raw script values when matching a reformatted preview script
* refactor(studio): check each moved element once and scan nested timelines only for moved targets
* docs(studio): keep the live-retime comments within the merge hook's rules
* fix(studio): place GSAP step lists and duration-less tweens where GSAP plays them
* refactor(studio): drop narrated comments and unnest the extend clamp
* fix(studio): match keyframes in time, resolve partial step timing, start readout from prior tween
* fix(studio): time step-list keyframes from the parts' last end and format
* refactor(studio): trim comments to the package's comment share
* fix(parsers): apply timeline defaults as GSAP does to step lists and motion paths
* fix(studio): keep GSAP's ease for motion paths with keyframes and read finished tweens
* refactor(studio): read a live motion path in its own step
* refactor(parsers): leave step-list timing to its one owner and skip timeline defaults there
* refactor(studio): move the live motion-path read into its own module
* test(parsers): pin an unresolved length for a step list stretched by a variable duration
* fix(studio): time keyframes linearly under an outer ease that overshoots or steps
* fix(studio): time a converted expression-duration tween from its live tween, and pin no rewrite
* fix(studio): undo no longer snaps back a box you started dragging again
* fix(studio): undo reloads the preview after the drag ends, and the bench checks it
* test(studio): leave the edit bench sequence for the resize-then-drag fix
* fix(studio): the undo reload after a drag also refreshes the restored scenes
* feat(studio): hand-move and hand-resize any number of selected clips
* test(studio): bench dragging and resizing every clip, frame cost and drop time
* test(studio): give the bench browser launch the run timeout
* test(studio): bench request timeline offsets
* fix(studio): joining or leaving a multi-clip drag restyles a clip instead of remounting it
* fix(studio): restore the linked-selection import and mark the drag bench complex
* test(studio): find a clip's track row through the per-clip wrapper
* test(studio): resolve track rows through the per-clip wrapper in the remaining cases
* perf(studio): write a group edit's GSAP changes as one request per file
* test(studio): cover the batched GSAP write and keep the owned-chain cases
* test(studio): bench profile of the drag's pointer moves
* perf(studio): sync a group edit's root duration once per file, not once per clip
* feat(studio): a timeline move registers a still-saving revert so Cmd+Z right after it need not wait
* test(studio): the reverted move stays reverted when its save lands
* test(studio): bench prints the heaviest call chain on request
* perf(studio): preflight a many-clip selection against one index of the live tweens
* test(studio): share one timeline across the indexed lookups
* test(studio): bench failure output skips resource 404 noise
* fix(studio): the live-tween index skips timeline entries that are not objects
* fix(studio): the live-tween index skips a null timeline entry
* test(studio): bench reports the first drag frame apart from the steady ones
* test(studio): bench lists inclusive time per function on request
* test(studio): bench reports when the last write of an action landed
* test(studio): bench reports medians of save, frame and first-frame times
* refactor(studio): move the live-tween index out of gsapRuntimeKeyframes to keep it under the line cap
* fix(studio): wire the live-tween index imports and drop an unused test binding
* style(studio): format the files CI flagged
* fix(studio): keep the bench and the scale helper out of fallow's findings
* refactor(studio): one exact tween-index lookup, finish a batch file once, reuse the duration sync
* fix(studio): the tween index lists a tween once per key
* fix(studio): restore the batch-finish and named-parameter helpers
* fix(studio): undo reverts an edit still saving before painting an older predicted step
* style(studio): format the batch duration sync
* chore(studio): keep the new comments within the block and share limits
* test(studio): settle the pending edit even when the undo-order test fails
* perf(studio-server): retime every clip in a GSAP batch with one parse and one hold sync
* test(studio-server): a batch of clip retimes writes what single requests in turn write
* style: format the retime fold and its tests
* perf(parsers): clip matchers in one retime share a DOM query cache
* perf(parsers): look up every clip id in one DOM walk when retiming
* perf(studio): re-resolving the same selected node keeps its source check
* perf(studio): a drop re-renders only the selection that actually changed
* test(studio): report main-thread task time of a bulk drop
* perf(studio): a group drop updates the timeline store once, not once per clip
* fix(studio): re-reading index.html keeps sub-composition keyframes
* refactor(studio): one owner for clip-retime no-op rules and selection options
* fix(studio): reuse a source check only for the same target, and re-check on a new cache version
* fix(studio): undo confirms a reverted save only once its history claim counted
* refactor: split a retime's application out of the one-parse fold; share test fixtures
* perf(studio): drop the per-clip wrapper node so timeline scrolling stays within budget
* refactor(studio): name the drag passenger style after the passenger it styles
* fix(studio): undo keeps a move undone when its history claim landed before the key
* fix(studio): undo a timeline move and its tween shift in one step
* refactor(studio): one owner of a timeline gesture's undo window
* refactor(studio): move single-clip move and resize into their own hook
* fix(studio): a reload or second tab never joins another page's undo step
* fix(studio): a delete and its ripple stay one undo step however late the ripple lands
* fix(studio-server): date a held undo step by its last write, not by the edit that ends it
* perf(studio): long clips mount only the picture tiles in view
A clip's picture strip mounted one tile per frame width, so a 10-minute
clip at full zoom mounted 18,000 tiles. The strip-size hook now also
reports the strip's on-screen span (refreshed on scroll, resize and clip
moves), and the video, image and composition strips mount only the tiles
inside it.
* refactor(studio): read the strip span outside the state updater
* fix(studio): a dragged long clip keeps its picture across the screen
The strip refreshed its span only on scroll, resize or a style change on
its own clip, but a drag moves the ghost through a wrapper, so a long
clip's ghost went blank past about 600 px of drag. Each strip now marks
its unmounted ends and re-measures when either nears the screen,
whatever moved it, and commits before paint. The tile row is one shared
ThumbnailTiles for the video, image and composition strips.
* fix(studio): warn of a tile gap inside the timeline scroller too
* fix(studio): clip strips re-measure together, one layout per frame
With row virtualization off the timeline mounts every clip, and each
strip had its own scroll listener and frame that read layout and then
committed. A scroll jump changed every strip's span, so a 1,000-clip
timeline laid out about once per clip per frame (the viewport gate's
1,000-row arm went to ~3 s frames). All strips now share one scroll
listener, observers and frame: every position is read first, then every
update commits in one batch.
* perf(studio): a scroll re-renders only the clip strips crossing the screen edge
A strip's span is clamped to its own measured width, and each strip keeps
its current size outside React so an unchanged size never calls setState.
A clip wholly on or wholly off screen then does no work on a scroll; only
strips straddling the edge re-render.
* perf(studio): a scroll re-measures only clip strips near the screen
The shared frame read every mounted strip's position, so a timeline of
1,000 unvirtualized clips forced about 1,000 style-and-layout passes per
scroll frame. An IntersectionObserver now tracks which strips are within
256 px of the screen; a scroll re-measures only those, and a strip is
measured as it comes near. A clip wholly off screen mounts no tile.
* test(studio): share the strip test setup through the root harness
* test(studio): a strip is measured as it comes near the screen
* fix(studio): a scroll jump measures the clips it brings on screen in the same frame
Each frame moves every strip's last measured box by its scroller's offset
change and reads only the boxes that land within 256 px of the screen. A
jump therefore measures exactly the strips it brings into view, with no
blank frame, at the cost of a short scroll; strips far away get their span
from the moved box without a layout read.
* perf(studio): a strip off either side of the screen keeps one empty span
* perf(studio): a clip strip far above or below the screen mounts no tiles
* perf(studio): a scroll frame leaves off-screen clip strips untouched
* perf(studio): short clips keep every tile and do no work on a scroll
A strip up to 4,096 px wide keeps all its tiles, as before this change,
and a scroll frame skips it; only long clips mount the tiles in view.
Short clips gain nothing from virtualizing and paid a re-render each
time they crossed the screen's edge.
* fix(studio): a scroll is never applied twice to a clip strip's position
Each strip remembers the scroll offset its box was read at, so a strip read
between a scroll and that scroll's frame is not shifted again. The empty-span
guards are removed: a near strip always starts inside itself and a far one
already gets nothing.
* fix(studio): a clip on screen keeps its pictures after a move and a scroll
A strip showing tiles is re-read on every scroll frame instead of trusting
its last box shifted by the scroll, which a move without a scroll (rows
removed above it, a dock resize) leaves stale. Tests now pin the vertical
shift, the 256 px band, the 4,096 px short-clip limit and the tile padding.
* fix(studio): the motion path draws on every load, not only when the layer's node is the frame's own
useMotionPathData found the selected layer with `instanceof` against the preview
frame's HTMLElement. In the Studio preview the body's nodes often carry the editor
window's prototypes (see core's runtime/domRealm.ts), so the check failed, the path
never got its anchor and drew nothing. Core's realm-free isHtmlElement owns that
question; both motion-path call sites now use it.
* fix(studio): every preview node check asks what a node is, not which window built it
Studio checked preview nodes against their document window's own constructors in
seek reapply, studio motion, timeline z-order commits, the manual offset drag and
the z-order menu. On loads where body nodes carry the editor window's prototypes
those checks fail silently, as the motion path did. They now use core's realm-free
predicates, and a source test fails on a new window-bound check.
* fix(studio): the webmcp preview helper asks what a node is, and both realm tests stub the frame
* fix(studio): the last preview node checks ask what a node is, and the guard sees any constructor read
The selector walk read ancestor ids only from editor-realm nodes and the audio group
observer never saw a group the preview added. Both use core's predicates now. The guard
flags any DOM interface read off an object, the spellings it missed included, and the
window gates the old constructor needed are gone.
* test(studio): cover the main seek filter across windows and split member reads
* fix(studio): a press on the motion path's line inside the selected layer moves the layer
* fix(studio): a press inside the selected layer moves it, and path nodes sit where the layer is
* refactor(studio): one helper places a path point, for keyframes and the start
* fix(studio): a handle over a path node takes its press; nodes sit right on centred layers
* fix(studio): reading a layer's path anchor leaves its CSS translate alone
* chore(studio): keep the motion path home file under the comment share
* fix(studio): a new motion path ends where you click on a CSS-centred layer
* fix(studio): a path made on a transform-centred layer ends where you click
* style(studio): keep a motion path test comment within 120 columns