* fix(producer): page timers during a render run on film time
* test(producer): a regression film whose timer bars must follow film time
* test(producer): schedule the timers regression film in CI shards
* fix(producer): keep setup timers on the wall clock until the page reports ready
* fix(producer): keep the renderer's own waits and deadlines on the wall clock
* test(engine): fail CI on a bare timer in code the engine runs in the page
* fix(core): type the wall-clock timers like the global timers they replace
* chore(engine): drop the comment on the shim's window type
* test(studio): kill and retry a test Chrome that hangs after it starts listening
* docs(producer): say the setup budget bounds each step, not setup as a whole
* fix(producer): a failure before the first frame reports frame capture as its stage
* fix(producer): a failure after the effect scan reports frame capture, with a stable code
* fix(engine): a render no longer finishes without an image that loaded late
* style(engine): format the frame gate
* fix(engine): an image outside the frame no longer stops a render
* fix(engine): a render stops and warns when a frame's image never arrives, with no cloud retries
* fix(producer): a cloud chunk keeps the missing image's error name so retries stop
* fix(producer): segmented capture gives up on a session stuck opening or initializing
* fix(producer): sequential disk capture bounds the opt-in drawElement setup the same way
* fix(engine): a gpu-less linux host falls back from drawElement instead of hanging self-verify
On a GPU-less Linux headless shell asked for browserGpuMode "hardware", Chrome has
GPU args and no GPU, so getContext("webgl") returns null. detectGpuBackend read that
as { isSwiftShader: false }, the SwiftShader gate let drawElement engage on a
BeginFrame-launched browser, and self-verify on its truth page then stalled until
the render failed after about 300 s, with no fallback.
drawElementGate now decides the init-time fallback, each with a named deGateReason:
- swiftshader: any software GL (SwiftShader, llvmpipe, lavapipe, softpipe, Microsoft
Basic Render Driver), from one shared token list. Detection on real GPUs is unchanged.
- webgl_unavailable: no WebGL context could be created (null, or getContext throws).
- beginframe_no_self_verify: the browser was launched for BeginFrame. Its self-verify
truth page has no BeginFrame driver, so drawElement frames could not be checked, and
a Linux host with a GPU would stall the same way. HF_FORCE_DRAWELEMENT bypasses only
this gate.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(producer): windowed frames runs drawElement through self-verify and a recycle
Adds a drawElement case to the windowed-frames integration test: drawElement capture,
self-verify through the on-demand hook, and a browser recycle. It covers that hook
only on a macOS or Windows host with a GPU. Linux always gates drawElement away
(headless-shell launches for BeginFrame, which has no self-verify), and so does any
host with no GPU; there the case asserts the named gate fallback (swiftshader,
webgl_unavailable or beginframe_no_self_verify) and prints that drawElement did not
run. HF_TEST_REQUIRE_DRAWELEMENT=1 turns that fallback into a failure, for the hosts
that are meant to run it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* feat(core): motion blur reports what a composition holds, as counts
The runtime scans a composition once per blur scan, on both tiers, and reports
counts of what it holds (canvases, video, frames, custom elements, clips, masks,
scroll containers, 3D, blend modes, and movers that overflow, sit under other
content, hold fixed children or carry pseudo-elements outside their box), plus
whether pose reads need callbacks. Counts only: no ids, classes, text or URLs.
The engine puts the non-zero counts on its [motion-blur] line and hands the
parsed report to the perf summary; the producer aggregates workers (first report
wins, failed frames sum) and the CLI sends motion_blur_* properties on
render_complete, from the CLI and from Studio renders.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* fix(cli): disclose blur counts in telemetry docs, raise inspector budget
The runtime fingerprint code is bundled into @hyperframes/inspector, which
puts its unpacked size 2.2 KB past the 1% tolerance. The telemetry docs now
list the composition counts the CLI sends with a blur render.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
* fix(producer): render reads a composition src like the preview, refuses paths outside
* fix(producer): a src with an encoded folder re-points its sibling assets; format
* test(engine): blur browser tests fail on CI when their browser cannot run
On CI a missing Chrome, a missing core runtime build or a Chrome without drawElementImage
fails the suite's beforeAll instead of skipping every case. Off CI the suites still skip.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(engine): every inside-the-trail case proves blur drew, not only held-card
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(engine): the liveness test watches held-card through its slide-out
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(producer): stateful-callback joins the multi-worker blur render, split across five suites
The render differential's suite moves into __test_utils__/blurRender.ts and five files run it
over one or two fixtures each, so none nears the flake gate's 120 s cap. Every fixture that
moves must now blur more than insideMaxMae, not only held-card, and CI fails instead of
skipping when ffmpeg is missing.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(producer): each blur render file imports its runner so the test classification reads it
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
* fix(core): blur quiets discrete callbacks instead of undoing what they wrote
#7191 undid the DOM a callback wrote during the blur scan with a mutation journal. That
regressed once-guarded and memoized timeline callbacks: the callback ran, its guard flipped,
and the journal put the DOM back, so the real seek never wrote it again.
Mute GSAP's onStart, onComplete, onReverseComplete and onRepeat for the scan and for eventful
pose reads, then restore them. onUpdate keeps firing, so movers driven from it are still found.
muteDiscreteCallbacks replaces a callback with a no-op rather than clearing it
(hasZeroDurationCallbackTween reads typeof vars.onComplete), walks tween.timeline for staggers
and keyframes, and skips an animation already muted because scene timelines nest in the root.
The journal (journalDom, landThenUndoDom, putBack) is deleted. The loud rewind through 0 stays.
Measured in the spike (mute-spike-report.md, "Probe matrix and fresh worker"): every GSAP
pattern matches blur off in label and fire count; 8 of 300 comparisons differ, all the non-GSAP
row, against 248 of 300 on main. This supersedes the limit #7191 accepted. Mute and restore over
2002 animations is 0.2 ms.
Limits:
- A mover that exists only because a muted callback set it up is found only if that callback
fired before the scan. A worker starting before the call leaves that mover sharp while a later
worker blurs it; positions stay right.
- tl.call(() => gsap.to(...)) movers are never found and stay sharp.
- A non-GSAP adapter that ignores suppressEvents (adapters/animejs.ts) and writes DOM on a
once-only completion shows it early. Pinned by a KNOWN LIMIT test.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(producer): drop the once-guard-label block-start guard that pins a block that cannot fail
The guard required a block start in [1, 15], the worker at frame 9, and the comment said it
paints on both sides of the call at 16. Its frames after the call (16, 17) sit inside the
trail mask at the label, so that block cannot show the bug. The outside-the-trail case on the
7-worker partition is what catches the mutant; the fixture stays in FIXTURE_NAMES.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(engine): split the callbacks matrix in three and share one blur-off run per row
The matrix file took 247 s on an idle Mac and timed out at the flake gate's 120 s in all 10 reruns.
Each row now compares the arms against one blur-off page painted in order and one fresh page, not
a new blur-off page per arm and sequence; the in-order sequence is the first paints of the page that
goes back to the first time; rows run their pages together; the paint skips the full-frame PNG that
only the pixel tests read. Only the two arms with an onUpdate mover stay (both tiers): they run the
scan's mute and the per-frame mute, which the arms without a mover do not.
The rows and harness move to __fixtures__/motionBlur/callbackRows.ts and the matrix is split over
three files so each run fits the gate. Rows a to y, the three sequences, both tiers, row y and the
KNOWN LIMIT test are all kept; no assertion changed.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
* feat(producer): render long videos with windowed source frames, behind HF_VIDEO_FRAME_WINDOW
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(producer): windowed calibration sees real frames, and the late full extraction reports itself
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(producer): windowed frames match a full extraction, frame for frame
Renders ten compositions twice on the segmented route, with and without
HF_VIDEO_FRAME_WINDOW, and compares FFmpeg framemd5 of the two outputs: a
mid-clip start, NTSC 24000/1001, a loop crossing a slice edge, a playback-rate
ramp, a held tail, two clips of one file, a VFR source beside a CFR one, two
workers, auto workers (capture calibration runs), and motion blur, which
declines the window. Each pair must also report the same capture mode.
A separate test samples segment-frames during a four-segment, two-worker
render and holds its peak under workers x segment frames x the largest frame
file x 1.2, and checks the folder is empty once the render closes.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(producer): windowed frames test finds its own work dir and asserts what it claims
Find the render's work dir with resolveRenderWorkDirPrefix and the owner record's pid, so
the peak test works on Linux and never samples or deletes a concurrent render's dir.
Assert the measured worker count, calibration, and the exact up-front frame count of the
VFR video. Retry a dead Chrome only with HF_TEST_RETRY_BROWSER_STALL=1, and fail a case
whose windowed render alone needed it.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* fix(producer): windowed segments honour keep-segments and cleanup never fails a render
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(producer): trim the comments the windowed frames route added
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(producer): the VFR-beside-CFR extraction test moves to the integration lane
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore(producer): raise the package size budget for windowed video frames
The new segment frame modules add about 9 KB to the packed producer package.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(producer): windowed frames header says what the real runs measured
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* feat(producer): a capture segment extracts the frames it shows and deletes them when it closes
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(producer): the windowed video hook reads its own frames outside a prepared window
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(producer): trim the comments the segment video frames hook added
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(producer): deferred frame extraction moves out of the distributed code
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(producer): the real-ffmpeg deferred extraction test moves to the integration lane
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(producer): an export over the peak ceiling loses only what it must
The delivery limiter cut every peak over -1 dBTP down to -3, a fixed 2 dB margin for its detector. It now limits at -1, measures the encode, and lowers the ceiling only by what that encode measured over.
* fix(producer): the delivery limit test runs in CI and one pass is its own step
* test(producer): build the loudness reference from the 16-bit track the mixer reads
The distributed planner compiled the raw entry file, so a <template>-wrapped
sub-composition rendered alone had no live root, timeline or duration and failed
with "Composition has zero duration". Entry resolution now lives in
runCompileStage, which both the in-process renderer and plan() call.
— Jerrai
* fix(core): blur scan and eventful reads put back the DOM a timeline call changed
With data-motion-blur-events on, the mover scan runs the timeline to the end with
callbacks on and rewinds with callbacks on. GSAP fires a tl.call on a backward
crossing too, so the rewind left the earliest call's DOM effect in place: the
callbacks fixture showed label "B" from frame 0, before its 0.5 s call.
Calls cannot be un-fired, so the scan (and eventful per-frame reads) now journal
DOM mutations with a MutationObserver, land on the frame with callbacks on as
before (keeping JS-side call parity), then undo the journal back to the
pre-scan DOM, which is what a plain seek to the frame produced.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(engine,producer): callbacks label-early pins become ordinary outside cases
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* perf(core): the DOM undo skips attributes and text already back at their old value
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
* fix(core): a scrolled list keeps its offset when blur moves the root
Chrome resets a scrolled container's offset when the root leaves or enters the
document, so the first blurred frame of a fresh page or render worker drew the
list at offset 0. Offsets are read at move time and put back before the re-seek,
so a container that became scrollable after the scan is covered too.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(engine): scroll-list is an ordinary outside case, not a pinned known bug
The scroll offset now survives the root's move, so the three engine differential
cases and the multi-worker render case expect blur on to equal blur off, and the
measured constants for the old symptom go.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* chore(core): drop the scroll-offset comment, the comment-share ratchet may only fall
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
* fix(producer): pad/trim audio from the delivery PCM, not its own AAC
The assemble stage's duration fix decoded audio.m4a and encoded it again.
That second AAC generation read about 2 dB hotter on a measured mix
(-1.8 dBTP out of the audio stage, +0.2 after the trim), so the whole-mix
cut then lowered an already compliant film by 3.4 dB, overshooting to
-2.5 dBTP. A sibling project with a slightly louder music bed escaped the
cut, so the two landed about 4 LU apart.
- The local render keeps the audio stage's PCM in the work dir until
assembly; pad/trim and any peak correction there encode from it.
- A whole-mix cut in the audio stage is applied to that PCM too, so it
still encodes to exactly the delivered AAC. If it cannot be rewritten
it is removed and assembly falls back to the AAC.
- The distributed plan does not keep the PCM, so its plan dir is unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(producer): name the assemble stage's PCM input by what it is
The comment-ratchet does not let assembleStage.ts gain a comment line, so
the new input says what it holds in its name instead.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HebQXN7wsMK6GqT3MNtqXw
* fix(producer): assembly never reuses a PCM whose delivered cut was not applied
When the audio stage cuts the whole mix and then fails to rewrite the kept
PCM, it tries to delete the PCM. Deletion is best-effort and can be refused,
for example on Windows, so the uncut PCM could stay on disk. The audio stage
handed it to assembly because the file still existed, and assembly would
then re-encode a mix louder than the AAC that was actually delivered.
The cut now reports when the PCM no longer matches the delivered AAC. The
audio stage keeps the PCM only on an explicit success, not because the file
exists, and assembly otherwise falls back to the verified AAC.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HebQXN7wsMK6GqT3MNtqXw
* test(producer): the fake-FFmpeg PCM rewrite writes its output
The true-peak correction now rewrites the kept PCM with FFmpeg and reports
the PCM as stale when that output never appears. The fake FFmpeg in this
test answered the rewrite without writing anything, so a correct run looked
like a failed rewrite. The fake now writes the output, as real FFmpeg does.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HebQXN7wsMK6GqT3MNtqXw
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(fonts): stop failing cloud renders on var() shorthands, font-X-400 names and linked font sheets
* style(producer): shorten the project font sheet comment
* style(core): shorten the field font families test header
* fix(fonts): split font size parsing and fit the CLI size budget
* fix(producer): read project font sheets for family names only, never fetch from them
* fix(producer): a wedged effect scan or screenshot-session open trips the 60 s stall watchdog
The sequential streaming watchdog raced only the capture call. Session init
(where the fast-capture effect scan runs) and opening the screenshot session
for effect frames waited on CDP's protocol timeout instead, which scales with
output area up to 30 minutes, so a starved page hung a render for ~25 minutes
before the watchdog saw the next frame. The effect scan now gives up when a
chunk outlasts its 120 s budget, opening the effect-frame session gets its own
no-progress window, and session init gets a 300 s one; each trip retries on a
fresh session like any other stall.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* feat(cli): one local render at a time per machine; a second waits and says for whom
Renders started side by side from different sessions starve each other until
frames stop landing. `hyperframes render` now takes a machine-wide slot (a lock
file in the HyperFrames cache directory, held by pid) after its preflight and
holds it for the render or the whole batch. A second render waits and prints
the pid and project it is waiting behind; `--no-wait` fails at once instead.
A holder whose process is gone is taken over, and HYPERFRAMES_RENDER_LOCK=off
restores side-by-side renders. `--workers` is unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(lint): flag fonts a cloud render cannot resolve, including the font shorthand
Lint read only `font-family`, so `font: 500 16px "PingFang SC", sans-serif`
passed while the renderer, which reads the shorthand too, drew the installed
Mac font locally and the cloud refused it. The shorthand now counts for
font_family_without_font_face (its parser moves to @hyperframes/parsers so
core and lint share one), and a new font_face_local_only warning names an
@font-face whose only sources are local(): it renders here and falls back in
the cloud. The rule's hint and the format reference stop recommending local()
for OS fonts.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(cli): a cloud render that refuses a font says which project files use it
The cloud's "fonts that could not be resolved: PingFang SC" named no
composition. For a render submitted from a local project, the failure now
lists each refused family with the project files that name it, and says how
to ship the font so the cloud can use it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore(cli): keep comment shares and exports within the gates, and split the single-render notes out of executeHeldRender
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(parsers): read a spaced line-height slash and var() before the size in the font shorthand
`font: 16px / 1.5 Inter` was read as the family `/ 1.5 Inter`, and
`font: var(--weight) 16px Inter` as `16px Inter`, because a var() counted as
the size. The parser now follows the shorthand grammar: optional style,
variant, weight and width keywords (or var()), then a length, percentage,
keyword or calc() size, then a `/ line-height` in any spacing. When no size can
be told apart from a var(), it says so: lint skips that declaration instead of
reporting a missing font, and the renderer keeps its best guess.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(cli): say the render slot is one per user account, not per machine
The lock lives in the account's HyperFrames cache folder, so renders by two
user accounts never queued behind each other while the messages, flag help and
docs said "this machine". They now say "per user account" and that
HYPERFRAMES_CACHE_DIR set to a shared folder shares the slot across accounts.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(cli): reclaim a render lock or takeover file left half-written
A lock or `.break` file that exists but cannot be parsed (a crash mid-write
where hard links are unavailable) was never reclaimed: a waiting render waited
forever and --no-wait refused forever. Once such a file is older than any real
write (5 s by mtime) it counts as abandoned: the lock goes through the same
`.break` takeover as a dead holder's, and a takeover file is removed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(producer): opening the capture session counts against the setup stall budget
The sequential streaming attempt opened its own capture session (Chrome launch
and new page) before the setup watchdog and outside the attempt's cleanup, so a
wedged launch still waited for the protocol timeout. Opening now shares the
300 s setup window with session initialisation, a trip fails the attempt like
any other sequential stall, and a session that finishes opening after its
attempt gave up is closed instead of leaking a browser.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore(parsers): keep the shorthand result type module-private
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(cli): reclaim an unreadable render lock only when its writer is provably gone
Where hard links are unavailable the lock is created by an exclusive open and
then written, so a contender paused between the two leaves an unreadable lock
while it is still alive. The 5 s mtime grace took such a lock over, and both
processes then held the slot. Each contender now writes an owner marker under
a name only it can take (pid plus random suffix, holding its process identity)
before it creates the lock, keeps it while it holds the slot, and removes it
otherwise. An unreadable lock or `.break` is reclaimed only when no other
contender's marker belongs to a live process; markers of dead processes, or of
a reused pid, are deleted. No reclaim is decided by time alone.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor: split acquireRenderLock and the streaming-stage session stub under the complexity gate
acquireRenderLock hands contender setup and a single marked claim to their own
functions, and the test stub for createCaptureSession splits its held-open
cases from the fake session it builds, so neither exceeds Fallow's cognitive
or CRAP thresholds. Behaviour is unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore(ci): raise the CLI and engine size budgets for the watchdog, lock and font-lint additions
Main's CLI unpacked size was already ~0.99% over its budget; the render lock and
owner markers push it past the 1% tolerance. The CLI unpacked budget takes the same
value as #7169 and #7170 (25,159,107) so the PRs merge cleanly. The engine's packed
size grows by about 4.7 KB for the effect-scan and session-open watchdogs; its packed
budget moves to 5% above the measured 467,097, as the budget file's headroom rule sets it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(parsers): a var() size glued to its line height is the shorthand's size
`font: 700 var(--size)/1.1 "Inter"` read as no family at all: the token was
tested whole against var(), and the slash after it hid that it was the size,
so the renderer injected no face for Inter. A var() followed by `/ line-height`
(glued or spaced) can only be the size, and is now read as one.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(parsers): split the shorthand size search out of parseFontShorthand
Keeps parseFontShorthand under Fallow's cognitive-complexity gate; behaviour is unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(cli): render lock never removes another render's takeover, knows a reused pid, works in a shared folder and on Windows
- A `.break` takeover file is removed only by the render that wrote it. One
whose writer is gone stops the render with the file to delete, instead of
being removed on an earlier reading, which could remove a live `.break`
written since and let two renders hold the slot. The takeover re-reads the
lock under its own `.break` right before replacing it.
- The lock record keeps its holder's process start time, so a pid that now
belongs to another process (an OOM-killed render in a container with a
persisted cache) no longer holds the slot forever.
- The `locks` folder is created writable for every account, so accounts
sharing HYPERFRAMES_CACHE_DIR take turns instead of the second failing with
EACCES; a folder this account cannot write in says how to fix it, and
another account's file that cannot be removed is left, not fatal.
- Windows: no PowerShell start-time lookup per check (pid liveness only), a
file another handle holds (EPERM/EBUSY/EACCES) reads as held, a lock that
vanished is retried once instead of in a tight loop, and a wait stops when
its signal aborts. The tests end every acquire they start before removing
their folder, and the paused contender writes through its open descriptor.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore(ci): raise the lint packed size budget for the font-shorthand rule
With main's audio-attribute rule (#7169) merged in, the font-shorthand and
local()-only font findings take @hyperframes/lint's packed tarball to
181925 bytes, over the 179338 budget. The new budget is that measurement
plus the usual 5% headroom.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* test(engine): pixel invariants for capture blur against blur off
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(engine): fixtures for every capture blur failure class seen so far
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(engine): nested canvas fixture reproduces #6975, sharp-tile fixtures have no moving times
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(engine): capture blur must match blur off outside the trail and the shutter average inside it
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(engine): differential tests pin known bugs by symptom, history test checks the reference frame
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(engine): a playing preview keeps changing with blur on
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(producer): a multi-worker blur render must match blur off outside the trail
Renders five blur fixtures through the real producer as a PNG sequence with 4
workers (contiguous blocks, three of them starting mid-film, the #6967
condition): blur off twice, blur on once. Outside the trail of everything that
moved, blur on must equal blur off in every frame with two neighbours. The
callbacks and scroll-list known differences are pinned by symptom.
Import route: a relative import of blurDifferential.ts, fixtures.ts and
thresholds.ts from packages/engine/src/services/__fixtures__. The producer
tsconfig excludes test files, so I type-checked the file with a temporary
tsconfig (rootDir widened); no error. No package subpath was needed.
RENDER_OUTSIDE_MAX_MAE: render noise is 0 (blur off, twice, bit-identical), the
rewind mutation measured 111.085 when caught, so the 1.0 floor applies.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(producer): render callbacks with workers that start between its calls
With 4 workers the blocks started at 0, 15, 30, 45, each on a call, so the
rewind mutation showed in a render only 3 times in 5. Seven workers over 60
frames start at 0, 9, 18, 27, 36, 45 and 54, two of them strictly between the
calls at frames 16 and 30; the mutation then fails callbacks in 8 of 8 runs
(worst MAE 97.02), the clean build in none.
A new case checks the partition with distributeFrames. The #list and #label
rects now come from the fixture's markup, and MEASURED_RENDER_REWIND_MUTATION
is 97.02.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(engine): blur pins bound the symptom, liveness detector reports blindness, fixtures time out
Pinned known bugs now require every bad tile inside the pinned region and a worst
MAE within half to double of the measured one. tileTouches, Rect and the band check
move into blurDifferential.ts with a dpr 2 unit test. The blank-frame census counts
canvases it cannot read and asserts none, and names both readings when no blank frame
is seen. No console.info on passing runs. Fixtures cases get a 30 s timeout.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(producer): scroll-list render case bounds the race, pins share the engine helpers
The scroll-list loss depends on timing per worker block, so the case now requires
frames 2..27 clean and any later bad tile inside #list, without requiring the loss.
The callbacks pin keeps requiring its symptom, bounds it to the label and to half to
double of its measured size, and its message names the entry to delete. Wording says
multi-worker, not 4-worker.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* build(engine): keep the blur test helpers out of the published tarball
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(engine): print the worst outside tile of each arm to explain the CI text diff
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test: both arms draw grayscale text so host subpixel settings are not read as blur
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(producer): run the multi-worker blur render alone so it cannot skew other Chrome tests
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test: re-pin the producer lane runner after splitting out the heavy blur render
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(engine): read the blank-frame pin from a wrap observer, not an animation frame poll
The pin sampled in requestAnimationFrame, so it could miss the gap between the
wrap and the first draw. A MutationObserver now reads the output canvas the
moment the root is wrapped, which is deterministic, and every fixture must
report a wrapped root.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* test(engine): drop the blurs field no fixture could set to false
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
* ci: give the flake gate 60 minutes, it budgets runs by file count not time
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
* fix(producer): a drive that refuses frame links gets a copy, whatever code it refuses with
* fix(producer): an entry already where the frames go still gets cleared and relinked
* test(producer): the relinked frame dir is read through its new link
* fix(engine): a full disk during frame extraction says so, not that the video is broken
* fix(engine): a pass that filled the disk is not decoded again in software
* fix(producer): fail a render once when its page never became ready
* refactor(producer): keep the page-never-ready error private to its module
* test(producer): drop a mock field the page-never-ready test never set
* fix(producer): a stalled capture resumes at the first unwritten frame instead of frame 0
* fix(producer): a page that keeps stalling falls back after three resumes instead of resuming forever
* feat(producer): a render request can force screenshot capture for that render
A retried render can ask for the slower, safer capture mode without changing the pod's environment.
* fix(producer): drop the comment line the comment ratchet flags
runFor shared one 1 s real-time budget between the render's start and every
step. When the cold start alone spent it, fake time jumped before the stalled
attempt opened, so the 400 s window ran out with no retry: "expected [] to
deeply equal [2]" on the first test, four merge-group failures since 10-30.
The first hold now gets its own 4 s budget. Reproduced by holding the compile
stage mock for 1.5 s of real time; it fails before and passes after.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(producer): a render stops when a capture session sees every composition script fail
* fix(producer): only capture workers decide a script failure; prep sessions stop without recording it
* fix(producer): a script failure in a capture worker still reports as the composition-script error
* style(producer): format the script-failure test
* feat(producer): report browser-computed reference backgrounds
Preserve one initial root/page reference across local, streamed and distributed
render results without guessing from film pixels.
— Jerrai
* fix(producer): preserve plan compatibility and optional inspection
Keep reference metadata outside the v2 manifest hash and read it from the
verified execution-plan artifact. Static planning uses a non-gating page
inspection instead of requiring render-worker capabilities.
— Jerrai
* fix(producer): poll readiness independently of animation frames
Use timed polling while the render clock parks animation frames. Cover readiness
that changes after the first check with a short real-browser regression.
— Jerrai
* fix(producer): budget measured reference metadata runtime growth
Producer adds 2,228 compressed bytes over current main. Tests, fixtures and source
maps are already absent from its dist-only tarball. Allow 7,766 bytes of headroom
above the verified 837,234-byte payload while retaining the unpacked limit.
— Jerrai
* fix(studio-server): more than six clips on one media file no longer starve check and preview of connections
Every file server answered `Range: bytes=N-` with the rest of the file. A
media element reads that until its buffer is full, then stops reading but
keeps the response open, so each <video> held one of Chrome's six HTTP/1.1
connections to the host. With seven or more <video> clips on the server's
host, every other request queued behind them and `hyperframes check`
stalled at 0% CPU. A long recording cut into trimmed segments, each its own
<video> on the same file, is enough.
An open-ended range of audio or video now gets at most 4 MiB
(OPEN_MEDIA_RANGE_BYTES), as a normal 206 with an exact Content-Range. The
element asks for the next range as it plays or seeks. Bounded and suffix
ranges, and files that aren't media, are served as before. The helper lives
in studio-server; its preview route and the CLI's static project server and
composition server use it.
Fixes#6029
Claude-Session: https://claude.ai/code/session_014aw1z3VrTNenka3LGDBBLa
* fix(studio-server): carry the range cap's reason in names and tests, not comments
The comment ratchet doesn't let a file's comment share rise: mediaRange.ts
was 48% comments against the package's 7%, and staticProjectServer.ts gained
a line. The cap is now MAX_OPEN_MEDIA_RANGE_BYTES, and the why and the
repro stay in the three tests and #6029.
Claude-Session: https://claude.ai/code/session_014aw1z3VrTNenka3LGDBBLa
* fix(producer): the render file server bounds open-ended media ranges too
parseRangeHeader takes the response's content type and caps an open-ended
`bytes=N-` on audio or video with openRangeEnd, like the CLI and Studio
servers. The producer imports it from a new `media-range` subpath of
@hyperframes/studio-server, as it does `encoder-options`, so a render
doesn't load the rest of the package.
Claude-Session: https://claude.ai/code/session_01DW4V8HZZx5JUgMffb3juVV
* test(cli): eight clips on one file no longer leave the host unanswered
A real Chromium page buffers eight long video clips of one file from the project server and then asks the same host for another file; with open-ended ranges unbounded the request stays unanswered, with the bounded piece it is answered at once.
* docs(producer): range comments name the open-ended form in lowercase
* docs(cli): the range test's comment says what holds now
---------
Co-authored-by: HuntsDesk <hunter@talloak.com>
* feat(engine): composite a source video inside the streaming encoder
* feat(engine): opt-in flag and rule for compositing a lone full-timeline video
* feat(producer): opt-in video layer passthrough for a lone full-canvas video
* feat(producer): launch the probe, drop its page and capture PNG when passthrough is on
* refactor(engine): trim the passthrough doc comments to one line
* fix(producer): refuse passthrough when a wrapper or sub-composition paints a background
* chore(producer): mark the in-page layout check as one deliberate unit
* fix(engine): a video left out of capture no longer blocks static-frame dedup
* refactor(engine): shorten two long comments in the static-frame eligibility scan
* fix(producer): a failed video extraction names which clip files failed
* fix(producer): the extraction source label hides scheme payloads and drive paths
* style(producer): format the extraction source label
* fix(producer): render telemetry reports beyond-viewport capture as the workers used it
* fix(producer): apply the sessions' beyond-viewport value at the summary, on every capture path
* chore(engine): drop a comment so the types file's comment share does not rise
* fix(producer): auto renders with color-graded media stay SDR instead of promoting to HDR
* fix(producer): keep auto renders SDR when a graded canvas is present