* feat(studio): let a host hide timeline history, place the shortcuts button and set track padding
* fix(studio): clamp host track padding and pin every padding reader with mounted tests
* fix(studio): resizing a faded or moving element writes a plain size, not keyframes
* test(studio): the fade resize test catches every keyframe mutation
* perf(core): the preview loads only the media on screen or due next
Studios preview bound every timed video and audio at preload=auto and called
* perf(core): a far clip in the preview stays unloaded until it comes due
A trimmed clip outside the window now waits at preload=none, reloaded so a fetch
the parser started stops too; at metadata, 60 clips' header reads still queued
on the origin under a slow link. An untrimmed clip keeps metadata, since its
window is read from the element's duration.
* fix(core): a far preview clip makes no request before it comes due
Chromium keeps fetching a clip once it has started, whatever preload says after,
so the reload at preload=none from the bind only restarted the fetch. In Studio's
preview the runtime now sets preload=none on each trimmed clip after the first
frame as it is parsed, and reloads only a clip the window armed when it leaves.
* perf(core): a playing clip loads the next clip on its track
At 3 MB/s a cold 1080p clip needed about 3.3 s to show a frame, longer than the
2 s look-ahead, so every clip on a one-track film was still empty when it came
due. While the film plays, a clip that starts now arms the next clip on the same
track (authored track index within one composition host, read as the timeline
payload reads it), and the window pass keeps that clip armed. Paused or
scrubbing, only the look-ahead applies.
* chore(core): say in one line why the preview parses later clips at preload none
* fix(core): the Studio timeline stops waiting on clips the preview left unloaded
Studio's timeline readiness scans every media element for canplay, so each far
clip the preview deferred held it until the 8 s timeout. In a document with the
Studio preview mark, a clip the runtime has not set to buffer now counts only
if it is on the first frame, as a lazy image already does.
* fix(core): a clip leaving the preview window closes its fetch on a slow link
Chromium keeps a fetch in flight when preload drops to none and load() runs, so
on a 3 MB/s link each played clip kept its connection and the armed next clip
queued behind them with no bytes. The release now drops src around the reload
and puts the same attribute back, which ends the fetch without a new one.
* refactor(core): name the authored-length check for what it reads
* fix(player): a clip the preview stops preloading drops its parent-frame copy
The player adopts each iframe clip whose preload turns auto into a parent-frame
proxy that fetches the whole file, but never let go when the runtime set the
clip back to none. On a 3 MB/s link those proxies and the thumbnail reads held
all six connections, so the armed next clip got no bytes. A demoted clip now
releases its proxy through the same path a removed clip uses.
* chore(player): keep the proxy adoption note in one place
* perf(studio): pause timeline thumbnails while playing preview media waits
A playing preview clip that fires waiting now holds every thumbnail job and
aborts the ones in flight until the transport stops; they re-run afterwards.
An aborted job frees its slot at once, and a filmstrip decode closes its
range requests on abort.
* Revert "perf(studio): pause timeline thumbnails while playing preview media waits"
This reverts commit 36926ebf22.
* fix(core): preview keeps loop-start clips loaded and drops arms a jump leaves behind
Studio's loop tick now tells the runtime where a wrap lands (window.__hf.setLoopStart), and
while playing the preview keeps the clips due there loaded, so a wrap no longer starts cold.
A next-on-track arm lasts only while the clip that set it plays on screen, so a jump away
releases it. A clip with no authored length stays out of the window and loads as in a
render, so no reload drops its duration. A clip is held until 4 s ahead after it is armed
at 2 s, so a scrub or a pause at the edge does not refetch it. The parse-time watcher is
installed only in the preview, once per page. One helper stops a clip's download, <source>
children included, for released and detached media alike.
* fix(core): a loop wrap also keeps the loop-in clip's next clip loaded
The loop start's clips are held out to the 4 s release distance, as a clip being left is, so
the wrap no longer reloads the clip after the loop-in one from nothing.
* fix(core): the preview leaves clips on <source> children out of its release
Putting a clip's <source> children back after the reload started a new download and moved them
ahead of its other children, which a scene swap reads as an edit. Release now stops only a src
clip's fetch; detached media is dropped as on main. Tests cover the loop hold's playing check,
its time check, and the untrimmed guard on the next-clip arm.
* style(core): drop a release comment the commit message already carries
* fix(core): arm a nested clip timed in root seconds by its real start
* fix(core): keep a clip loaded for a step back across its end in the preview
* fix(studio): keep a dropped clip on the row it was dropped on
* fix(studio): keep group moves, new-track file drops and audio drops where they were aimed
* fix(studio): drop assets on the row's own track and keep locked clips as obstacles
* fix(studio): keep multi-file audio drops together and stop locked clips sliding in the drag preview
* fix(studio): read a dropped asset's track from every clip of the target file
* refactor(studio): move the drag preview and shell wiring out of the timeline provider state
* docs(studio): drag floor comments name the host start, not 0
* docs(studio): shorten the drag commit and landing comments
* docs(studio): the drag commit comment says a new track renumbers rows
* fix(studio): a clip released on its own spot stays there
A clip whose neighbours end off the centisecond grid no longer jumps to the end of its row
when dropped back where it was; the snap guide clears when the row moves the clip.
* fix(studio): a clip keeps its own spot when float sums overshoot a neighbour
0.333 + 1.733 is 2.0660000000000003, so the own-spot check allows a hair of slack at both ends.
* fix(studio): with keyframes hidden, a keyframed clip no longer opens the track-name column
* style(studio): format the audio-group column test
* test(studio): the ruler origin is 80 px when hidden keyframes open no column
* fix(studio): the timeline follows a paused playhead and zoom keeps the playhead in place
* test(studio): pin a paused on-screen seek past the playback follow line
* style(studio): format the follow change and trim its comments
* fix(studio): only a person's zoom anchors on the playhead, not a pin or a resize
* test(studio): pin that a toolbar zoom is counted as a person's zoom
* fix(studio): keep a paused timeline scroll when the preview reloads after a keyboard pause
* fix(studio): publish the paused time so a reverse shuttle stop keeps the timeline scroll
* fix(studio): follow a paused playhead only on a seek, not when a reload republishes the time
* fix(studio): keep a reloaded preview's hand-over from counting as a person's seek
* fix(studio): keep a paused timeline still during a beat drag and after a preset audition
* fix(studio): keep a paused timeline where a person put it while they trim a clip
* feat(studio): the timeline publishes where it draws 0 s, so a host can map a click to a time
* style(studio): keep the provider types' comment share at its base
* fix(studio): clips inside nested compositions sit at their master time
* fix(studio): nested clip starts read authored scene lengths as the runtime does
* test(studio): drop a reference-start case the DOM fallback never reads
* test(studio): a clip inside a referenced scene sits after its authored length
* fix(studio): drag and trim a nested clip to where it is drawn
* fix(studio): keep a root-time nested video's drag in master time
* fix(studio): duplicate and keyframe edits on a nested clip use its own clock
* fix(studio): nested clip drops stop at the host start and trims scale on its clock
* fix(studio): a nested clip's head trim stops at its host's start
* fix(studio): a dropped nested clip stops at its host's start before snapping
* fix(studio): move only the dragged word, not every word sharing its tween
A drag on one element whose position tween also targets its siblings (a stagger on a
shared class) now persists that element's own offset instead of rewriting the shared
tween. The motion-path overlay leaves such a tween read-only, and every write of one
drag records as one undo step.
* fix(studio): keep the comment share flat in the word-move fix
* fix(studio): save a shared-tween word's move as left/top on that word
A CSS translate offset on an element a GSAP tween still drives gets folded into GSAP's
transform, so render, preview and a second drag disagreed. left/top is never parsed by
GSAP, adds to any offset the word already has, and is refused when it would not shift
the box exactly. The resize anchor move takes the same channel, and tweens that miss the
element or are shared with siblings no longer steer a drag that has its own tween.
* refactor(studio): drop the untested own-tween selector override in the drag
* fix(studio): keep a Layers-picked word's move and make a resize one undo step
A word picked in the Layers panel is lifted to position:relative for display only; the
move now reads the authored position, saves position:relative, and survives deselect.
An anchored resize saves its move after the size, under the same undo key, and drops it
when the size save fails. A percent left or top gets its own refusal message.
* fix(studio): give the host canvas hook the per-word left/top move
The host geometry hook now stages a shared-tween word's move with the same left/top
offset as the editor, saved through the host's patch path, so a Desktop drag of one
word moves only that word.
* fix(studio): keep host word moves saving after one failed save
The host canvas hook reset its save queue per save, as the host style hook does, so one
conflict no longer pauses every later word move. A save error the patch path already
showed is no longer covered by a generic failure toast.
* perf(studio): clicking an element in the preview selects it without restyling the whole film
Every hit test added a `* { pointer-events: auto !important }` style element to the
preview document and removed it again. Each insert and removal restyled every element,
and the head mutation made the off-canvas indicators rebuild their layer walk from
scratch. The override only let pointer-events:none elements into the hit list, and the
author pointer-events filter removed them again, so the hit test now uses the browser's
own result: the candidates are what Chrome itself hit-tests.
* docs(studio): the double-press hit test comment no longer claims it lifts pointer suppression
* fix(studio): undo and redo swap the restored scene in place instead of reloading
* fix(studio-server): a preview asked for right after an undo shows the undone state
* fix(studio): an undo that restores a page outside every scene still reloads in full
* fix(studio-server): a preview built across a write is not cached under the old signature
* test(studio): a soft undo keeps the scene hashes so the next edit still swaps
* feat(studio): a host can save canvas moves, resizes and rotations with the handles
* fix(studio): the canvas overlay accepts commits that resolve to an outcome
* fix(studio): host resizes undo on a failed save and refuse without a timeline session
* style(studio): wrap long lines and trim a comment
* fix(studio): host geometry saves refuse until the preview has loaded
* feat(studio): one timeline tool picker with select leftward and rightward
The Selection and Razor buttons become one button showing the active tool, with a menu:
Select (V), Split (B), Select leftward ([) and Select rightward (]). Leftward and rightward
select every clip, on every track, that starts before or at/after the playhead.
* test(studio): toolbar order and label follow the tool picker
* fix(studio): select leftward and rightward use the live playhead and the usual selection resets
* style(studio): keep playerStore's comment share at its base
* feat(studio): a host can hide the timeline's keyframe lanes and diamonds
* refactor(studio): read the timeline's keyframe data through one gate
* fix(studio): hidden keyframes keep the track names in the timeline header
* test(studio): check diamonds on a collapsed clip and lanes on a keyframed one
* style(studio): format the keyframes switch test
* fix(studio): hide handles Studio would refuse to commit
Studio showed move, resize and rotate handles on animated elements whose
motion it cannot write back (a helper or loop, a runtime-computed value, a
live tween with no matching source). The drag ran, the commit was refused
at release, the element snapped back and a toast explained why.
The commit's refusal rules now also run when a selection resolves:
- move uses the existing drag preflight, now exported
- rotation and resize rules are extracted into preflight functions that the
commit paths call first, so both use the same decision code
- the session narrows canApplyManualOffset / Size / Rotation (with the
refusal's message as reasonIfDisabled) in one place, and the chrome,
nudge, group drag and design panel read that unchanged
- until an element's first check lands, its manual flags stay closed
A press on a box that cannot move now shows the reason at once instead of
after 4px of travel.
* refactor(studio): read the rotation preflight selector once and derive the scale flag
* fix(studio): make the handle check read what the commit reads, and never stall
- Match tweens to an element the same way everywhere: the animation fetch
used by the handle check and by group moves now also matches through the
live element, so an element a class tween animates keeps its handles.
- The handle check reads each file's parse once per edit version. A file with
no tweens is an answer, not a cold parse to retry, so plain elements get
their handles after one read and later selections in that file at once.
- A failed read is not remembered: the next selection asks again.
- While the check is still running a press stays silent, and only the primary
button explains a blocked press. A group press with a blocked member now
says why instead of doing nothing.
* fix(studio): check handles per project, keep answers on failed reads, refuse shared group tweens
- The handle check's parse cache now uses the same project and file key as
the parse request, so switching projects never judges one project's file
by another's parse.
- A failed re-read after a save or undo keeps the last good answer and asks
again on the next selection, instead of closing the handles.
- A group move stays refused when a member's motion comes from one tween
shared with other targets, as before: each member would write into the
same tween. The group check and the group commit use the same rule; a
single selection still edits the shared tween.
- The element-to-tween matcher moves to its own module so the move rule can
use it without an import cycle.
* docs(studio): the group move rule comment says which tweens it excludes
* feat(player): play and loop a range of the film with range-start and range-end
The runtime takes a set-play-range control and stops on the range end frame itself.
The player wraps to range-start with loop, fires ended without it, and reports a
range cut to the film with rangeclamped. Video and __timelines players check it per tick.
* fix(player): hold a range on its last frame and let the runtime own range jumps
A runtime with the play-range capability jumps to range-start itself when a new range leaves
the playhead outside, so a stale state no longer ends the film; older runtimes keep the
player fallback, guarded until a state lands inside. Every range stop shows the last frame
before range-end; a paused playhead re-parks only when it falls outside the new range.
* fix(player): stop a range a check early and enforce its end on a video in a background tab
* test(player): share the range video setup
* fix(player): a slow frame no longer cuts a range short; a video without a range is unchanged
* fix(player): a range still stops early where video time moves once per frame
* refactor(player): cut the range look-ahead comment to one line
* fix(player): a per-frame video time rounded down still stops a range early
* test(player): pin no rounding tolerance at a film's own end
* test(studio): expect the play-range capability on control messages
* feat(studio): a host can hide the timeline's audio effects controls
* test(studio): share the whole-timeline mount setup between timeline tests
* fix(studio): hidden audio effects also take the effect-rack shortcut off lane names
* test(studio): share the gain-automated group fixture
* test(studio): use the shared group fixture in every automated-group test
* fix(studio): a disabled group lane name does not light up on hover
* refactor(studio): keep the timeline provider and lanes under the file size limit
* refactor(studio): format the lanes row indexes within the size limit
* feat(studio): a host can save style edits on a selection through Studio's own style commit
* fix(studio): drop an import the moved writer no longer needs
* fix(studio): host style saves recover after a failure and never revert a later edit
* fix(studio): an escape cancels a preview marquee band and stops there
* fix(studio): name the band escape handler instead of commenting it
* test(studio): check the band is gone before the pointer is released
* fix(studio): drilling in opens the composition's full project path
* fix(studio): keep the shared source-path helper as is and trim ./ only for the drill path
* fix(studio): a project folder named preview keeps its path
* perf(studio): swap an edited scene into the live preview instead of reloading
On a preview reload, Studio fetches the rebuilt preview document and asks the preview to swap
in only the scenes that changed. When the preview cannot or will not swap (it predates the
swap, a full reload is already running, or the document changed outside its scenes), Studio
does the full shadow reload as before. A document from an older reload is never swapped in.
* fix(studio): re-sync selection and layers after a scene swap
A swap replaces scene DOM without a load event, so selection, manual
edits, the Layers panel and the edit callout kept pointing at the
replaced nodes. They now listen for either a load or a swap.
* fix(studio): drop a stale scene swap once the preview is replaced
A swap still pending when the preview reloaded or switched composition
could fall back to reloading the old one. Color grading and its compare
view are also re-sent after a swap.
* docs(studio): say exactly when the preview generation changes
* refactor(studio): cut scene swap comments to what names and types do not say
* fix(studio): fall back to a full reload when a scene swap download stalls
* fix(studio): give up on a scene swap that stalls at any step, not only the download
* fix(runtime): a scene swap refuses when an animation outside the scene moves its elements
* test(runtime): pin the scene swap volume re-probe, host CSS variables and diagnostics-free swap
* fix(runtime): a scene swap keeps a video its scene script animates instead of reloading it
* fix(runtime): a scene swap stops every animation the old scene script started
* fix(runtime): record scene script animations only on pages a scene swap can act on
* docs(core): reword the scene animation recording comment
* fix(runtime): watch media as the page parses only on pages a scene swap can act on
* perf(runtime): a scene swap checks for outside tweens in one pass over the film's tweens
* test(runtime): pin the single revert and the cleared animation record of a scene swap
* test(studio): pin that a playing film keeps playing through a scene swap
* fix(runtime): a scene swap rebuilds media when the edit changes the scene script
* fix(runtime): a scene swap undoes the sets a scene script made
* fix(runtime): a scene swap rechecks outside tweens and runs new scripts after every host
* test(runtime): pin that a tween started during the caption wait leaves the page untouched
* fix(runtime): a scene swap refuses when its script set a value on an element the swap keeps
* docs(core): say the scene recording drops a finished tween that the timeline would keep when paused
* fix(runtime): a scene swap refuses when two of its animations write to an element it keeps
* fix(runtime): a scene swap resets kept media and refuses animations outside the scene
* fix(runtime): a scene swap keeps a moved video in place and swaps tweens on plain objects
* chore(core): regenerate the inlined position-edits script for the kept-video move reapply
* fix(runtime): a scene swap checks the timeline registry as it is after the caption wait
* fix(runtime): a scene swap refuses when a scene changed during the wait or a revert re-registers
* fix(runtime): a scene swap stops every animation a revert chain registers and rechecks its hosts
* fix(runtime): a scene swap refuses a moved host or a cancelled swap and stops at a shortened end
* fix(studio): a scene swap that times out is cancelled before the reload starts
* fix(runtime): a scene swap refuses when a scene leaves its place or the film during the wait
* fix(studio): a newer edit cancels an older scene swap still waiting
* fix(runtime): a scene swap checks only its host's place, so a later body append does not refuse it
* fix(studio): a scene swap cancelled before it starts does not run
* fix(runtime): a scene swap refuses when the film's scene layout changed during the wait
* fix(runtime): a scene swap refuses when the order around a scene changed during the wait
* test(runtime): pin that a scene swap checks the film root order when every scene is wrapped
* fix(runtime): a scene swap gives kept media the mute, rate and loop a fresh load gives it
* fix(runtime): a scene swap rebuilds media a script wrote attributes on, keeping the rest
* fix(runtime): a scene swap keeps media carrying the runtime classes or reordered attributes
* fix(runtime): a scene swap resets a kept video's volume as a load does, not through the volume probe
* fix(studio): timeline Fit fills the width with the film, and a host can hide keyframe controls
* fix(studio): keyframe tests read the claimed K press, and the fit span stays private
* fix(studio): an edit that changes the film's length keeps the timeline scale, and Fit is an icon
* fix(studio): manual zoom keeps its scale whenever only the film's length changes
* fix(studio): drop the width check the kept scale never needed
* fix(studio): a composition switch refits, and the kept scale clamps against the new fit
* test(studio): a project reset refits the manual zoom
* fix(studio): back to the master after a nested drill restores the master playhead
* fix(studio): every way back to the master restores its playhead, 0 included
* fix(studio): the timeline playhead follows the restored master time
The timeline canvas unmounts while a composition level loads and remounts
with its playhead drawn at 0. The playhead effect only re-ran on a time or
zoom change, so a level switch that kept the time left the needle at 0 while
the readout showed the real time. It now also re-runs when the canvas remounts.
Drilling in during playback saved the store time, which playback does not
update per frame; the save now reads the live playhead.
* fix(studio-server): a cold proxy copy answers 202 at once and the preview retries until it lands
* fix(studio): timeline filmstrips wait for a clip's proxy copy instead of failing on the 202
* fix(studio-server): a copy that cannot be made reports its failure instead of answering 202 forever
* test(studio-server): pin that a full queue is not remembered and a reset probe stops waiting
* test(studio-server): pin that a failure outside ffmpeg is remembered too
* style(studio-server): keep comment share at base in the transcoder and decoder
* fix(core): a clip's proxy URL goes on the video only once the copy is served, so every reader of it works
* fix(player): the parent media mirror follows a clip's src, so it plays the preview copy once it lands
* perf(player): the mirror re-points a clip only when the parent takes over playback
* style(core): shorten the sync-state comment in the proxy swap
* fix(studio): the timeline follows a clip re-pointed at its preview copy
* fix(core): a failed readiness check is retried instead of leaving a clip on its original
* fix(studio-server): a composition card rendered while preview copies are made is not cached
* fix(core): frame captures wait for a pending preview copy as long as for a loading video
* fix(studio-server): the preview-copy check uses the shared realpath from main
* fix(player): re-pointing a clip onto another clip's file no longer plays that file twice
* fix(player): a clip that replaces another on the same file keeps its sound
* fix(studio): read and write a clip's in-point the way playback does
* fix(studio): a group head trim keeps the minimum clip length off the grid
* fix(studio): a group head trim stops where a single-clip trim does and never goes below zero
* fix(studio): group members on the grid move together when a trim stops at its limit
* fix(studio): level-out measures and places its lift on the clip clock at any speed
* fix(studio): round level-out lane times and tighten the half-speed test
* fix(studio): carve and duck follow each clip's trim and speed
* fix(studio): carve ignores speech after the bed stops playing
* test(studio): carve ignores speech past a bed that ducks and has no duration
* fix(studio): carve cuts speech past the bed's end at every strength
* perf(studio): light ui and player entries for a host's first screen
* perf(studio): the ui entry's logo no longer loads the studio header
* test(studio): refuse only packages studio itself depends on
* test(studio): the light entries also refuse the hf-ids parser
* feat(studio): export DOM editing for a host outside EditorShell
* fix(studio): host hears only single-box clicks, and a handle release no longer eats the next one
* refactor(studio): cut the sibling z-order comment to one line
* fix(studio): releasing a clip drag outside the window cancels it
Pointer capture delivered the release to the timeline even outside the window,
so the move or trim committed wherever its preview was last drawn. A release
outside the window now cancels the gesture, the same as Escape.
* test(studio): pin a release exactly on the window's edge as outside
* fix(studio): releasing a fade-handle drag outside the window cancels it
Fade handles run their own gesture, so they now use the same outside-window
check as clip moves and trims, moved into one shared module.
* feat(studio): export snapping, the marquee and picker describe for a host's own preview
* fix(studio): a host pick type must bring its own marquee resolver
* fix(studio): dragging an audio clip's edge trims it instead of moving it
The clip picture layer (waveform, filmstrip, stills) paints above the trim
handles and swallowed the press, so an edge drag started a move. The
picture layer now takes no input.
* docs(studio): say clip content takes no pointer input
Miguel Ángel