Choose the smallest environment
Docker setup, the Docker cron runner, Rust, and TanStack Start are not required
for the active path. A particular database/container integration test may still
need an isolated container runtime; offload that test rather than treating it as
a requirement for every task. Fixtures do not prove a real database migration or
hosted media network works.
Install and run an active app
Use the repository’s pinned Bun and Node requirements from the version reference:bun setup for
minimal onboarding: it can build packages and probe Docker/local services.
When runtime development is needed, start only the selected Next app, for example
bun dev:web or bun dev:calendar. Portless provides the established app host
and central-login boundary. The package’s dev:app is available for direct-port
work, but cross-app auth still needs valid local origins and coordinated URLs.
Do not start Rust or TanStack Start merely to satisfy an old setup paragraph.
Preview documentation locally
scripts/local-docs.js from the repository root. It executes the
pinned Mintlify CLI through npx in apps/docs and needs no Docker daemon,
Compose stack, database, Rust, or TanStack Start. The CLI pin is read from apps/docs/mintlify-version.json, independently of
retained Docker configuration.
The first run downloads that version; later runs can reuse the npm cache.
Stop the foreground preview with Ctrl+C.
For another port or a finite link check:
--print-command shows the exact command without starting a server. bun dev:docs:local is a compatibility alias for the same local preview.
bun dev:docs:down is disabled while Docker setup is paused; stop the local
foreground preview with Ctrl+C.
Validate without building apps
ttr resources status --json and run heavy commands through
ttr resources run -- <command>. Repository policy prohibits local builds and
bun validate, whose graph can build dependencies. Require relevant test,
type-check, lint, real app builds, and strict Mintlify validation in CI for the
exact source commit. Neither this local path nor a fixture test waives a required
integration check.
Use remote fixtures deliberately
An approved remote devbox can host isolated Supabase or database-dependent suites while local editing stays lightweight. Verify the runner’s actual host and checkout; a same-machine container does not offload work. For SQL migrations, apply to an isolated database and record its exact schema/test evidence. Hosted Supabase dev/staging services can support read-only application testing when configured, but they are not interchangeable with a disposable migration test fixture. See Remote devboxes, Local Supabase development for optional isolated fixtures, and the active runtime map for current ownership. The docs wrapper uses the Node patch pin inapps/docs/mintlify-version.json.
Other host versions use an isolated npx runtime without changing the host
installation. See Mintlify runtime compatibility
for the cancellation mechanism, validation guarantees and pin removal criteria.
Focused Forms metadata/loader tests resolve their mocked Supabase server boundary
from source via apps/forms/vitest.config.ts, so they do not require a shared
package build or a Docker database. They cover author noindex settings and
anonymous/protected snapshots; they do not prove live database access.
Hosted profile await diagnostics
The hosted fixture installs Chromium OS packages through a temporary APT configuration selecting the runner’s signed Ubuntu sources. Unrelated vendor feeds do not participate; missing Ubuntu sources or package failures stop setup. Browser downloads run as the runner user. A setup failure before tests produces no profile acceptance result, even if the terminal artifact is absent. The disposable hosted Lettin profile fixture retains fixed server read-stage counts in its existing terminal receipt. Profile actor, bindings, creator and public-world reads, and workspace layout session, workspace, invitation, list and navigation reads use the existing CI/explicit-diagnostic gate. Wrappers preserve results and rethrow the original error; they add no queries, retries, permission changes or navigation time. The collector uses its existing owned private log checks and 128-KiB tail. Only allowlisted stage names, capped started/completed/failed counts and last status leave the collector, with at most 256 events and explicit tail/event truncation. Completed and failed read durations retain observed/absent/invalid counts and maximum milliseconds; a real zero differs from an absent value. Recognized Next startup, compilation and type-checking display timings remain separate fixed categories. Display decimals convert exactly at their emitted precision. Missing compiler timing remains unknown, including webpack paths that emit none. These aggregate maxima have no request correlation and must not be added into a critical-path estimate. Each summary has an 8192-byte guard with explicit loss flags. Timing regressions cover malformed/overflow values and decimal precision. No raw log lines, paths, request IDs, user data or error messages are retained. Concurrent reads are not request-correlated: unmatched counts or last status cannot identify a stalled request, particularly after truncation. Missing stage observations are inconclusive, andcauseProven remains false. HTTP 200 with an
unfinished body is not navigation success. Use the bound receipt to narrow the
next investigation; preserve the actual profile assertions, cleanup and exact-head
runtime gate. These diagnostics alone establish neither a causal repair nor
provider or production acceptance.
Failed profile navigation also retains bounded browser observations in
terminal.results[].navigationDiagnostics. Request starts, responses, finishes,
failures and frame commits remain separate from body completion and page
DOMContentLoaded/load. Read capped counts and truncation fields before drawing
conclusions; unobserved requests and frame load stay unknown. The helper records
only safe route classes, local ordinals, relative timings and fixed status fields.
It retains no raw URLs, arbitrary headers, bodies or failure text. The result parser accepts
one versioned text record from the failed profile attempt and preserves its status.
These observations preserve the original navigation deadline and error. They do
not prove a load blocker or justify a retry. Helper and result-summary regressions
cover privacy, framing, limits, cleanup and late callbacks; actual runtime evidence
still requires the exact-head fixture gate.
Native Wrangler prototype CI validation
Meet SSR diagnostics distinguishloader-import, loader-model, handler and
render-boundary. The owning router predicate identifies thrown router redirects;
handler outcomes distinguish returned 500s, redirects and other responses. Original
throws and responses retain their identity. Records contain only closed enums,
allowlisted error names/codes and up to four known function names with bounded
numeric locations. Accessor-backed inspection is unavailable; messages, causes,
raw stacks, URLs, headers, cookies and environment values are never projected.
Handler records add only login, callback, other or UNKNOWN request scope,
classified from the three canonical locale variants of each public route. Local
closures carry scope through the outer proxy pipeline and the Start handoff;
delegating records precede each handoff, followed by its original outcome.
Concurrent requests share no mutable correlation state. Loader/render observations
remain scope/stage UNKNOWN; temporal proximity does not bind them to a request.
A terminal login/proxy record may also contain one strict loginRedirect
projection. A request-local closure classifies the actual navigation argument,
constructed redirect, Start fetch result and final proxy result using fixed
origin/path enums. It retains no raw target, query or request identifier. The
same optional callback crosses both request contexts and is sealed at the outer
outcome; multiple navigation calls saturate to an ambiguous classification and
late callbacks cannot change the snapshot. Missing or unavailable cells do not
prove a producer. Compare the first divergent boundary only after exact-source
hosted capture; pure handler controls use a fixed Start port and do not qualify
Start finalization or the shared login page. Coverage lives in
login-redirect-diagnostics.test.ts, handler-start-handoff.test.ts and the
existing bridge/parser suites. The navigation hook uses the owning server-only
factory; the real build and emitted client inspection must confirm its removal
from client code before delivery.
The collector accepts the exact observed SDK ANSI ERROR prefix and closing reset,
as well as the bare marker and Node TAP marker. It performs no general ANSI
stripping or mid-line marker search. Foreign prefixes remain ordinary output,
while recognized malformed or oversized diagnostic payloads are suppressed.
Emission is limited to 64 records per Worker instance plus an overflow marker.
The launcher suppresses marker lines from forwarded output, bounds candidates to
64 lines of 2048 characters, sanitizes again after natural child close and pipe
drainage, and includes the result in the existing private parent-finalization
evidence. Missing or incomplete capture is UNKNOWN; dropped records are counted.
These diagnostics add no request, retry, timer or runtime acceptance. A login 500
remains unexplained until exact-source hosted evidence identifies its phase and
outcome. Pure controls live in ssr-diagnostics.test.ts,
ssr-error-boundary.test.tsx and meet-ssr-capture.test.mjs.
Meet’s finite meet-emitted-v1 graph uses two public
unstable_startWorker handles and one fresh private registry. Both the original
and restored artifact gates run node scripts/ci/meet-native-launcher.mjs "$SOURCE_SHA". Each launcher runs all twelve original cases and three HTTP hook
controls twice, with distinct private homes, registries, temporary roots and
nonpersistent local storage. The existing three-minute CI watchdog and 30000 ms
per-case deadlines stay in force; duration fit and real binding resolution need
exact-commit CI evidence. Never run it without a fresh sealed emitted artifact.
Pure checks use node --test scripts/ci/meet-native-admission.test.mjs scripts/ci/meet-native-lifecycle.test.mjs scripts/ci/meet-native-supplier.test.mjs.
Public SDK readiness can precede the real user-worker registry publication.
After acquiring and starting both handles, the graph makes exactly one public
GET to the canonical app /.well-known/meeting-runtime route (200, version 1)
and one unauthenticated probe POST (403, Forbidden). Both bodies must drain
and validate, with unchanged outbound-hook counters, before the unchanged strict
registry admission. This uses neither private readiness nor retries. Failure
retains bounded projected registry facts in the existing private lifecycle receipt
before reverse disposal: role categories and shape, freshness, loopback, mapping
and instance-reuse booleans only, without raw names, records or identifiers.
The projection never grants admission. Deferred-response/body-drain regressions
and empty, foreign, stale, reused and invalid-mapping registry controls remain
pure checks; actual SDK linking and deadline fit require exact-head hosted CI.
The app config remains byte-identical, including metadata/normalization paths,
ordered compatibility flags, ESModule rules, self-reference service, local R2,
Images and Live SQLite migration. Normalization paths are provenance, never
ambient-config discovery authority. Meet’s finite inventory hashes the exact emitted hidden files
client/.assetsignore, server/.vite/manifest.json and server/.dev.vars, plus
the .vite directory. The ignore file must contain exactly the producer’s two
rules (wrangler.json and .dev.vars); dev-vars must contain only the exact two
public CI placeholder assignments. This file is inert sealed evidence: explicit
empty environment-file selection prevents ambient loading, and fixture bindings remain injected.
Nonfixture public values, private values, extra keys, unknown hidden paths,
symlinks and incomplete layouts fail before SDK load. Vite metadata has a closed
typed field set; output paths and import references must point into the sealed
inventory. Source IDs remain provenance. The shared generic hidden-file rejection
is unchanged. A valid archive manifest alone does not establish that a fixture
profile admits every emitted file; preserve a positive actual-layout regression
and unknown-hidden/credential negatives in meet-native-hidden.test.mjs.
The authored probe uses an external Live
namespace and the named MeetingAIProvider service binding. Acceptance requires
the real emitted Live class’s exact 401 and the real named provider’s exact 403
with zero HTTP attempts; a route or manually constructed class cannot replace
these cases. Unsupported local resources, registry records or remote auth fail
closed. Do not strip bindings to obtain startup success.
The finite fixture also admits exactly eight app-role GETs to the synthetic
https://meet-ci.supabase.invalid/auth/v1/admin/users/be0e8f2e-c239-4e40-a1f4-d6881938cae4
account-assurance endpoint. meet-native-assurance.mjs defines the sole subject
and deterministic confirmed, unbanned account with server-owned optional MFA.
Both admin credential headers must match the generated disposable fixture key;
URL credentials, cookies, query parameters, other subjects/methods/origins and
excess reads are denied. These reads have their own counter, separate from the
single central API forward: two for logout and three each for the authenticated
forward and app denial control. Real production signature and current-account
MFA guards still run; banned, MFA-required and unavailable account responses must
fail in the real-proxy tests. No production auth fallback or provider access is
introduced. The focused vitest.native-auth.config.ts retains real auth/locale
code, uses the existing product Vite bun source-export condition for Node/SSR
resolution, and transforms only next-intl for its extensionless Next import.
Its include array selects only the public-callback/assurance test file. The
ordinary app test config excludes that one file; the dedicated unconditional CI
gate restores the standard exclusions and executes it with real auth and locale
code. No test is replaced with a skip.
Coverage shards also run this existing focused config after a successful ordinary
suite, only when run-test-shard.js receives --coverage and its dynamic shard
plan owns @tuturuuu/meet. The focused run keeps its one-worker cap and writes to
apps/meet/coverage/native-auth, so its report cleanup cannot overwrite the
ordinary coverage report. Existing coverage artifact collection includes both
reports. Unit and plan modes, other shards and failed ordinary suites do not
start it; focused failures remain shard failures. Verify actual focused coverage
hits the public callback return, preserves the parent report inventory and keeps
all 25 ordinary test files discoverable. Runner command-sink regressions live in
scripts/ci/meet-focused-coverage.test.mjs; omitting the focused invocation must
fail coverage verification. This does not qualify the emitted Worker runtime.
HTTP500 fixture responses are consumed into bounded private receipt diagnostics
before the original exact-status assertion fails. At most four projections retain
only route/content/error/owning-frame categories and bounded lengths; no response
bytes, headers, tokens, arbitrary errors or paths are persisted. The 64 KiB bound
marks oversized cancellation or failed reads truthfully rather than claiming a
complete drain. Unrecognized response errors remain UNKNOWN. These observations
are response markers, not proof of an underlying server exception; product login
routing must not change to conceal an unexplained HTTP500.
The HTTP fixture claim covers trusted repository app/probe code through each
configured role’s outbound hook. App allows one exact bounded central API forward
and the ten exact synthetic account-assurance reads above; probe allows none.
Live controls exercise app default, app named-entrypoint and
probe hooks, including private/loopback/lookalike targets. Hash-pinned SDK generated
helpers, assets/registry/control-plane traffic and Node control paths are trusted
tooling outside that claim. This is neither hostile-code isolation nor whole-process
or TCP confinement. Production access, billing limits and durable stop guards are
unchanged. The app’s required provider binding gets only a disposable synthetic
value; no ambient credentials or remote bindings enter the child environment.
Runtime suppliers resolve from Meet’s package and then Wrangler’s ancestry:
Wrangler 4.151.2 CLI SHA256
507cd3644d6a53f0d66922d79c04b03557b7d2d0a376d2d906b92ed20812bb30
and Miniflare 5.20261019.0-beta entry SHA256
309b8863f0f4c3050e173e945b4c696db8c330cdf3f35f0ecfd8417d75891eaa.
Both pins are checked before and after SDK load, with preloads rejected and
ownership rechecked across the graph. These attest two entry files, not the
entire transitive installation. Keep the independently pinned normalization
producer separate. A missing or mismatched installation is a blocker; do not
restore dependencies without determining cause and authority.
The graph records each returned public handle before readiness, disposes in
reverse order exactly once and attempts both disposals even when one fails.
Startup/readiness/primary/disposal errors remain separate. The launcher observes
natural child close and stdout/stderr drainage before independently checking
original/copy seals, both SDK work directories, registry removal, foreign sentinel
and temporary-root inventory. A verified retained snapshot precedes removal;
any failed gate retains scratch. Finalization persistence has readback checks.
Private seven-day CI artifacts retain a tar archive of the existing owned
meet-native-run-* roots, including hidden .wrangler snapshot files, modes,
links and empty directories. Upload only the archive, avoiding the upload action’s
hidden-file filter. meet-native-evidence.test.mjs executes both selected packaging
commands and compares extracted inventories, including an omission negative;
logs contain bounded statuses rather than fixture credentials. No sweeper, retry,
forced exit or private SDK controller may manufacture closure. SDK internal
cleanup and descendant closure remain UNKNOWN even after public disposal and
natural owned-child close. Pure/source checks do not qualify the emitted graph.
The original validation step also runs the synthetic native Wrangler prototype
unit/runtime suites with file concurrency one and default Node process isolation.
They retain their existing test limits and the same outer three-minute watchdog.
Synthetic qualification is independent of Meet acceptance and does not qualify
Calendar or Apps callers. Historical raw NOTPASS evidence stays unchanged.
Public Worker.ready reports proxy readiness, not successful user-Worker linking.
For the four allowlisted returned-Worker startup controls (WASM, logical import
underflow, missing text export and Node builtin), classify the target error only
if observed from a single public dispose(): require the exact public name
MiniflareCoreError [ERR_RUNTIME_FAILURE], code ERR_RUNTIME_FAILURE, and the
case-specific user-service diagnostic predicate after observation, with fulfilled
proxy readiness. Preserve the observed error C and all primary, ready and disposal failures separately. Do not
invent a ready error or error-object identity, or infer generic disposal success.
Executed evidence qualifies only this isolated harness; caller adoption still
requires separate real-graph acceptance. Existing NOTPASS records stay unchanged.
For the isolated harness, retain a parent-owned sealed cleanup plan. Observe
natural child exit and its actual code/signal (require code 0 and null signal),
then collect residual, original,
copy and foreign-sentinel proofs independently, even when another phase fails.
Before deletion, verify a complete diagnostic snapshot outside every removal
target, including readback and preservation of partial failures. A surviving
pathname or hash cannot recover deleted bytes. If snapshot verification fails,
retain the source and stop deletion. Seal, snapshot, retention, persistence and
removal closure must all pass independently; a receipt or error alone is not
closure. Awaited disposal is not a filesystem fence: Miniflare can schedule
removal through fireAndForget. Keep the current finite archives for parent
collection and disposition; do not add automatic sweeps, retries, timeouts,
controllers or private SDK hooks.
The isolated public SDK harness has one intentional pre-return syntax case:
export default = ; must produce exactly the owned copied-entry compiler
error Unexpected "=" at line 1, column 15, with no extra error graph. It may
report OBSERVABLE_SYNTAX_REJECTION_WITH_CLOSED_CHILD only after the parent
observes natural child close, exit 1 with no signal, drained stdout/stderr and
no spawn/output failure or intervention. Original/copy seals, residual and foreign
file guards, verified retained snapshot, successful owned-file removal and
verified finalization persistence must all succeed first. A failed proof retains
its errors and available evidence; a failed snapshot prevents removal and retains
the source. Internal cleanup and descendant-process closure remain UNKNOWN.
This is a distinct observable negative outcome, not ordinary SDK success or proof
that Wrangler’s unobservable internal disposal fulfilled. Every other startup
failure still fails closed. The existing CI watchdog must continue to fail a
stuck stage; no timeout, forced exit or retry can qualify this case.
Synthetic controls live in native-wrangler-observable.test.mjs, imported by the
workflow’s explicitly named native-wrangler-runtime.test.mjs entry. Run that
entry in CI before reviewing the isolated SDK syntax result. Existing Meet,
Calendar and Apps application runtime callers require separate qualification
before adopting this contract.
Calendar emitted Worker caller
Calendar’sscripts/ci/calendar-native-worker.runtime.mjs uses the public
unstable_startWorker adapter with the owning Calendar SDK resolution. Its finite
calendar profile requires the existing calendar-artifact.json seal and
calendar-native-artifact.mjs validator: exact compatibility flags, module rules,
assets, normalized defaults and empty resource registrations remain checked.
The emitted configuration is copied byte for byte, without deleting fields or
inventing module relationships. The default adapter profile still rejects unknown
fields, compatibility flags and external Workers as before.
This local fixture trusts the hash-pinned Wrangler 4.151.2 and its owning
Miniflare 5.20261019.0-beta control plane. The configured Calendar application
Worker receives an explicit outbound handler that returns status 599 for every
request and records unexpected origins; there are no allowed outbound fixtures
or configured probe Workers. SDK-generated core, registry and debug helpers and
Node networking are outside this application egress boundary. A bug or compromise
in that trusted tooling can retain network capability. This is not whole-runtime
confinement or a sandbox for hostile code. Production cost, durable stop and
access guards retain their separate acceptance requirements.
The caller acquires the public handle before observing readiness, memoizes
disposal, observes natural child close and drained pipes, and independently
checks original/copy seals, residuals, the foreign sentinel, retained diagnostics,
removal and finalization persistence through the existing helper. Failed gates
retain evidence. Internal SDK cleanup and descendant closure remain UNKNOWN.
The original bilingual rendering, locale cookie/header, hydration asset and exact
offline URL assertions remain. The companion
apps/calendar/src/runtime/offline-artifact.runtime.mjs still tests emitted
classic service-worker bytes in a VM and does not construct a native SDK runtime.
The adapter suites request-context.test.ts, next-navigation.test.tsx and
handler-start-handoff.test.ts exercise real request storage, cookie serialization,
memory-router transitions and handler forwarding through fixed external ports.
They cover behavior independently of generated registry invocation counts. Memory
history does not qualify browser scrolling, and router search normalization does
not prove duplicate-key preservation. If unbuilt workspace exports block local
collection, a private source alias can qualify focused source behavior only;
normal dependency builds and exact-commit CI remain separate requirements.
Run the source-only profile controls through the canonical resource queue with
node --test --test-concurrency=1 scripts/ci/calendar-native-artifact.test.mjs scripts/ci/calendar-emitted-defaults.test.mjs scripts/ci/native-wrangler-runtime.test.mjs. These controls do not import the SDK
or qualify a real Worker. After review and parent integration, the existing
mail-calendar-tasks-builds.yaml Calendar job must build fresh artifacts for its
exact SOURCE_SHA, emit the supplier hashes, run
node scripts/ci/calendar-native-worker.runtime.mjs "$SOURCE_SHA", run the
companion offline suite, and verify the original seal under the unchanged
three-minute runtime watchdog. A restored artifact must pass the same caller and
seal checks for that exact source. Runtime acceptance remains pending until those
hosted gates pass; no local build or dependency restore is required for the pure
controls.
The dedicated preload-control outcome has a different scope; it grants no generic
missing-Worker waiver. The next bounded CI observation must retain the public
cause chain and proof-phase states, explicit unknown/missing/truncated fields,
and normalized path roles while preserving full diagnostics privately. Do not
infer a parser route or closure from absent public fields. Existing raw NOTPASS
results remain unchanged. Never stage sensitive transcripts; see the CI tooling
reference for supplier evidence.
Profile request attribution
Only the existing disposable hosted development profile diagnostic gate admits request attribution. GET HTML document requests receive a fresh 128-bit opaquex-lettin-profile-request-id at proxy entry, replacing any incoming value. The
existing next-intl request-header forwarding carries it into the request context;
the actual response exposes the same ID. Request-scoped memoization reads the
context once for fixed read-stage events. Browser extraction retains only a
validated ID, and terminal.results[].readCorrelation joins the single main
profile document response to that ID’s bounded events. Redirect IDs cannot stand
in for the destination document. Missing, malformed, duplicate, ambiguous,
cross-attempt or truncated evidence remains unknown; older unattributed aggregates
remain intact. Attributed reads prove only read-stage observations, never renderer,
HTML stream, DOM or page-load completion. Regression coverage lives in
profile-proxy-diagnostics.test.ts, read-diagnostics.test.ts,
profile-request-identity.test.ts, mail-profile-correlation.test.mjs and
mail-profile-result-summary.test.mjs. Run them in the admitted CI environment;
source inspection and syntax checks do not establish runtime acceptance.
Apps finite emitted Worker callers
Both Apps acceptance entries use the Apps-owned finite public SDK adapter:apps/apps/cloudflare/native-built-worker.test.mjs and
scripts/ci/apps-native-browser.runtime.mjs. The former retains the real HTTP,
SSR, locale/query redirects, discovered RPC, PATCH/cookie forwarding and exact
599 compiled-handler negative control. The latter retains real Chromium anchor
clicks against the public Worker.url listener. Existing request, navigation,
test and CI watchdog limits remain unchanged. A listener-visible locale redirect
must preserve its original scheme, host and port; a proxy-origin mismatch fails
acceptance rather than changing the expected URL.
RPC discovery parses sealed JavaScript metadata and requires exactly one distinct
ID for the Apps gateway function. Accept string literals and expression-free,
single-quasi template literals with a string cooked value. Reject interpolation,
tagged templates, dynamic expressions, zero candidates and distinct-ID ambiguity;
never evaluate aliases or use source maps to supply or normalize an ID. Preserve
parse and symlink failures. The adjacent native-artifact-functions.test.mjs
retains a hash-checked actual emitted chunk and negative controls. Its pure
success does not establish actual RPC wire or Chromium/restored acceptance.
The plan invokes apps-native-artifact.py verify with an explicit source SHA and
canonical receipt, checks the actual native or saved deploy pointer and preserves
all normalized configuration fields. Every session copies every sealed emitted
module and asset, including .assetsignore, without rewriting producer metadata.
The Apps hidden metadata profile additionally admits only server/.vite as a
directory containing exactly one regular manifest.json. That file stays in the
source receipt, original/copy inventory and every session copy. Its bounded JSON
entries use a closed field vocabulary; file/CSS/asset references must name hashed
regular entries in the sealed server inventory, and imports must name own manifest
entries. Own __proto__ keys survive as data without prototype mutation. Reject
unknown hidden paths, env/credential entries, links, incomplete metadata, escapes,
unsealed references and malformed or mistyped fields. Existing .assetsignore
and deploy-pointer admission remain unchanged. This profile does not admit SDK
workdirs before startup or exclude .vite from seals. Cover it with
apps-native-runtime-hidden.test.mjs; metadata admission is no runtime proof.
The application resource/auxiliary topology must remain exactly empty. HTTP uses
two unchanged Apps copies, each with a private registry; its negative role changes
only the admitted API fixture origin. Browser uses one copy. No Meet graph,
synthetic app, raw Miniflare constructor, private SDK accessor or option deletion
is part of this adapter.
Wrangler resolves from apps/apps/package.json, and Miniflare resolves from that
Wrangler CLI. Before SDK loading, require Wrangler 4.151.2 CLI SHA256
507cd3644d6a53f0d66922d79c04b03557b7d2d0a376d2d906b92ed20812bb30
and its Miniflare 5.20261019.0-beta entry SHA256
309b8863f0f4c3050e173e945b4c696db8c330cdf3f35f0ecfd8417d75891eaa.
These are requirements, not evidence that an installation is qualified. Reject
preloads, wrong ancestry, byte/version changes, owner/lock changes and runtime
build-SHA bindings. A stale owning lock edge requires separately admitted
package-manager repair; root package presence is insufficient. Do not hand-edit
the lock or broaden pins when a scoped repair churns unrelated dependencies.
The configured app and negative-role HTTP hooks deny every nonfixture origin.
HTTP forwarding admits only the exact disposable 127.0.0.1 origin and the existing
method/path/query contracts, propagates headers/body/cookies and cancellation,
and never follows redirects. Account assurance has a separate recorded category:
only GET of the one generated fixture UUID’s exact admin-user URL, with the
captured generated service key in both apikey and Bearer authorization, no
query, fragment, URL credentials, Cookie or body. The local fixture validates
the same request before returning its explicit server-owned non-required policy.
The HTTP app permits exactly four assurance reads: three compiled API guard
negatives (required MFA, banned account and unavailable policy), then the original
signed PATCH. The negative role permits exactly one assurance read before its
original API 599 denial; central forwarding stays zero and the exact denied-call
counter remains one. The same signed session is reused across account-policy
transitions; production guards and policy freshness are unchanged. Required,
banned and unavailable cases must return 403/MFA_REQUIRED, 401/UNAUTHENTICATED
and 503/AUTH_UNAVAILABLE respectively, without forwarding or clearing cookies.
Two signed SSR locales and one signed RPC account for three profile forwards;
the original PATCH remains the sole forwarded write, with its exact query, body,
cookie and two response cookies. Require the separate counts in child and parent
receipts; an extra request fails rather than increasing a cap.
Each role retains at most 32 hook operations across all categories, including two
pre-start denial controls; PATCH bodies retain the 16 KiB cap. Browser app HTTP
remains deny-all with zero assurance reads; anonymous Chromium anchor navigation
needs no account fixture. One owned page-target CDP session admits the runtime
listener and existing exact in-memory destination origins. Its Fetch request-stage
listener is attached before wildcard enablement and classifies every redirect hop
independently: continue the fixed listener without overrides, fulfill destination
HTML in memory, or fail with BlockedByClient. Neither page.route nor context.route
covers redirected hops in the owning Playwright 1.63.0 implementation; do not
stack those interceptors with this fence. Counters have fixed categories and a
4096-request ceiling; diagnostics retain no request URLs, headers or payloads.
Fetch remains enabled through owned page closure; handler promises drain before
session detachment and listener removal. Setup, protocol, navigation and cleanup
failures all fail acceptance. Scope is one page target, without browser-wide,
OOPIF or popup coverage. The historical browser timeout cause remains UNKNOWN.
native-browser-fence.test.mjs covers protocol, cap and lifecycle failures without
loading the SDK. The finite apps-native-browser-fence.runtime.mjs proof uses only
two disposable 127.0.0.1 listeners: actual anchor, 307, intermediate listener hop,
and exact final URL/load. Its old-route RED control must fulfill zero requests
and reach destination upstream once. CDP GREEN must fulfill once with zero
upstream; an unadmitted destination must block once with zero upstream. CI uses
owning bundled Chromium after the existing Web Chromium installation. A local
machine with bundled Chromium absent may explicitly run
ttr resources run -- node scripts/ci/apps-native-browser-fence.runtime.mjs --chrome
with existing Chrome through Playwright’s public channel, headless and a fresh
owned ephemeral profile. Never use a real user profile. Local Chrome proof does
not qualify CI bundled Chromium or emitted Worker acceptance; no SDK, account
fixture or external host participates in the finite proof. Keep strict residual
checks, including rejection of unknown .org.chromium files; do not delete foreign
residuals or broaden admission for browser temporary files.
Hash-pinned SDK-generated actors and Node
helper/debug/control networking are trusted tooling outside this claimed
application HTTP confinement. This is no OS, TCP or DNS firewall claim. Focused
policy/receipt tests use doubles and do not qualify the compiled guard; original
and freshly restored hosted HTTP and real Chromium acceptance remain required.
The launcher supplies fresh allowlisted child environment, HOME/XDG/temp roots,
empty fixture env file and per-role registries. Browser alone receives the
installed Web-owned Playwright cache path. Each public handle is owned before
readiness and disposed once in reverse order. Browser closure precedes session
teardown; primary/start/readiness/disposal failures remain separately recorded.
Natural child close, code 0, null signal and both drained pipes are independent
of the child’s finite assertion/lifecycle receipt. Parent readbacks recheck the
original/copy/pointer/receipt/owner/lock/supplier evidence and foreign sentinel.
Generated .wrangler workdirs are inventoried separately; only those exact
directories are excluded from copied-source seal comparison. A verified snapshot
and pre-removal persistence/readback precede owned scratch removal. Failures retain
scratch and diagnostics; final persistence failure also fails qualification.
Internal SDK cleanup and descendant closure remain UNKNOWN.
Run source-only checks through the canonical resource queue:
apps-native-artifact.test.py suite on macOS, use a canonical
temp directory such as TMPDIR=/private/tmp. Its restore fault injection compares
exact paths; the /var versus /private/var alias can prevent the injected move
fault from firing. Preserve every assertion when correcting fixture setup.
These tests use normalized data fixtures and supplier/lifecycle doubles. They
neither load the SDK nor qualify real emitted output. Exact-commit CI must build,
seal, run both original callers, pack unchanged qualified bytes, restore them to
fresh output and repeat both callers and final seal checks. Both HTTP steps use
the same APPS_ARTIFACT_RECEIPT as browser acceptance. Each invocation creates new
home/temp/registry custody. CI retains a seven-day tar archive of
$RUNNER_TEMP/apps-native-evidence, including hidden snapshot/workdir evidence,
on success or failure. Archive the directory itself, not a shell * expansion.
Source review, supplier correction, real runtime acceptance, promotion and customer
acceptance remain separate gates.