* test(engine): a capture page whose tab Chrome closed while opening it is replaced once or named
* fix(engine): reopen a render page whose tab Chrome closed while opening, or say why it can't
* style(engine): keep openPage's comment to two lines
* feat(engine): renders send page traffic through the egress proxy in HYPERFRAMES_CAPTURE_PROXY
* feat(engine): render media downloads go through the egress proxy in HYPERFRAMES_CAPTURE_PROXY
* fix(engine): downloads through the egress proxy keep undici's fetch, so gzip text and headers work
* fix(producer): resume checks the segment file the join reads, not the manifest's path
A resumed segmented render now validates each reusable segment at its own
computed path in the segment folder. It must be a plain file, not a link, and
match a slice of this render's plan. The path a manifest records is never
opened or probed.
* fix(engine,producer): concat joins open only the list and encoder containers
Both concat-demuxer joins (the engine's chunk and segment concat and the
distributed assemble join) now pass a format whitelist of concat, mov and
matroska. ffmpeg applies it to every file the list opens, so a listed file
that is a playlist or manifest cannot pull in other files, while mp4, mov and
webm joins work as before.
* fix(producer): resume reuses only segments this install recorded
Segment manifests are now signed with an HMAC keyed by a per-install secret
kept in the HyperFrames config folder, outside every project. Resume trusts a
manifest only when its signature checks out, so a segment folder copied from
another machine or shipped inside a project is captured again, while a
render's own interrupted run resumes as before.
* docs(producer): restore the segment path ordering comment and rewrap resume docs
* fix(producer): replace an empty or short resume key file
A key file too short to use is now replaced by a fresh key instead of
disabling resume for good. A missing key is still linked into place, so
renders that create it at the same time share one key; a test runs eight
processes against one path to check that.
* fix(producer): warn under --resume when no resume key is available
When the resume key can be neither read nor created, for example on a
read-only home folder, a file system without hard links or a serverless
runtime, --resume now logs one warning that every segment will be captured
again instead of only reporting zero complete segments.
* fix(engine): fail a concat join at a list entry ffmpeg refuses
The concat demuxer ends the stream at a listed file it cannot open and ffmpeg
still exits 0, which cut the output short without an error. -xerror on the
concat input makes the join fail instead. mp4, mov and webm joins still exit
0.
* fix(producer): resume checks each reused segment's SHA-256
Each finished segment's SHA-256 is now recorded in the signed manifest. The
hash is taken once when the segment closes, and on resume only the files
about to be reused are hashed again, so a file swapped for another of the
same size is captured again.
* docs(cli): note that resume re-checks segment hashes and recaptures older segments once
* fix(studio-server): proxy joins only its own pieces, through the shared concat input
Studio's chunked proxy copy now names its pieces with a tag keyed by the
user's preview token, so pieces that arrive inside a project folder sit at
names it never looks up and every piece is encoded fresh. A stopped copy of
the user's own still continues from its finished pieces.
The piece join uses concatListInputArgs, now in @hyperframes/parsers so the
engine, producer and Studio share it. It allows only local files in the
concat, mov or matroska formats and fails at a refused entry. The cache sweep
recognizes both tagged and older piece names.
* test(parsers): prove the concat protocol whitelist with a data: entry
ffmpeg already refuses http:// in a concat list opened from a file, so the
test passed without the whitelist. A data: entry opens by default; the test
now asserts it is refused as not on the 'file' whitelist.
* fix(studio-server): only the copy's own tagged pieces count as lock progress
The copy lock counted any .part-<key>- file as the owner's progress, so a
piece shipped with a future modified time kept a stalled lock looking active.
It now counts only names under the copy's own tagged piece prefix. The cache
sweep removes untagged pieces past the usual age even while that copy runs,
and measures age in both directions so a future-dated piece is swept too.
* fix(studio-server): say once when proxy pieces cannot be keyed to the user
Without a preview token, piece names use a per-process secret, so pieces are
reused only within that Studio process. Studio now logs that once, so a copy
restarting from its first piece after a restart has a visible cause.
* test(studio-server): name the proxy join test for what it checks
* fix(producer): derive the segment manifest key from the preview token
Sign segment manifests with an HMAC key derived from the per-user preview
token instead of a separate key file. The token is created with an exclusive
open, so concurrent renders never end up with different keys, and it is only
used when the file is private to this user.
Resume now checks a segment's SHA-256 before probing it, and a real-ffmpeg
test documents how the concat join treats an entry that is itself an ffconcat
list.
* docs(producer): describe the manifest key per user and the no-token case
* test(producer): remote scripts and stylesheets inlined at compile time stay within the size limit
* fix(producer): fetch each remote script and stylesheet once, a few at a time, within the size limit
Every inlined copy is charged to the render's expansion budget as it arrives;
going over fails the compile with COMPOSITION_TOO_LARGE and stops the
downloads still queued. Remote CSS is spliced in literally, so `$` sequences
in it are no longer expanded.
* fix(producer): drop the budget label comment the comment gate counts
* fix(producer): count a remote script when it arrives and stop the queue on an integrity mismatch
* test(producer): font normalization tests answer Google Fonts from a stub, not the network
* style(producer): wrap the stubbed font response
* 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
* fix: refuse media paths that ffmpeg's image2 demuxer would read as a pattern
ffmpeg's image2 demuxer reads %d, %03d, %% and a % before a wildcard in an
input path as a pattern of other files, folders included. Every project,
private-file and received-file check approves the literal path, so a
composition could name a placeholder whose pattern reaches images outside
the project and get them back as video frames.
Every ffmpeg and ffprobe input built from a project file now goes through
assertLiteralMediaInput, which refuses such a local path before ffmpeg runs.
The engine's urlInputArgs, the parsers' mediaInputFormatArgs and the
studio-server's new mediaInputArgs all take the input path, so the CLI
snapshot and cloud offload, lint, core grade analysis and studio-server
callers are covered too. URLs and other percent signs, such as %20, are
read as before.
* build(parsers): declare the literal-media-input subpath
* build: raise the parsers packed-size budget for the literal-media-input subpath
The new subpath adds its own built entry, type file and export map rows,
about 2.7 KB packed. It is a separate module so test suites that mock
ff-binaries still run the real path check.
* test(parsers): a harmless name shaped like a pattern is refused too
The local lookup that runs before a proxied download took no abort signal,
so a stalled resolver held the request past its timeout. It now settles
when the request's signal aborts.
Its pass-through list now matches what dns.lookup reports: ENOTFOUND,
EAI_AGAIN and EAI_FAIL go to the proxy; ENODATA and ESERVFAIL, which the
lookup never returns, are gone.
Adds a test that runs the real GIF step on a source saved in Studio's
private downloads folder.
* 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
* fix(engine): check proxied download hosts against local DNS; keep raw GIF downloads private
Behind an env proxy (HTTPS_PROXY with NODE_USE_ENV_PROXY=1 or
--use-env-proxy), composition downloads skipped the resolved-address check
and relied on the literal-host check alone. An internal DNS name passed, and
NO_PROXY hosts were dialled directly.
Now the downloader resolves the host on this machine first and refuses it
when any answer is non-public. A name this machine cannot resolve is still
left to the proxy, so proxy-only networks keep working.
Studio's remote GIF prep now picks only URLs whose path ends in .gif,
discards a downloaded body that does not start with a GIF signature, and
the raw downloads folder is no longer served to the page; only the converted
output is.
* fix(cli): read the downloaded GIF's header through a bounded read stream
CodeQL read the openSync call as a temp-file creation. The file sits in the
project's .hyperframes folder and is only read, but a six-byte read stream
does the same check without a file descriptor of our own.
`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>
ffmpeg resolves playlist entries with URL rules, not Node path rules. An entry
with a colon before its first slash, backslash, query or fragment mark, and an
entry resolved from a folder whose name holds a query or fragment mark, now
count as leaving the folder, so the check no longer approves a list that ffmpeg
opens somewhere else. Entries that are http(s) URLs are unchanged.
Co-authored-by: Claude Sonnet 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(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(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(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): 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
* chore: release v0.9.55
* chore: release v0.9.55 notes include #7830
* chore: release v0.9.55 notes include #7859 and #7867
* chore: release v0.9.55 notes name the docs change and cloud render
* chore: release v0.9.55 notes include #7866 and #7801
* chore: release v0.9.55 notes match the style bar
* 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.