* fix(engine,producer): media inputs refuse formats that open other files
Composition media read by ffprobe/ffmpeg now passes a format allowlist on every
input: the demuxers the installed ffmpeg reports, minus the ones that open other
files or URLs on their own (DASH, IMF and similar). hls and concat stay allowed,
since ffmpeg carries the list into every file they open. The HDR window,
alpha-plane, GIF, HEIC, audio-sidecar and snapshot reads that skipped it now use it.
The not-media check skips ID3v2 tags before it looks at the first byte, refuses a
playlist entry that is a document, and refuses JSON or non-SVG markup as an <img> src.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine,parsers,core,lint,cli): format allowlist reads old listings and covers every media probe
The demuxer listing is read from the binary that enforces the flag, accepts ffmpeg 4's
two-column output, and a failed listing is asked again next time. The lint HEVC probe,
the grade analyzer and the snapshot probes use it too. A nested playlist entry is refused
only for a real document signature, so encrypted segments and keys are kept; an image whose
prolog outruns the sniff window, or that is UTF-16, is no longer refused.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore(parsers,producer): trim comments added with the media format list
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(engine): keep the format-limit probe's argv in the shape the ffprobe contract reads
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): the image markup check reads a doctype without regex backtracking
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore(parsers): raise the parsers size budget for the media format list
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): check the resolved address of a restricted download under Bun too
Bun maps a bare undici import to a built-in whose fetch ignores the dispatcher,
so the download lookup that refuses private addresses never ran there.
Load the package by file path.
* refactor(engine): the undici package import says why in its name
* 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(hdr): bound HDR image decode and resample sizes
The native HDR image path sized its host buffers from the PNG header and
the element's page-measured layout box, with no ceiling.
- PNG decode checks IHDR dimensions and bit depth before allocating,
inflates with maxOutputLength = height * (stride + 1), and rejects image
data whose inflated length does not match the header.
- HDR images are limited to 8192x8192 pixels; resampleRgb48leObjectFit
refuses targets above that.
- A layout box larger than the output frame is shrunk uniformly to fit it.
- Decoded and resampled HDR image buffers count against the HDR extraction
budget (HDR_EXTRACTION_MAX_BYTES / cgroup limit) for the render's lifetime.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* build(engine): raise the packed size budget to 510000 bytes
The PNG header checks and bounded inflate add about 500 bytes to the
packed engine, which was already within a few hundred bytes of its
1% tolerance over the 500000-byte budget.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* 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.
A download whose response declares a Content-Length re-arms its attempt
timeout on every chunk, so a server that trickles just above the throughput
floor was never cut off by time. Parallel downloads also had no shared limit
on the disk they could fill.
- Each download attempt now has a deadline that incoming data never moves:
30 minutes by default, HYPERFRAMES_MAX_DOWNLOAD_MS to change it. Passing it
fails the download without a local retry.
- The default per-file cap drops from 20 GiB to 8 GiB
(HYPERFRAMES_MAX_DOWNLOAD_BYTES still overrides it).
- Downloads keep 512 MiB free on their volume
(HYPERFRAMES_DOWNLOAD_MIN_FREE_BYTES, 0 turns it off). A declared size is
claimed before the body is read and counted against every parallel
download on the same device, and free space is measured again every 4 MiB
as bytes arrive. Free space that cannot be measured does not block.
- docs/packages/engine.mdx lists the download limits and their variables.
* fix(engine): restricted downloads use the capture proxy's address rule
With PRODUCER_RESTRICT_PAGE_NETWORK on, remote asset downloads now go
through the same transport and host check as the render page's capture
proxy:
- An IPv6 literal host, or a name the capture proxy refuses, is not
permitted, on the first request and on every redirect hop.
- Names resolve to IPv4 answers only, every answer must be public, and
the download dials the checked address. A name with only IPv6 answers
does not download, as in the capture proxy.
- Proxy variables (HTTPS_PROXY, NO_PROXY) are not used in this mode, so
no host is dialled without the address check. HYPERFRAMES_CAPTURE_PROXY
still routes downloads, as it does for the page.
With the setting off, downloads keep the existing transport.
* fix(engine): restricted downloads keep undici's transport with the capture resolver
The capture transport refuses any compressed response and sends no
User-Agent, and its socket and parse errors were not retried. Restricted
downloads now use the same undici agent as before, with a connect lookup
that calls the capture proxy's resolvePublicAddress: IPv4 answers only,
every answer public, and the checked address is the one dialled.
This keeps the old request headers (User-Agent, Accept: */*), gzip, br
and deflate unpacking for text fetches under the existing byte cap, the
asset path's refusal of compressed bodies, "fetch failed" retry handling,
and connection reuse. Non-public destinations stay non-retryable refusals.
* fix(engine): the media playlist check reads HLS lines and attributes as ffmpeg does
The folder check now finds every name ffmpeg's hls demuxer would open:
- lines end at CR, LF or NUL, and a line is also read cut at ffmpeg's
4095-byte limit;
- URI attributes are split like ff_parse_key_value: quoted or bare values,
with backslash escapes removed;
- leading ID3v2 tags are skipped before the playlist signature, and a file
behind more than 16 of them is refused.
Each refused shape is checked against ffprobe 8 in the test: ffprobe opens
the outside file, and playlistLeavesItsFolder now refuses the list.
* fix(cli): snapshot never hands FFmpeg a project video that is a document or an escaping playlist
`hyperframes snapshot` decodes held project videos with FFmpeg and FFprobe.
It now runs the engine's media check first: a file that is a document, or an
HLS or ffconcat list naming files outside its folder (under any extension),
is skipped with a "not media" warning and never reaches FFprobe or FFmpeg.
Real clips and HLS lists of segments beside them snapshot as before.
* fix(engine): playlist check reads lines as bytes and refuses unreadable nested lists
- Playlist text is read as latin1, one character per byte, so a line is cut
at 4095 bytes exactly where ffmpeg cuts it, even when it holds bytes that
are not UTF-8. Nested names are opened by those same bytes.
- A nested name that exists but cannot be read is refused; a name that does
not exist, or is too long to exist, is still kept.
- Each name is checked once, each file is opened once (ID3 header and head
in one read), and each file's verdict is reused within a call: 100k
segments naming one file drop from seconds to tens of milliseconds.
* perf(cli): snapshot checks each project video once and warns once when it is refused
* test(engine): the ffprobe playlist proof ends its options with -- before the input
* chore(engine): raise the packed size budget to 500000 bytes
The byte-exact HLS playlist parser adds about 6 KB to the packed engine
(496647 in CI against a 490452 budget).
* fix(engine): media inspection never waits on a FIFO or device
The document sniff and the playlist walk open with O_RDONLY|O_NONBLOCK where
the platform has it, fstat the descriptor, and refuse anything that is not a
regular file before reading; a folder still fails as it did. A FIFO with no
writer, as a media source or named in a list, is refused at once.
* fix(cli): snapshot inspects project videos within the probe deadline and its cleanup scope
The held-video hints are gathered inside the capture's cleanup scope, and
every media inspection gives up after the same 30 s limit as the FFprobe
call it guards, treating the file as not media.
* fix(engine): read PRODUCER_RESTRICT_PAGE_NETWORK's usual spellings and restrict on an unknown value
true, 1, yes and on turn the render network restriction on and false, 0,
no and off leave it off, in any letter case and with surrounding
whitespace. Unset or blank stays off for local renders. Any other value
now restricts and logs a warning once, instead of leaving the render
browser and ffmpeg URL inputs unrestricted.
* fix(producer): on a render service the audio probe reads a composition URL from a downloaded copy
With PRODUCER_RESTRICT_PAGE_NETWORK on, a video URL the composition
names is fetched through the shared downloader (resolved-address check,
pinned connection, per-hop redirect checks) before ffprobe reads it, and
skipped if the download is refused. In a distributed audio step the copy
lands in the mixer's work folder, so the mix reuses it instead of
downloading again. Without the flag the probe reads the URL as before.
* fix(engine): on a render service a URL that ffmpeg reads in place must be a self-contained container
With PRODUCER_RESTRICT_PAGE_NETWORK on, every https input ffmpeg or
ffprobe opens directly (such as a signed storage URL for a project's
video or audio sidecar) also gets -format_whitelist with the same
self-contained containers the Studio media helpers allow. A playlist,
manifest or concat list stored under a media file name can no longer
make ffmpeg open other network locations. Local renders are unchanged.
* fix(producer): the render-service audio probe skips only refused URLs and downloads once
A composition URL is skipped, with one warning, only when the download
address rules refuse it. Timeouts, HTTP errors and a cancelled render
fail the probe as before. Videos without sound, muted or hidden are not
downloaded. The in-process extract stage passes the render's abort
signal and the mixer's work folder, so the mix reuses the copy.
* fix(producer): unit tests load the orchestrator again; raise the engine size budget
audioWorkDir moves to render/shared.ts, so tests that replace the audio
stage module still load the orchestrator. The format-whitelist test
probe ends its options with -- as the ffprobe argv contract requires.
The engine packed size budget rises to 500000 bytes.
* 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
downloadToTemp now refuses any Content-Encoding other than identity, caps each
download at 20 GiB (HYPERFRAMES_MAX_DOWNLOAD_BYTES) on the declared Content-Length
and while streaming, and aborts a transfer whose bytes over the last 60 s average
below 32 KiB/s (HYPERFRAMES_MIN_DOWNLOAD_BYTES_PER_SEC, 0 disables).
Compressed and over-limit responses are not retried. A throughput abort is a
retryable timeout like the stall timer, which is unchanged. A sized body that
trickles one chunk every 100 s is now cut by the floor instead of finishing.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): NAT64 addresses count as non-public; producer exports the address rule
* chore(producer): drop the new section comment
* fix(engine): judge mapped and NAT64 addresses by the IPv4 address they carry
* test(engine): operator ranges hold through mapped and NAT64 addresses
* 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(engine): refuse media playlists that name files outside their folder
* refactor(producer): media preflight decides refusals in one helper
* fix(engine): read a playlist once, bounded, instead of sizing it first
* fix(producer): inline only public HTTPS scripts, under the download URL policy
The compile step fetched every external `<script src>` with a bare fetch:
any scheme, any host, redirects followed, body size unbounded.
It now fetches through the engine's download policy, the one remote
stylesheets and media already use: HTTPS only, literal and resolved
addresses public, every redirect hop checked again, connect pinned to the
checked address, and at most 16 MiB per script. A new engine helper,
fetchPublicHttpsBytes, returns the raw bytes so integrity metadata is still
checked before decoding; fetchPublicHttpsText now decodes its result.
A script outside the policy keeps its `<script src>` tag, and the capture
browser loads it as before; the log says so at info level instead of
warning that the render may fail. Scripts under the operator's
HYPERFRAMES_GSAP_BASE_URL mirror, which may be loopback HTTP, are still
inlined. An integrity mismatch still fails the render.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(producer): the audio probe skips remote video URLs outside the public HTTPS policy
A video whose remote src compile could not download keeps that URL, and
the probe-only audio pass handed it straight to ffprobe, which fetches any
scheme and host. A src that fails the literal public-HTTPS check (plain
HTTP, loopback, private, link-local or `.internal` hosts) is now skipped,
the same outcome frame extraction already gives it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(producer): the GSAP mirror exception covers only its dist folder
Scripts from the operator's HYPERFRAMES_GSAP_BASE_URL mirror are fetched
outside the public-HTTPS policy, because the mirror may be loopback HTTP.
That exception now covers only plain script file names in the GSAP dist
folder the compiler itself points at, refuses redirects and stops at
16 MiB, like every other inlined script. Any other path on the mirror's
origin follows the public-HTTPS policy and is left for the browser.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): on a render service, https media inputs open only HTTPS
ffmpeg and ffprobe read some https sources in place. An https playlist
or manifest can name segments on any protocol, and the default protocol
list for an https input does not restrict them. With
PRODUCER_RESTRICT_PAGE_NETWORK=true, these inputs now pass
`-protocol_whitelist https,tls,tcp`, so segments and parts they name must
be HTTPS too. Local renders are unchanged.
A new test pins that local project files which are playlists, concat lists
or DASH manifests (with their own extension or named `.mp4`) are probed
and decoded without any request to the URLs they list: ffmpeg limits what
a local file input may open to file, crypto and data, and the concat
demuxer refuses URL entries in safe mode.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(studio-server): check and render keep their history on a drive without hard links
The history lock had its own list of the errors that mean a drive cannot
hard-link, and it lacked EISDIR, which Windows returns on a Google Drive
folder. Every check report and render record there failed. The lock now
uses core's list, the one owner, which also gains ENOSYS from the lock.
* fix(engine): downloads and plan blobs publish on a drive without hard links
The producer's plan publisher kept a third list of no-hard-link errors
without EISDIR, and the downloader had no fallback, so both failed on a
Google Drive folder. Both now use core's cannotHardLink; the downloader
copies into an exclusively created file, so it still never overwrites.
* fix(engine): a download on a drive without hard links publishes atomically
Instead of copying into an exclusively created file, the fallback renames
the staged download into place under the cache path lock when nothing is
there yet, so a killed run never leaves a truncated file to reuse.
* fix(engine): keep media ids that differ only by case in separate folders
macOS and Windows disks ignore case, and APFS ignores Unicode normalization,
but mediaIdPathSegment passed plain ids through as written. Two clips such as
`s12-vB1` and `s12-vb1` therefore shared one `__hyperframes_video_frames`
folder: whichever was staged first kept it, and the other clip read its
frames. A longer clip then failed mid-render with ENOENT on a frame past the
shorter clip's end; a same-length pair rendered the wrong footage silently.
Only a lowercase, NFC-normalized id now maps to itself. Any other spelling
gets the existing readable~digest form, so every per-id path (frame folders,
the tail probe, audio work files, distributed plans) stays distinct on a
case-insensitive disk.
* fix(engine): name the case-folding check instead of commenting it
Keeps mediaPathSegment.ts at or under its comment share at the merge base.
* fix(cli): check hears a WAV whose header misstates its byte rate, as render plays it
A PCM WAV whose header byte rate is wrong (some speech generators write 2x) sent the silence decode's input seek past the file's end, so every clip past the middle was reported audio_clip_silent. Render already cuts such a file by decoded time (#7541); the byte-rate rule now lives in parsers and the CLI decoder seeks after decoding starts for those files.
* test(cli): keep the misstated byte-rate case with the other single-clip checks
* style(cli): format the WAV test helper
* style(parsers): keep the byte-rate rule's comment within the line limit
* 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>
* fix(engine): offset clips from a WAV with a wrong byte rate play the right sound to their end
A WAV header that states twice its real byte rate sent the mixer's input seek
to twice the clip's in-point: the clip played later words, then silence. Such a
source is now cut by decoded timestamps instead of by a byte seek.
* refactor(engine): let the byte-rate flag's name carry the seek rule
* fix(producer): build the render job before taking a render slot
A request whose options fail the strict render-request validator now gets
a 400 on both the blocking and streaming routes, and its inline project
directory is removed. Validate workers up front like the other overrides.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(producer): write compiled sub-compositions only inside the compiled directory
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): keep media work files inside their directory for any element id
Map a media element id to one plain path segment before it names a frame
directory or an intermediate audio file. Ids that already are one plain
segment map to themselves, so existing paths stay the same; the producer
and the distributed plan derive the same segment.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): listen on loopback by default in the engine file server
The file server feeds the co-located capture browser, which loads it from
localhost. A caller that wants another interface passes hostname.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(producer): refuse cross-origin browser posts to the standalone render server
A web page on another origin can no longer start a render or lint through
the server's POST routes. Requests without an Origin header (CLI tools,
server-to-server callers) and same-origin pages are unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* chore(engine): trim comments on the media path segment and file server host
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(producer): trust the browser's Sec-Fetch-Site verdict for render server posts
A same-origin page behind a reverse proxy that rewrites the Host header sent an
Origin that no longer matched Host, so the cross-origin guard refused it. The
guard now uses Sec-Fetch-Site when the browser sends it and falls back to the
Origin and Host comparison only for browsers that do not.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(engine): keep generated media path names apart from plain ids and within filename limits
A plain media id that already ends like a generated name now takes the hashed
branch too, so it can no longer share frame folders or audio work files with
the unsafe id that produced that name. The readable part of a generated name
is capped at 64 UTF-8 bytes before the digest, so long or multibyte ids that
contain separators stay within the 255-byte filename limit.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(cli): staging folders beside a project path no longer fail past 260 characters on Windows
mkdtemp does not get the long-path prefix that mkdir does, so every staging folder
made beside a project or output path failed once its full path passed 260 characters.
They now come from one helper, createStagingDir in @hyperframes/core/atomic-file, and a
scan test fails on a new mkdtemp beside a path.
* fix(cli): give mkdtemp the long-path form instead of replacing it
CodeQL treats mkdtemp as the safe way to make a folder under the system temp dir and
flagged every file written into a folder from the mkdir-based helper. createStagingDir
now calls mkdtemp with the long-path form of the path on Windows, so both hold.
* fix(cli): leave non-Windows paths alone when making a staging folder
The long-path form is now chosen by the shape of the path, not process.platform,
so tests that pretend to be Windows keep working and the comment share does not rise.
* fix(core): a staging folder keeps a Windows path that already names its namespace
* fix(core): a staging folder keeps a Windows device path as the caller gave it
* fix(core): the staging folder helper's comment fits the line limit
* fix(engine): read a video's length from its packets when its headers state none
* fix(engine): ignore the cut first line of a long packet scan and count N/A as a frame
* chore(engine): trim the packet scan comments and put its doc back on the function
* style(engine): format the packet duration test
* fix(engine): GPU renders use the NVENC preset names the host's ffmpeg lists
* fix(engine): one ffmpeg stdout reader for encoder detection and preset listing
* ci(engine): raise the engine unpacked size budget for the NVENC preset reader
* 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
* fix(cli): capture's public-address check uses the engine's list; 192.0/16 is not all reserved
Only 192.0.0.0/24 and 192.0.2.0/24 are special-use. The capture proxy blocked all of
192.0.0.0/16, so sites on WordPress VIP (192.0.64.0/18, e.g. nasa.gov at 192.0.66.108)
failed every capture with net::ERR_TUNNEL_CONNECTION_FAILED. isPublicIPv4 now reads the
engine's isBlockedNetworkHost, so capture and asset downloads share one list.
— Jerrai (cutroom-debug)
* refactor(engine): one special-use network list, in a light subpath capture imports
Importing all of @hyperframes/engine into capture's publicNetwork slowed the lookup child's
start-up past publicNetwork.process.test's 6 s mid-lookup exit. The list and
isBlockedNetworkHost move to engine/src/utils/networkPolicy.ts, exported as
@hyperframes/engine/network-policy; urlDownloader and the engine index read it there.
— Jerrai (cutroom-debug)
* test(engine): pin 192.0.0.0/24 and 192.0.2.0/24 blocked, the rest of 192.0/16 public
— Jerrai (cutroom-debug)
* fix(cli): alias the engine's network-policy subpath in the CLI bundle
esbuild's root alias rewrote @hyperframes/engine/network-policy to src/index.ts/network-policy;
the exact-subpath list now carries it. The publicNetwork docstring is cut to keep the file's
comment share under its base.
— Jerrai (cutroom-debug)
* fix(engine): a video on a non-square pixel grid renders at its display shape
* chore(engine): drop comments the names already carry
* fix(engine): a rotated clip with a non-square pixel grid keeps its display shape
* test(engine): the frame probes end their options with -- like every ffprobe call
* fix(engine): late-starting videos play to their last frame
A video whose first frame is after timestamp 0 could end early (frozen
tail) or late: ffprobe's stream duration does not run from the first
frame in every container (fragmented MP4, Matroska). Such a video's end
is now read from its last packet, once, where its facts are probed.
* test(engine): the WebM-with-audio case measures its first frame from the file
* test(engine): the first-frame probe ends its arguments with the input file
* fix(engine): late-starting MP4 and WebM videos render every frame the preview shows
The browser counts an MP4 or WebM from timestamp 0, but FFmpeg seeks from the file's
earliest stream start. A file whose first frame comes after 0 (a fragment cut from a
longer stream, an edit-list offset, a WebM with a start offset) was extracted early and
short, so renders tripped the video coverage gate. Every video seek now maps media time
to FFmpeg's timeline, and the video begins where the browser shows it.
* fix(engine): audio from late-starting MP4 and WebM plays when the preview plays it
The mixer seeked and trimmed audio by FFmpeg's clock, which starts at the file's earliest
stream. In an MP4 or WebM whose streams all start after 0, the browser plays that audio
later, so the render heard it early by the same amount. The mixer now maps media time onto
FFmpeg's clock with the same offset frame extraction uses.
* fix(engine): a late-starting file's picture shows on the clock its audio plays on
* test(producer): vfr-screen-recording baseline shows each frame at its timestamp
* perf(engine,cli): a machine's GPU encoder probe runs once, not on every render
* refactor(engine): one shared probe per process, no answer kept on disk
* ci(windows): probe that a render opens no visible window
* ci(windows): the probe names what opened each window
* ci(windows): the probe spawns each binary alone, with and without detached
* ci(windows): the probe logs the processes started during the render
* ci(windows): the probe also spawns Chrome one consoleless hop down
* ci(windows): the probe logs each child started without windowsHide
* ci(windows): the probe logs every child process with its windowsHide and detached
* fix(engine): Chrome keeps the CLI's console on Windows, so a render opens no window
* fix(cli): every child the CLI starts on Windows is hidden unless it opts out
* ci(windows): the probe bisects Chrome's flags and keeps each command's output
* ci(windows): the probe names the Chrome process behind each window
* ci(windows): the probe loads a page in Chrome directly and one hidden hop down
* ci(windows): the probe prints the Chrome main command line and renders with the reporter's flags
* ci(windows): the probe narrows the CLI's Chrome arguments to the ones that open a window
* ci(windows): the probe launches the CLI's Chrome arguments one hidden hop down
* ci(windows): the probe launches Chrome through the engine's browser pool
* ci(windows): the probe varies what the engine passes to Puppeteer
* fix(engine): renders on Windows launch Chrome with a Puppeteer that keeps it attached
* refactor(cli): hideChildConsoles copies its arguments and keeps one comment line
* fix(engine): extraction waits out the decode up to a deep seek in a long-GOP video
* chore(engine): shorten the keyframe gap doc comment
* fix(engine): cancelling an extraction during the keyframe probe reports a cancel
* fix(engine): a segment stopped by another's failure reads as stopped, not cancelled
* fix: phone videos with an undecodable first audio track check, preview and render
* fix(engine): a rate-lane clip bakes its ramp from the decodable audio track
* test: phone-clip tests end ffprobe options before the input
* fix(engine): a scratch folder Windows refuses to delete no longer fails a finished audio mix
* fix(engine): audio scratch files Windows refuses to delete no longer fail a render
* fix(engine): a rename Windows keeps refusing falls back to a copy so the audio mix finishes
* fix(engine): audio scratch left behind is counted in the render log
* style(engine): wrap the long rename fallback test call
* refactor(engine): split the rename fallback decision out of the retry loop
* fix(engine): the rename copy fallback is opt-in and scratch leftovers are counted per render
* style(engine): keep renameWithRetry's comment share at the base
* style(engine): drop the blank line left by the comment cut
* fix(producer): convert HEIC images to JPEG at compile time
Tiled HEIC photos probe as several video streams, so the media-type
preflight rejected them as image:video, and Chrome cannot decode HEIC.
Sniff the ftyp brands of every <img>, join and rotate the tile grid with
ffmpeg, verify the declared size, and swap in a cached JPEG.
* fix(producer): shorten the HEIC prep comments
* fix(producer): name host tool failures and keep a failed HEIC preview image as authored
Also: HEIC tests run in the integration lane; the primary grid is picked by default disposition.
* chore(producer): raise the package size budget for the HEIC prep
Frame extraction decoded every source in software, so a long 4K60 HEVC clip
spent much of its CPU on decoding. On macOS, extraction now asks ffmpeg for
VideoToolbox when this ffmpeg has it and the source cannot carry alpha; ffmpeg
falls back to software for a stream VideoToolbox cannot decode, and the frames
written are byte-identical.