* fix(aws-lambda): match the shell to its own pin, ship only hashed files, refuse the shell ZIP in CDK and SAM
Review follow-ups to the pinned shell route:
- build-zip --source=chrome-headless-shell accepts the folder only when its
digest is pinned for this version, not for any pinned build.
- It leaves out the files the digest skips (debug.log and chrome_debug.log,
which Chrome writes as it runs), so nothing unhashed ships.
- The CDK construct throws on chromeSource "chrome-headless-shell" and the
SAM template allows only sparticuz, as lambda deploy already refused it:
a shell ZIP cannot fit a function. The CHROME_PATH wiring for that ZIP is
gone with it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore(aws-lambda): raise the packed size budget to 82,000 bytes
The shipped build-zip script now checks the shell against its own
version's pin and skips the files the digest leaves out. That takes the
tarball to 81,378 bytes in CI, over the 80,500 budget's 1% tolerance;
main was already within about 200 bytes of it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
The engine ceiling moves from Beta 152.0.7977.30 to stable 158.0.8127.36, with its Chrome for
Testing digests. The places that installed `@stable` or an older pin follow it: the CI test
workspace, the regression test image, the k8s and Cloud Run examples, the CLI render image
(amd64) and the Lambda build hint. The motion-blur nightly keeps its pinned-versus-stable
comparison: the pin leg now uses the workspace's pinned shell, and a stable leg fetches stable.
The chat regression golden is regenerated on 158. Chrome 157 renders it pixel-identically to
158, so the previous golden recorded Chrome 152's paint of a background-clip:text phrase whose
word spans start at opacity 0.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): the render file server never serves a project file as a service worker's script
* fix(producer): render, capture and inspector servers never serve a service worker's script
* perf(engine): check still frames on several pages at once so text films start sooner
* fix(engine): parallel still-frame check keeps its full time budget
* test(engine): give the Bun download check the minute its spawn already allows
* test(inspector): the inspector's Chrome follows the host sandbox rule, and probes retry without it
* fix(inspector): the inspector's Chrome starts as root or in a container
* test(producer): the page check and the inspector retry Chrome without the sandbox when it refuses
* fix(producer): the page check retries Chrome without the sandbox when it refuses, like the inspector
* chore(inspector): raise the packed size budget for the shared sandbox rule
* test(engine): the GPU, host-ceiling and HDR launches keep the sandbox where the host allows it
* fix(engine): the GPU, host-ceiling and HDR launches keep the sandbox where the host allows it
* test(engine): the host-ceiling stub shell runs only where /bin/sh does
`canEncodeWhileCapturing` started an H.264 export beside the capture workers
whenever `workerCount < cpuCount`, but `appendSoftwareEncoderThreadsArg` gave the
encoder every usable core, so the overlap spawned a full-width x264 pool next to
the capture workers (#7458).
The overlap now reserves the cores capture is using: `softwareEncoderThreads =
max(1, cpuCount - workerCount)` travels through the streaming encoder options to
ffmpeg's `-threads`, while the post-capture encode keeps the old default.
* fix(engine): GPU probe, HDR capture and host-ceiling probe keep a required sandbox
These three launches always passed --no-sandbox, even where HYPERFRAMES_CHROME_SANDBOX=1
says Chrome must keep its sandbox. They now drop it in that case and behave as before
otherwise.
— Rames
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): HDR capture passes --no-zygote only alongside --no-sandbox
Chrome exits at launch ("Zygote cannot be disabled if sandbox is enabled") when
--no-zygote is passed with its sandbox on, so HDR capture under
HYPERFRAMES_CHROME_SANDBOX=1 needs to drop it together with --no-sandbox.
— Rames
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): video warnings show control characters in the src as visible escapes
The missing-source and opaque-alpha warnings pass the authored src, and the path
built from it, through terminalText before writing them to stderr.
* fix(cli): snapshot never probes or decodes a private project file for a page video
projectLocalFile applies the same private-file rule as the render readers, judged as written
and with links resolved, so held-video probes and frame injection skip those files. Studio's
own prepared-assets and requests folders still resolve.
* fix(parsers,engine): media inputs never select a text-art demuxer
The media format allowlist leaves out tty, bin, xbin, idf and adf, so ffmpeg and ffprobe
cannot draw a text file as a video frame, whether or not ffprobe is installed. ffprobe's
refusal of one of these formats still reports the source as a text file.
A link inside the project whose target is outside it is still read by snapshot: links a
person puts in their own project are accepted, imported projects cannot carry links, and
render reads them the same way.
* fix(cli): registry warnings show control characters as visible escapes
A project's hyperframes.json can name the registry, so item names and deprecation text
from it pass through terminalText before the studio install, remote template and
item-loading warnings write them to stderr.
* fix(cli): failed render and frame read messages escape control characters
The render failure box escapes each line of the message, keeping its line breaks, and
snapshot's frame read errors escape the path and the ffmpeg or ffprobe text they quote.
* test(cli): probe a missing path with control characters instead of creating it
Windows cannot create a file with those characters in its name; the failed probe's
message still carries the path.
The bypass entry for a restricted browser's page server now always names its
port, so a default port no longer admits every port on the host. Studio
thumbnails take the server's own origin, not a request's Host header. A stop
signal that lands while the temp profile is being made removes it and launches
no Chrome. The wiring test follows renamed and namespaced calls, requires the
callback to pass on the network's args and profile, and refuses an unset
pageServerUrl.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(cli): own render-slot lock dir; refuse cache files other accounts can write
Sharing one render slot across accounts no longer means sharing HYPERFRAMES_CACHE_DIR,
which holds the browser, packages and helpers each account runs.
HYPERFRAMES_RENDER_LOCK_DIR names a folder of lock records only, created sticky and
writable by all (1777); the per-user lock folder is created 0700. Help text, errors and
docs no longer suggest sharing the cache or chmod 777.
foreignWritablePath (core/cache-dir) refuses a cached file whose path up to the cache
root is owned by another account or is group/world-writable. Chrome (CLI, engine,
inspector), optional packages (incl. the Sherpa runtime), the whisper.cpp build, the TTS
script, the Apple audio helpers, opencv.js and the Lambda handler reinstall or rebuild
instead of running such a file, and trustedCacheRoot moves their installs to
~/.cache/hyperframes when another account can write HYPERFRAMES_CACHE_DIR.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(cli): seal own cache installs against umask 002 and repair old lock folder modes
sealCacheInstall (core/cache-dir) takes group and world write off what this account just
installed and the folders above it up to the cache root, so an install made under umask
002 passes foreignWritablePath on the next run instead of being refused and fetched again.
Chrome, optional packages, the whisper.cpp build, opencv.js, the TTS script, the Apple
audio helpers and the Lambda handler call it after installing.
ensureLockDir makes an existing per-user lock folder 0700 again when an older release left
it open, and adds the sticky bit to an existing HYPERFRAMES_RENDER_LOCK_DIR folder, warning
once with the folder's name when it cannot.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(cli): drop added comments to pass the comment ratchet
The explanations move into names: the mode bits in core/cache-dir are GROUP_OR_WORLD_WRITE
and WITHOUT_GROUP_OR_WORLD_WRITE, and the owner check is anotherAccountCanWrite. No change
in behaviour.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(cli): verify the lock folder through a no-follow handle and stage installs owner-only
The render lock folder is opened with O_NOFOLLOW | O_DIRECTORY and checked and chmod-ed
through that descriptor: a link, or a folder another account owns (root may own a shared
one), is refused with RenderLockFolderRefused instead of being made world-writable or
used as is.
Chrome staging, the optional-package staging folder, the whisper.cpp build folder and the
opencv, TTS, Apple helper and Lambda handler folders are created 0700, and Chrome's staged
tree is sealed before it leaves staging, so nothing is group-writable while it installs.
foreignWritablePath accepts a sticky folder owned by this account or root, as /tmp is, and
tolerates a statSync without options; tests whose cache sat directly in /tmp, and tests
that mock statSync, failed on both. Docs note that a record naming a live process of
another account holds the shared slot.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(cli): skip the uid-based Chrome cache refusal cases where there is no uid
Windows has no process.getuid, so the ownership check never runs there and the two cases
that expect a refusal cannot hold.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore(core): raise the unpacked size budget for the cache ownership checks
core grew to 4418013 bytes unpacked with foreignWritablePath, sealCacheInstall
and trustedCacheRoot; the budget follows the usual 5% headroom over that size.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(core): a graded video's opacity animation reaches its export
* fix(core): a graded clip keeps its own clip-path, so it never renders black
* test(producer): golden render of graded video dissolve and wipe
* fix(core): a graded clip stays clickable in the preview, hidden by a filter not a clip
* chore(studio): drop an import the reader no longer uses, and format the graded fixture
* fix(engine,producer): render media readers treat private project files as missing
A video, audio, GIF or HEIC src that names a file the file servers refuse
(git metadata, env, credentials, tool state, app records), as written or
through a link, is now treated as missing by every render-time reader:
the compile-time duration probe and keyframe advisory, GIF and HEIC prep,
the media drop step, the HDR probe, frame extraction and the audio mixer.
The engine's isPrivateUnderAssetRoots judges a path from every asset root
that holds it, so a render's own work folder inside the project's
.hyperframes/ keeps its downloaded and prepared files.
* fix(engine): probe refuses a text file that ffmpeg reads as text-art video
ffmpeg's tty and bintext demuxers turn a text file (such as .asc or .nfo)
into a video stream that draws the text into frames. Every probe now
refuses an input whose container is tty or whose video codec is ansi,
bintext, xbin or idf, as not media. Probing, frame extraction and audio
reads all go through the same probe, on every render. No demuxer for real
video or audio produces these, so local renders keep every other format.
* fix(engine,producer,cli): playlist entries and check probes skip private files
- A media playlist (HLS segment, key or map URI, ffconcat file) that names a
private file inside its own folder is refused as not media, like one that
names a file outside it.
- `hyperframes check` no longer probes a media source outside the project or
private in it: mediaPath returns null for such a file and the audio,
heard-clip and HDR checks skip it.
- The compiler's duration probe and keyframe check judge privacy from every
asset root, as the render-time readers do.
* fix: warnings that name project files print control characters as visible escapes
The CLI already escaped control characters in the text its own commands
print, but warnings from core, producer and engine went to the terminal
raw. A composition whose sub-composition path held ESC or BEL still
drove the terminal through the bundler's "Skipping sub-composition"
warning in `info --media` and `snapshot`.
terminalText moves to core so there is one sanitiser, the CLI imports it
from there, and the library warnings that carry project text (the
bundler, the producer logger, the file server, render path skips, asset
load failures, FrameCapture, the import map, fonts, figma and atomic
file warnings) pass that text through it.
* fix: every library warning that carries project text escapes control characters
* fix(engine): give each superset extraction a folder of its own
A superset group extracted into a folder named from the group index and the
process id, and deleted and recreated it by that name in the cache root that
every render shares. Two renders in one process could share the folder and
remove each other's frames.
Partial folders are now created with mkdtemp, so each extraction writes only
into a folder it made. A cache entry is published only when its frame count
is the one the extraction wrote.
* fix(engine): make the partial folders with createStagingDir; raise the engine size budget
* wip: paused before review
* test: cover credential files on the preview routes and the deploy notice
* refactor: name the inspector's file lookup for what it serves
* fix(cli): a link to a private file outside the project keeps its own left-out reason
* fix: escape the upload notice and skip private files from old manifests
The static-dedup and at-risk predictors turn each GSAP tween into a frame
range and wrote every frame of every range into a Set. The page decides how
many tweens there are and how long they claim to run, so stacked tweens
multiplied the loop and the at-risk predictor never clamped a range's end at
all: one tween ending at 1e9 s walked billions of frames.
Ranges are now clamped to the frames the render captures, merged before any
frame is written, and the interval list is capped. Past the cap, static dedup
is skipped and every frame is treated as at risk (screenshot capture), so
output never changes for the worse.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): a cached browser is used only when its files match the pinned build
* ci: install the pinned headless shell for the engine and producer test jobs
* ci: record the producer test job's new setup step for test reachability
* fix(cli): the static project server answers only loopback and marks pages another site loads
check, snapshot, validate, layout, compare, grade-compare and motion-shot serve the
project from a loopback server. It now refuses any Host other than loopback or its
in-process name before reading a file. A page or file that another site loads comes
back sandboxed, and its documents carry the another-site mark, so the runtime offers
that site no editing port. The capture browser's own loads are unchanged.
* fix(producer): the render file server answers only loopback and offers no editing port
The render file server now refuses any Host other than loopback before it opens a
file; the capture browser asks for localhost. Every HTML page it serves carries the
another-site mark, so its runtime answers no editing connect. A render never sends
one, so capture is unchanged.
* fix(engine): the exported file server answers only its own host and offers no editing port
createFileServer from @hyperframes/engine now refuses any Host other than loopback or
the hostname it was bound to (on a wildcard bind, this machine's own addresses too)
before it reads a file. Every HTML page it serves carries the another-site mark, so
its runtime answers no editing connect.
* fix(engine): extraction-time video downloads get the not-media check
A video src that is still remote at frame extraction is downloaded again and
then probed. That copy now gets the checks other media downloads get before
anything reads it as media:
- the not-media sniff, so an HTML, XML or JSON body (including a DASH
manifest) is refused with the existing NotMediaPayloadError, classified as
invalid_media;
- on a render service (PRODUCER_RESTRICT_PAGE_NETWORK), the same
-format_whitelist an https input gets, so a playlist, manifest or concat
list fails to open whatever its bytes say, and no file it names is read.
Real mp4, mov and webm downloads extract the same frames as before.
* fix(engine): the download format check stops when the render is cancelled
* fix(engine): the not-media sniff keeps mp4 files whose box size reads as text
An ISO BMFF file opens with a 4-byte box size and a box type. A size of 60
is the byte `<`, so after the leading NULs were skipped a valid mp4 with a
60-byte ftyp was refused as a text document. The sniff now recognises an
mp4/mov box header (size 0, 1 or at least 8, then ftyp, styp, moov, moof,
mdat, free, skip, wide, sidx or pdin) before it skips NULs. HTML, XML,
JSON and playlist refusals are unchanged.
* fix(engine): the mp4 exception in the not-media sniff needs a box that fits the file
The sniff only skips its document check for an mp4/mov opening when the
first box is ftyp or styp, its declared size (including a 64-bit size) fits
the file length, and the next box header, when the sniff window holds it, is
a known media box that also fits. A document that only spells a box header
falls through to the document and playlist checks as before.
* fix(engine): the not-media sniff keeps mp4 files with leading padding or extension boxes
An mp4 or QuickTime file may open with free, skip, wide, uuid, pdin, moov,
mdat or moof as well as ftyp or styp, and may carry any box type after it.
The sniff now accepts any of those first boxes, then walks every box header
the sniff window holds: each needs a printable four-character type and a
size that fits the file. A document that only spells a box header still
falls through to the document and playlist checks.
The outside-project media check skipped any src starting with data:, blob:,
about: or http(s): in any letter case, while the readers resolve everything
but exact http:// and https:// URLs as a local path. A src such as
data:x/../../outside/clip.mp4 passed the check and the readers opened the
file it named.
The check and the media type preflight now use the readers' remote test,
isHttpUrl, and check every other src with a shared containment helper,
isInsideAssetRoots. Frame extraction, the audio mix, and the HDR and video
sound probes also refuse a local source outside the project, compiled and
download folders on their own when outside files are not allowed.
The CLI static project server and the producer and engine file servers bind
127.0.0.1, but answered any Host header. They now refuse a request whose Host
is not 127.0.0.1, localhost or [::1] at their own port (or the in-process
origin the CLI hands out when listen is refused), and their responses carry
frame-ancestors 'self' and X-Frame-Options: SAMEORIGIN so another site cannot
frame the served page.
Render, capture and the HTML bundler used a narrow private-file rule that
only refused Git data and env files. A composition's script could read the
app's own records under .hyperframes/ (chat history, hand-off, comments,
job log) from the file server, or a data-composition-src could inline one.
Every file server a composition reaches now uses the rule Studio, play and
present already use: Git, env, and .hyperframes/ apart from Studio's own
files and the prepared-assets and requests folders. The rule now matches
Windows spellings too: any case, trailing dots or spaces, backslashes and
stream suffixes.
* fix(gcp-cloud-run): render pages cannot reach the service's own dispatch endpoint
The Cloud Run image now sets PRODUCER_RESTRICT_PAGE_NETWORK=true, so a
rendered page reaches only its own project server and public addresses,
not loopback ports or the metadata server. The dispatch endpoint also
refuses any POST that carries an Origin header: browsers send one on every
POST and Cloud Workflows never does.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): the default frame cache folder is private to the user who renders
The default extraction cache sits in the shared temp folder. It is now
created with mode 0700, an existing one owned by the same user is closed
to others (its entries stay, so cache hits carry over), and one that is a
link or belongs to another user is not used: that render runs without the
cache and prints a warning. The animated GIF cache under the same folder
follows the same rule. A folder set with HYPERFRAMES_EXTRACT_CACHE_DIR is
left as it is.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* feat(gcp-cloud-run): a Terraform variable turns the page network restriction off
restrict_page_network (default true) sets PRODUCER_RESTRICT_PAGE_NETWORK on
the service. The package README and docs say what the restriction refuses
and how to turn it off for trusted compositions that need private hosts.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(engine): restore an unset TMPDIR as unset after the cache-root tests
Assigning undefined to process.env stores the string "undefined", so on a
runner with no TMPDIR every later test made its temp folder under ./undefined.
* test(engine): the frame-extractor link test also restores an unset TMPDIR as unset
* chore(engine): raise the packed size budget to 500000
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
When one capture worker fails, the pool aborts its peers and each of them
reports "Parallel worker cancelled". The pool message listed every worker in
id order, so the one real cause sat between cancellations:
Worker 0: Parallel worker cancelled; Worker 1: Parallel worker cancelled;
Worker 2: Disk capture may need ~2712.6 MB ...; Worker 3: Parallel worker cancelled
The message now carries the failures that are not cancellations and counts
the peers that were stopped because of them. A pool where every worker was
cancelled keeps the full list.
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
* fix(engine): render refusals name the address an IPv6-mapped or NAT64 host carries
* chore(engine): raise the engine size budget for bounded downloads and refusal classes
* fix(engine): start nvidia-smi, vm_stat, ps and tasklist from trusted folders only
The renderer resolves these helpers through the shared trusted lookup and runs the absolute path, so a program with the same name in a project folder is never started in their place.
* test(engine): memory and import tests follow helpers started by resolved path
* fix(producer): shown-box sampling stays within the validated render duration
Sampling where each oversized video is drawn stepped through the authored
start and end in 0.25 s float steps with no bound, before the render
duration was checked. An enormous start never advanced the step, and an
unbounded end grew the sample set until memory ran out.
The render duration is now validated first, each window is cut at the
composition's end, a window that is not finite is skipped, and the loop
counts integer steps. Building the sample list happens inside the
measurement's try, so any failure falls back to full-size extraction.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix: render and capture file servers refuse env files and Git data
The producer render file server, the engine file server and the CLI
static project server served every regular file under the project to the
page, including `.env*` files and anything under `.git`. Compile already
refuses to inline those files, and Studio preview and play refuse to
serve them.
All three now answer 404 for them through the shared isVcsOrSecretPath
rule, checked on the requested name and on a link's target, with the
case and Windows spelling variants it already covers.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): renders reach only public addresses from every part of the browser
* fix(engine): renders reach only public addresses from every part of the browser
* fix(engine): renders reach only public addresses from every part of the browser
* fix(engine): renders reach only public addresses from every part of the browser
* fix(engine): look a host up again after a failed lookup instead of refusing it for the whole page
* fix(engine): name the failed-lookup reset instead of commenting it
* fix(engine): hold the render page to the asset download address rules
With PRODUCER_RESTRICT_PAGE_NETWORK=true the render page reaches only its own project server and public addresses, checked by host and by resolved address, the rule asset downloads already follow. Unset, nothing changes for local renders.
* fix(engine): keep the page network filter comment within four lines
* fix(engine): an unrecognised capture failure is unknown, not the author's fault
* fix(engine): carry the extractor's disk-full words in a name, not a comment
A caller that runs several renders at once sets HYPERFRAMES_OWNER to a per-run id; every browser the CLI or
engine launches and the warm check server carry --hyperframes-owner=<id>, so the caller can tell one run's
leftovers from another's.
The startup diagnosis rebuilt its env from process.env, so a launch that
dropped WAYLAND_DISPLAY or the SwiftShader Vulkan pins was diagnosed with
them restored. The engine and CLI now pass the failed attempt's env through
explainChromeLaunchFailure; process.env stays the fallback when no env is given.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): launch Chrome with only the env it needs
Every Chrome HyperFrames starts (render, GPU probe, HDR capture, startup
diagnosis, version and shell probes, CLI browsers, inspector) now gets an
allowlisted environment from @hyperframes/core/chrome-env instead of the
whole process env. HYPERFRAMES_CHROME_ENV_PASSTHROUGH names any extra
variable a host needs.
Refs #7623
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(core): keep the Chrome env passthrough across repeat filtering
The CLI GPU probe filters its env twice, which dropped the names
HYPERFRAMES_CHROME_ENV_PASSTHROUGH adds, so the probe and the render
saw different envs. Keep the passthrough variable itself.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
When a sandboxed Linux launch fails and the no-sandbox retry also fails,
the startup diagnosis re-ran Chrome with the first attempt's flags, so it
described a launch that was not the one reported. The engine and CLI now
diagnose the flags of the attempt that produced the error.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): keep Chrome's sandbox on for local renders where the host supports it
Chrome launched with --no-sandbox on every host. Keep the sandbox on
macOS, Windows and non-root Linux outside containers; drop it as root,
in Docker/Podman/Kubernetes, on Lambda and Cloud Run, and where Linux
restricts unprivileged user namespaces. --no-zygote now ships only with
--no-sandbox, since Chrome refuses it while sandboxed. A sandboxed Linux
launch that fails at startup retries once without the sandbox and warns.
HYPERFRAMES_CHROME_SANDBOX=1|0 overrides the choice.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(cli): cover the Linux sandbox retry in managed browser launches
The off-macOS closed-pipe case now passes --no-sandbox, so it still
pins "no seatbelt relaunch" rather than the new Linux sandbox retry,
which gets its own case.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): honor HYPERFRAMES_CHROME_SANDBOX=1 and latch the fallback on clear evidence only
With the override set to 1, a sandboxed launch Chrome refuses now fails
instead of retrying unsandboxed. A bare startup exit (TargetCloseError)
retries that launch without the sandbox but only latches the sandbox off
after a second one, so a single unrelated early kill no longer disables
it for the rest of a long-lived process. Chrome naming the sandbox in its
error still latches at once.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
A mover that moves further than its own width between frames leaves gaps in a
trail built from whole-frame blur-off poses; the shutter's smear lands in them and
read as a leak outside the trail (nightly seed 63098). The mask now adds the
shutter's sub-frame poses, captured in time order. Seed 63098 joins the default
seeds as the regression case.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(cli,parsers): take helper programs only from install locations, never the project folder
FFmpeg, FFprobe, whisper-cli, parakeet-mlx, Python and system Chrome are now
found through one shared rule: an absolute PATH entry outside the working
directory, or a fixed install dir. A relative PATH entry and any folder
inside the working directory are skipped, on every platform. Windows walks
PATH itself instead of asking `where`, which lists the working directory
first.
FFmpeg discovery no longer falls back to `.hyperframes/bin` or to an
installer package in the project's node_modules; an installer package
installed next to HyperFrames still works. The env overrides are unchanged.
The CLI skill reference stops suggesting the project-local folder.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(cli): give the PATH-lookup tests a fixed PATH on Windows
Windows now walks PATH instead of running `where`, so tests that faked
`where` output found the runner's real python and cmake. Both tests now set
PATH to a temp folder holding only the programs they expect.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix: report a missing helper program instead of running it by bare name
When no trusted FFmpeg or FFprobe is found, the engine, the producer's
probes and Studio's waveform, peak and audio-track helpers now report
"not found" with the HYPERFRAMES_FFMPEG_PATH / HYPERFRAMES_FFPROBE_PATH hint
instead of handing the bare name to the OS lookup. Callers that degraded
on a missing binary still do: runFfmpeg returns a spawn_error result, the
GPU and version probes report none, and Studio's audio helpers fail soft.
The Lambda handler names its bundled ffmpeg and ffprobe by path, since
they live under the task root, which is the working directory.
brew, git and cmake for the whisper.cpp install, and the clipboard tool
for `hyperframes add`, run by the absolute path the trusted lookup
approved. The media-use engine gets a PATH holding only trusted folders.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): fail a missing FFmpeg the way a failed spawn always has
Throwing from getFfmpegBinary turned every caller's missing-binary path
into a synchronous throw: the streaming encoder's "failure result, not a
throw" contract broke, and unit lanes that run without FFmpeg crashed at
module load. With no trusted copy the getters now return an absolute path
inside HyperFrames' own install that is never created, named for the
override to set. Spawning it fails with ENOENT exactly as before, and the
OS still never looks the bare name up. The call-site guards and fixture
changes that the throw needed are reverted.
The whisper install tests match git and cmake by name and skip the brew
case on Windows, where the lookup walks the real PATH.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(engine): pin the found FFmpeg before the HDR test looks it up as macOS on Windows
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* feat(producer): fail a render whose variables the page does not declare
* chore(producer): keep the comment share and the dead-code audit clean for the variables check