@volter/twin-standard 1.0.36 → 1.0.38

package/dist/src/assessment.js

@@ -112,7 +112,7 @@ export async function assessPack(packDir, options = {}) {
         const transport = await chromiumServed(packDir, life.host ?? 'twin.local');
         try {
             const a = await replay(transport.served), b = await replay(transport.served);
-            browser = { measured: true, target: 'Chromium fetch, cookie jar and HTTP response behavior; no DOM interaction coverage', version: transport.version, answered: a.trace.length, failures: [...a.failures, ...b.failures], replay: { equal: a.trace.length > 0 && json(a.trace) === json(b.trace), firstSha256: hash(a.trace), secondSha256: hash(b.trace), runs: 2 }, operationCoverage: coverageOf(a), domCoverage: null, clock: 'World and page JavaScript clocks frozen; native cookie expiration uses Chromium wall time' };
+            browser = { measured: true, target: 'Chromium fetch, cookie jar and HTTP response behavior; no DOM interaction coverage', version: transport.version, answered: a.trace.length, failures: [...a.failures, ...b.failures], replay: { equal: a.trace.length > 0 && json(a.trace) === json(b.trace), firstSha256: hash(a.trace), secondSha256: hash(b.trace), runs: 2 }, operationCoverage: coverageOf(a), domCoverage: null, clock: transport.clock };
         }
         finally {
             await transport.stop();

package/dist/src/browser-assessment.d.ts

@@ -2,5 +2,11 @@ import type { ServedTwin } from './walk/behavior-journey.js';
 export declare function chromiumServed(packDir: string, host: string): Promise<{
     served: ServedTwin;
     version: string;
+    clock: {
+        native: string;
+        nativePrecisionMs: number;
+        javascriptPrecisionMs: number;
+        monotonic: string;
+    };
     stop: () => Promise<void>;
 }>;

package/dist/src/browser-assessment.js

@@ -8,16 +8,39 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 };
 // Browser transport for the existing journey engine. A container supplies network isolation in catalog execution.
 import { join } from 'node:path';
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { worldNow } from '@volter/world-core/runtime';
 export async function chromiumServed(packDir, host) {
     const { chromium } = await import('playwright');
-    const browser = await chromium.launch({ args: ['--no-sandbox'] });
     const mod = await import(__rewriteRelativeImportExtension(join(packDir, 'src/index.ts')));
     const factory = Object.entries(mod).find(([name, value]) => /^create\w+Fetch$/.test(name) && !/TwinFetch$/.test(name) && typeof value === 'function')?.[1];
-    if (!factory) {
-        await browser.close();
+    if (!factory)
         throw new Error('Browser assessment needs the pack HTTP fetch factory');
+    const library = ['/usr/lib/x86_64-linux-gnu/faketime/libfaketimeMT.so.1', '/usr/lib/aarch64-linux-gnu/faketime/libfaketimeMT.so.1'].find(existsSync);
+    if (process.platform !== 'linux' || !library)
+        throw new Error('Deterministic browser assessment needs Linux libfaketime installed for native cookie time');
+    const clockDir = mkdtempSync(join(tmpdir(), 'twin-browser-clock-'));
+    const clockFile = join(clockDir, 'clock');
+    const syncClock = () => {
+        const instant = new Date(worldNow());
+        // libfaketime's absolute format stops wall time, at HTTP-date (one-second) precision.
+        writeFileSync(clockFile, `${instant.toISOString().slice(0, 19).replace('T', ' ')}\n`);
+        return instant;
+    };
+    syncClock();
+    const env = Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== undefined && !entry[0].startsWith('FAKETIME')));
+    Object.assign(env, { LD_PRELOAD: library, TZ: 'UTC', FAKETIME_TIMESTAMP_FILE: clockFile, FAKETIME_NO_CACHE: '1', FAKETIME_DISABLE_SHM: '1', FAKETIME_DONT_FAKE_MONOTONIC: '1', NO_FAKE_STAT: '1' });
+    let browser;
+    try {
+        browser = await chromium.launch({ args: ['--no-sandbox'], env });
+    }
+    catch (error) {
+        rmSync(clockDir, { recursive: true, force: true });
+        throw error;
     }
     const served = async (root, options) => {
+        syncClock();
         const fetchPack = factory({ root, ...options });
         const context = await browser.newContext({ serviceWorkers: 'block', locale: 'en-US', timezoneId: 'UTC' });
         const page = await context.newPage();
@@ -35,6 +58,9 @@ export async function chromiumServed(packDir, host) {
             try {
                 const response = await fetchPack(new Request(request.url(), { method: request.method(), headers: await request.allHeaders(), ...(request.postDataBuffer() ? { body: new Uint8Array(request.postDataBuffer()).buffer } : {}) }));
                 const headers = Object.fromEntries(response.headers);
+                // Playwright otherwise adds CORS permission to cross-origin fulfillments. Absence means denial on the vendor wire.
+                if (!Object.hasOwn(headers, 'access-control-allow-origin'))
+                    headers['access-control-allow-origin'] = '';
                 const cookies = response.headers.getSetCookie();
                 if (cookies.length)
                     headers['set-cookie'] = cookies.join('\n');
@@ -45,9 +71,10 @@ export async function chromiumServed(packDir, host) {
             }
         });
         await page.goto(harness);
-        await page.clock.setFixedTime(new Date('2026-01-01T00:00:00.000Z'));
+        await page.clock.setFixedTime(syncClock());
         return {
             fetch: async (request) => {
+                await page.clock.setFixedTime(syncClock());
                 const body = request.body ? Buffer.from(await request.arrayBuffer()).toString('base64') : null;
                 const result = await page.evaluate(async ({ url, method, headers, body }) => {
                     const bytes = body === null ? undefined : Uint8Array.from(atob(body), (char) => char.charCodeAt(0));
@@ -62,8 +89,13 @@ export async function chromiumServed(packDir, host) {
                     throw new Error('Chromium returned an opaque response; this journey needs browser-specific navigation assertions');
                 return new Response([101, 204, 205, 304].includes(result.status) || request.method === 'HEAD' ? null : Buffer.from(result.body, 'base64'), { status: result.status, headers: result.headers });
             },
-            stop: () => { void context.close(); },
+            stop: () => context.close(),
         };
     };
-    return { served, version: browser.version(), stop: () => browser.close() };
+    return { served, version: browser.version(), clock: { native: 'World time through libfaketime', nativePrecisionMs: 1000, javascriptPrecisionMs: 1, monotonic: 'elapsed machine time' }, stop: async () => { try {
+            await browser.close();
+        }
+        finally {
+            rmSync(clockDir, { recursive: true, force: true });
+        } } };
 }

package/dist/src/browser-verification.d.ts

@@ -0,0 +1,19 @@
+export declare function verifyBrowserTransport(pack: string): Promise<{
+    purpose: string;
+    passed: boolean;
+    chromium: string;
+    replays: number;
+    exercisedOperations: number;
+    declaredOperations: number;
+    cookieJar: boolean;
+    cookieExpiry: string[];
+    clock: {
+        native: string;
+        nativePrecisionMs: number;
+        javascriptPrecisionMs: number;
+        monotonic: string;
+    };
+    binaryBytes: number;
+    corsEnforced: boolean;
+    domCoverage: null;
+}>;

package/dist/src/browser-verification.js

@@ -0,0 +1,86 @@
+// Regression of the standard's own browser transport. This fixture is not a pack or an admission verdict.
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { getActiveWorldStore, observeDerivedDispatch } from '@volter/world-core/runtime';
+import { inMemoryWorld } from "./walk/behavior-journey.js";
+import { chromiumServed } from "./browser-assessment.js";
+const require = createRequire(import.meta.url);
+export async function verifyBrowserTransport(pack) {
+    assert.ok(process.env.VOLTER_WORLD, 'browser transport verification must run through a World');
+    assert.ok(!existsSync(pack), 'browser fixture directory must be new and task-owned');
+    mkdirSync(join(pack, 'src'), { recursive: true });
+    writeFileSync(join(pack, 'src/index.ts'), `
+  import { createDerivedFetch } from ${JSON.stringify(pathToFileURL(require.resolve('@volter/world-core')).href)};
+  export function createFixtureFetch() {
+    return createDerivedFetch({ surface: { version: '1', operations: [
+      { id: 'login', method: 'post', path: '/login', class: 'action' },
+      { id: 'identity', method: 'get', path: '/identity', class: 'get' },
+      { id: 'binary', method: 'get', path: '/binary', class: 'get' },
+      { id: 'head', method: 'head', path: '/head', class: 'get' },
+      { id: 'gap', method: 'get', path: '/gap', class: 'get' },
+      { id: 'unused', method: 'get', path: '/unused', class: 'get' },
+    ] }, handlers: {
+      login: async () => new Response(null, { status: 204, headers: [['set-cookie', 'session=fixture; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=3600'], ['set-cookie', 'second=fixture; Path=/; Secure; SameSite=Strict; Expires=Thu, 01 Jan 2026 01:00:00 GMT']] }),
+      identity: async ({ request }) => {
+        const session = request.headers.get('cookie')?.includes('session=fixture') || false;
+        const second = request.headers.get('cookie')?.includes('second=fixture') || false;
+        return Response.json({ authenticated: session && second, session, second });
+      },
+      binary: async () => new Response(new Uint8Array(100000).fill(197), { headers: { 'content-type': 'application/octet-stream' } }),
+      head: async () => new Response(null, { status: 204 }),
+    }, gap: async () => Response.json({ error: 'unsupported' }, { status: 404 }) });
+  }
+  `);
+    const world = inMemoryWorld('browser-transport-verification');
+    const setClock = (instant) => getActiveWorldStore().write(process.env.TWIN_WORLD_CLOCK_FILE, instant);
+    const browser = await chromiumServed(pack, 'browser-fixture.test').catch((error) => { world.restore(); throw error; });
+    const seen = new Set();
+    const unsubscribe = observeDerivedDispatch(({ operation }) => seen.add(operation.id));
+    const replays = [];
+    try {
+        for (let run = 0; run < 2; run++) {
+            setClock('2026-01-01T00:00:00.000Z');
+            const served = await browser.served(world.root(), {});
+            try {
+                const fetch = (path, method = 'GET') => served.fetch(new Request(`https://browser-fixture.test${path}`, { method }));
+                assert.equal((await (await fetch('/identity')).json()).authenticated, false, 'fresh contexts must not inherit cookies');
+                assert.equal((await fetch('/login', 'POST')).status, 204);
+                const identity = await (await fetch('/identity')).json();
+                assert.equal(identity.authenticated, true, 'the browser cookie jar must reach the twin');
+                setClock('2026-01-01T00:59:59.000Z');
+                assert.deepEqual(await (await fetch('/identity')).json(), identity, 'both cookie types must remain before their World-time expiry');
+                setClock('2026-01-01T01:00:01.000Z');
+                const expired = await (await fetch('/identity')).json();
+                assert.deepEqual(expired, { authenticated: false, session: false, second: false }, 'native Expires and Max-Age must follow World time');
+                const binary = new Uint8Array(await (await fetch('/binary')).arrayBuffer());
+                assert.equal(binary.byteLength, 100000);
+                assert.ok(binary.every((byte) => byte === 197));
+                const head = await fetch('/head', 'HEAD');
+                assert.equal(head.status, 204);
+                assert.equal(await head.text(), '');
+                assert.equal((await fetch('/gap')).status, 404);
+                assert.equal((await fetch('/unknown')).status, 404);
+                await assert.rejects(() => served.fetch(new Request('https://another-origin.test/identity')), /Failed to fetch/);
+                replays.push({ identity, expired, binaryBytes: binary.byteLength, headStatus: head.status, gapStatus: 404 });
+            }
+            finally {
+                await served.stop();
+            }
+        }
+        assert.deepEqual(replays[0], replays[1]);
+        assert.deepEqual([...seen].sort(), ['binary', 'gap', 'head', 'identity', 'login']);
+        return { purpose: 'browser-transport-fixture', passed: true, chromium: browser.version, replays: 2, exercisedOperations: seen.size, declaredOperations: 6, cookieJar: true, cookieExpiry: ['Expires', 'Max-Age'], clock: browser.clock, binaryBytes: 100000, corsEnforced: true, domCoverage: null };
+    }
+    finally {
+        unsubscribe();
+        try {
+            await browser.stop();
+        }
+        finally {
+            world.restore();
+        }
+    }
+}

package/dist/src/index.d.ts

@@ -10,3 +10,4 @@ export type { Criterion, CriterionResult, GradeUnit, ScoreReport, Standard } fro
 export { compilePackFacts, renderPackFacts, type PackFacts, type PackFactsFile } from './pack-facts.js';
 export { assessPack, type AssessmentOptions } from './assessment.js';
 export { createPack } from './create-pack.js';
+export { verifyBrowserTransport } from './browser-verification.js';

package/dist/src/index.js

@@ -14,3 +14,4 @@ export { unitAt } from "./unit.js";
 export { compilePackFacts, renderPackFacts } from "./pack-facts.js";
 export { assessPack } from "./assessment.js";
 export { createPack } from "./create-pack.js";
+export { verifyBrowserTransport } from "./browser-verification.js";

package/dist/src/walk/behavior-journey.d.ts

@@ -34,7 +34,7 @@ export type ServedTwin = (root: string, options: {
     application?: import('@volter/world-core').PackFetchOptions['application'];
 }) => Promise<{
     fetch: (request: Request) => Promise<Response>;
-    stop: () => void;
+    stop: () => void | Promise<void>;
     socket?: (url: string, headers: Record<string, string>) => WebSocket;
     stream?: TwinStream;
 }>;

package/dist/src/walk/behavior-journey.js

@@ -1094,7 +1094,7 @@ export async function walk(journey, root, collect, opts) {
         await Promise.allSettled([...pending.values()].map((request) => request.answer));
         setDeliveryObserver(previousObserver);
         setInProcessTwins(previousTwins);
-        served?.stop();
+        await served?.stop();
         if (sqlSession)
             await sqlSession.then((session) => session.end(), () => { });
         // a World's managed database ends with its walk (vendor-fetch.ts), so the next World declares it at the same port

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/twin-standard",
-  "version": "1.0.36",
+  "version": "1.0.38",
   "description": "The Protocol 3 standard for Volter twin packs: the criteria a pack is graded by, the grader, the gate a pack repository and the twin catalog run on every change and submission, and the spec derivation the grade checks against. Pin a version: every place a pack is judged judges by that standard.",
   "keywords": [
     "twin",
@@ -75,7 +75,7 @@
     "yaml": "2.9.0"
   },
   "peerDependencies": {
-    "@volter/world-core": "3.0.44",
+    "@volter/world-core": "3.0.46",
     "@volter/world-runtime": "*",
     "playwright": "^1.63.0"
   },

package/src/assessment.ts

@@ -84,7 +84,7 @@ export async function assessPack(packDir: string, options: AssessmentOptions = {
     const transport = await chromiumServed(packDir, life.host ?? 'twin.local');
     try {
       const a = await replay(transport.served), b = await replay(transport.served);
-      browser = { measured: true, target: 'Chromium fetch, cookie jar and HTTP response behavior; no DOM interaction coverage', version: transport.version, answered: a.trace.length, failures: [...a.failures, ...b.failures], replay: { equal: a.trace.length > 0 && json(a.trace) === json(b.trace), firstSha256: hash(a.trace), secondSha256: hash(b.trace), runs: 2 }, operationCoverage: coverageOf(a), domCoverage: null, clock: 'World and page JavaScript clocks frozen; native cookie expiration uses Chromium wall time' };
+      browser = { measured: true, target: 'Chromium fetch, cookie jar and HTTP response behavior; no DOM interaction coverage', version: transport.version, answered: a.trace.length, failures: [...a.failures, ...b.failures], replay: { equal: a.trace.length > 0 && json(a.trace) === json(b.trace), firstSha256: hash(a.trace), secondSha256: hash(b.trace), runs: 2 }, operationCoverage: coverageOf(a), domCoverage: null, clock: transport.clock };
     } finally { await transport.stop(); }
   }
   const conform = options.conformance === false ? null : await conformance(packDir);

package/src/browser-assessment.ts

@@ -1,13 +1,32 @@
 // Browser transport for the existing journey engine. A container supplies network isolation in catalog execution.
 import { join } from 'node:path';
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { worldNow } from '@volter/world-core/runtime';
 import type { ServedTwin } from './walk/behavior-journey.ts';
 export async function chromiumServed(packDir: string, host: string) {
   const { chromium } = await import('playwright');
-  const browser = await chromium.launch({ args: ['--no-sandbox'] });
   const mod = await import(join(packDir, 'src/index.ts')) as Record<string, unknown>;
   const factory = Object.entries(mod).find(([name, value]) => /^create\w+Fetch$/.test(name) && !/TwinFetch$/.test(name) && typeof value === 'function')?.[1] as ((options: import('@volter/world-core').PackFetchOptions) => (request: Request) => Promise<Response>) | undefined;
-  if (!factory) { await browser.close(); throw new Error('Browser assessment needs the pack HTTP fetch factory'); }
+  if (!factory) throw new Error('Browser assessment needs the pack HTTP fetch factory');
+  const library = ['/usr/lib/x86_64-linux-gnu/faketime/libfaketimeMT.so.1', '/usr/lib/aarch64-linux-gnu/faketime/libfaketimeMT.so.1'].find(existsSync);
+  if (process.platform !== 'linux' || !library) throw new Error('Deterministic browser assessment needs Linux libfaketime installed for native cookie time');
+  const clockDir = mkdtempSync(join(tmpdir(), 'twin-browser-clock-'));
+  const clockFile = join(clockDir, 'clock');
+  const syncClock = () => {
+    const instant = new Date(worldNow());
+    // libfaketime's absolute format stops wall time, at HTTP-date (one-second) precision.
+    writeFileSync(clockFile, `${instant.toISOString().slice(0, 19).replace('T', ' ')}\n`);
+    return instant;
+  };
+  syncClock();
+  const env: Record<string, string> = Object.fromEntries(Object.entries(process.env).filter((entry): entry is [string, string] => entry[1] !== undefined && !entry[0].startsWith('FAKETIME')));
+  Object.assign(env, { LD_PRELOAD: library, TZ: 'UTC', FAKETIME_TIMESTAMP_FILE: clockFile, FAKETIME_NO_CACHE: '1', FAKETIME_DISABLE_SHM: '1', FAKETIME_DONT_FAKE_MONOTONIC: '1', NO_FAKE_STAT: '1' });
+  let browser;
+  try { browser = await chromium.launch({ args: ['--no-sandbox'], env }); }
+  catch (error) { rmSync(clockDir, { recursive: true, force: true }); throw error; }
   const served: ServedTwin = async (root, options) => {
+    syncClock();
     const fetchPack = factory({ root, ...options });
     const context = await browser.newContext({ serviceWorkers: 'block', locale: 'en-US', timezoneId: 'UTC' });
     const page = await context.newPage();
@@ -19,15 +38,18 @@ export async function chromiumServed(packDir: string, host: string) {
       try {
         const response = await fetchPack(new Request(request.url(), { method: request.method(), headers: await request.allHeaders(), ...(request.postDataBuffer() ? { body: new Uint8Array(request.postDataBuffer()!).buffer } : {}) }));
         const headers = Object.fromEntries(response.headers);
+        // Playwright otherwise adds CORS permission to cross-origin fulfillments. Absence means denial on the vendor wire.
+        if (!Object.hasOwn(headers, 'access-control-allow-origin')) headers['access-control-allow-origin'] = '';
         const cookies = response.headers.getSetCookie();
         if (cookies.length) headers['set-cookie'] = cookies.join('\n');
         await route.fulfill({ status: response.status, headers, body: Buffer.from(await response.arrayBuffer()) });
       } catch { await route.abort('failed'); }
     });
     await page.goto(harness);
-    await page.clock.setFixedTime(new Date('2026-01-01T00:00:00.000Z'));
+    await page.clock.setFixedTime(syncClock());
     return {
       fetch: async (request: Request) => {
+        await page.clock.setFixedTime(syncClock());
         const body = request.body ? Buffer.from(await request.arrayBuffer()).toString('base64') : null;
         const result = await page.evaluate(async ({ url, method, headers, body }) => {
           const bytes = body === null ? undefined : Uint8Array.from(atob(body), (char) => char.charCodeAt(0));
@@ -40,8 +62,8 @@ export async function chromiumServed(packDir: string, host: string) {
         if (!result.status) throw new Error('Chromium returned an opaque response; this journey needs browser-specific navigation assertions');
         return new Response([101, 204, 205, 304].includes(result.status) || request.method === 'HEAD' ? null : Buffer.from(result.body, 'base64'), { status: result.status, headers: result.headers });
       },
-      stop: () => { void context.close(); },
+      stop: () => context.close(),
     };
   };
-  return { served, version: browser.version(), stop: () => browser.close() };
+  return { served, version: browser.version(), clock: { native: 'World time through libfaketime', nativePrecisionMs: 1000, javascriptPrecisionMs: 1, monotonic: 'elapsed machine time' }, stop: async () => { try { await browser.close(); } finally { rmSync(clockDir, { recursive: true, force: true }); } } };
 }

package/src/browser-verification.ts

@@ -0,0 +1,74 @@
+// Regression of the standard's own browser transport. This fixture is not a pack or an admission verdict.
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { getActiveWorldStore, observeDerivedDispatch } from '@volter/world-core/runtime';
+import { inMemoryWorld } from './walk/behavior-journey.ts';
+import { chromiumServed } from './browser-assessment.ts';
+const require = createRequire(import.meta.url);
+export async function verifyBrowserTransport(pack: string) {
+  assert.ok(process.env.VOLTER_WORLD, 'browser transport verification must run through a World');
+  assert.ok(!existsSync(pack), 'browser fixture directory must be new and task-owned');
+
+  mkdirSync(join(pack, 'src'), { recursive: true });
+  writeFileSync(join(pack, 'src/index.ts'), `
+  import { createDerivedFetch } from ${JSON.stringify(pathToFileURL(require.resolve('@volter/world-core')).href)};
+  export function createFixtureFetch() {
+    return createDerivedFetch({ surface: { version: '1', operations: [
+      { id: 'login', method: 'post', path: '/login', class: 'action' },
+      { id: 'identity', method: 'get', path: '/identity', class: 'get' },
+      { id: 'binary', method: 'get', path: '/binary', class: 'get' },
+      { id: 'head', method: 'head', path: '/head', class: 'get' },
+      { id: 'gap', method: 'get', path: '/gap', class: 'get' },
+      { id: 'unused', method: 'get', path: '/unused', class: 'get' },
+    ] }, handlers: {
+      login: async () => new Response(null, { status: 204, headers: [['set-cookie', 'session=fixture; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=3600'], ['set-cookie', 'second=fixture; Path=/; Secure; SameSite=Strict; Expires=Thu, 01 Jan 2026 01:00:00 GMT']] }),
+      identity: async ({ request }) => {
+        const session = request.headers.get('cookie')?.includes('session=fixture') || false;
+        const second = request.headers.get('cookie')?.includes('second=fixture') || false;
+        return Response.json({ authenticated: session && second, session, second });
+      },
+      binary: async () => new Response(new Uint8Array(100000).fill(197), { headers: { 'content-type': 'application/octet-stream' } }),
+      head: async () => new Response(null, { status: 204 }),
+    }, gap: async () => Response.json({ error: 'unsupported' }, { status: 404 }) });
+  }
+  `);
+  const world = inMemoryWorld('browser-transport-verification');
+  const setClock = (instant: string) => getActiveWorldStore().write(process.env.TWIN_WORLD_CLOCK_FILE!, instant);
+  const browser = await chromiumServed(pack, 'browser-fixture.test').catch((error) => { world.restore(); throw error; });
+  const seen = new Set<string>();
+  const unsubscribe = observeDerivedDispatch(({ operation }) => seen.add(operation.id));
+  const replays = [];
+  try {
+    for (let run = 0; run < 2; run++) {
+      setClock('2026-01-01T00:00:00.000Z');
+      const served = await browser.served(world.root(), {});
+      try {
+        const fetch = (path: string, method = 'GET') => served.fetch(new Request(`https://browser-fixture.test${path}`, { method }));
+        assert.equal((await (await fetch('/identity')).json()).authenticated, false, 'fresh contexts must not inherit cookies');
+        assert.equal((await fetch('/login', 'POST')).status, 204);
+        const identity = await (await fetch('/identity')).json();
+        assert.equal(identity.authenticated, true, 'the browser cookie jar must reach the twin');
+        setClock('2026-01-01T00:59:59.000Z');
+        assert.deepEqual(await (await fetch('/identity')).json(), identity, 'both cookie types must remain before their World-time expiry');
+        setClock('2026-01-01T01:00:01.000Z');
+        const expired = await (await fetch('/identity')).json();
+        assert.deepEqual(expired, { authenticated: false, session: false, second: false }, 'native Expires and Max-Age must follow World time');
+        const binary = new Uint8Array(await (await fetch('/binary')).arrayBuffer());
+        assert.equal(binary.byteLength, 100000);
+        assert.ok(binary.every((byte) => byte === 197));
+        const head = await fetch('/head', 'HEAD');
+        assert.equal(head.status, 204); assert.equal(await head.text(), '');
+        assert.equal((await fetch('/gap')).status, 404);
+        assert.equal((await fetch('/unknown')).status, 404);
+        await assert.rejects(() => served.fetch(new Request('https://another-origin.test/identity')), /Failed to fetch/);
+        replays.push({ identity, expired, binaryBytes: binary.byteLength, headStatus: head.status, gapStatus: 404 });
+      } finally { await served.stop(); }
+    }
+    assert.deepEqual(replays[0], replays[1]);
+    assert.deepEqual([...seen].sort(), ['binary', 'gap', 'head', 'identity', 'login']);
+    return { purpose: 'browser-transport-fixture', passed: true, chromium: browser.version, replays: 2, exercisedOperations: seen.size, declaredOperations: 6, cookieJar: true, cookieExpiry: ['Expires', 'Max-Age'], clock: browser.clock, binaryBytes: 100000, corsEnforced: true, domCoverage: null };
+  } finally { unsubscribe(); try { await browser.stop(); } finally { world.restore(); } }
+}

package/src/index.ts

@@ -17,3 +17,4 @@ export { compilePackFacts, renderPackFacts, type PackFacts, type PackFactsFile }
 export { assessPack, type AssessmentOptions } from './assessment.ts';
 
 export { createPack } from './create-pack.ts';
+export { verifyBrowserTransport } from './browser-verification.ts';

package/src/walk/behavior-journey.ts

@@ -168,7 +168,7 @@ function takeReplies(c: Connection): LineReply[] {
 /** A pack served for a walk the way a World runs it (its server.ts on a port, the World's root and scenario its options):
  *  the walk's requests go to it over HTTP, the vendor's host in their Host header, instead of to the fetch in process;
  *  its sockets are WebSockets to that port, and a line connection (`stream`) is a TCP connection to its protocol port. */
-export type ServedTwin = (root: string, options: { scenarioPath?: string; application?: import('@volter/world-core').PackFetchOptions['application'] }) => Promise<{ fetch: (request: Request) => Promise<Response>; stop: () => void; socket?: (url: string, headers: Record<string, string>) => WebSocket; stream?: TwinStream }>;
+export type ServedTwin = (root: string, options: { scenarioPath?: string; application?: import('@volter/world-core').PackFetchOptions['application'] }) => Promise<{ fetch: (request: Request) => Promise<Response>; stop: () => void | Promise<void>; socket?: (url: string, headers: Record<string, string>) => WebSocket; stream?: TwinStream }>;
 
 export async function walk(journey: Journey, root: string, collect: Failure[], opts: { beats: boolean; verbose?: boolean; hooks?: StepHooks; captured?: Captured; served?: ServedTwin }): Promise<Captured> {
   attributionName(journey.author);
@@ -769,7 +769,7 @@ export async function walk(journey: Journey, root: string, collect: Failure[], o
     await Promise.allSettled([...pending.values()].map((request) => request.answer));
     setDeliveryObserver(previousObserver);
     setInProcessTwins(previousTwins);
-    served?.stop();
+    await served?.stop();
     if (sqlSession) await sqlSession.then((session) => session.end(), () => {});
     // a World's managed database ends with its walk (vendor-fetch.ts), so the next World declares it at the same port
     await (twin as { stopDatabase?: () => Promise<void> }).stopDatabase?.();