Skip to main content

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:
Use the owning app’s documented environment variables and an approved dev/staging service configuration. Keep values in ignored local env files. A remote database URL is not permission to change production data. Do not require 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

This runs 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

Focused tests can use explicit worker bounds. Before broad validation, inspect 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 in apps/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, and causeProven 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 distinguish loader-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’s scripts/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 opaque x-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:
For the separate 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.