@ai-ecoverse/slicc-browsers 1.13.3 → 1.13.5

package/README.md

@@ -190,9 +190,9 @@ The `C9` foreign extension isolated-world family requires `extensionWorld`: a br
 
 The integration launcher loads shared-web 1.25.2’s harness extension exactly once through `Extensions.loadUnpacked` (`ankmbodmgimjemnojmeddfcdlbocolob`), whose content script runs on HTTP(S) pages. shared-web 1.25.2 also loads it by default in its own harness. A transport unable to host a foreign content-script extension omits `extensionWorld` and reports `not-supported:extensionWorld`; an advertised capability with no observed world fails, rather than silently skipping.
 
-`C2.redirect-secret` probes ordinary fixture 302s to seven’s `/auth/callback?code=…&state=…` and vault’s `/oauth/mcp-callback?code=…`, plus `#access_token=…` variants of both. It navigates with Page and scripted `location.href`, fetches a subresource and sends an XHR. The 302 carries `Location`, `Content-Location`, `Refresh: 0;url=…` and `Link: <…>; rel=preconnect`. Page, Network (including ExtraInfo), Runtime, Log, Audits and both Fetch stages are enabled. Every received raw message is scanned, including replies, across an eight-second tail, for raw, percent-encoded, JSON-escaped and base64 marker representations. Both response-body APIs are attempted on each hop; guarded bodies need matched refusals. Page frame trees, resource trees and navigation history are read before recovery to catch error-page leftovers. A separate structural check requires every protected `Network.Request.urlFragment` and `Page.Frame.urlFragment` to be empty or absent, even if its value contains no marker; the ordinary `#access_token` control independently requires fragment evidence in request events, frame events, frame-tree replies and resource-tree replies. The ordinary session must survive. The unguarded ordinary redirect control preserves all four headers in `redirectResponse`, ExtraInfo’s headers and `headersText`, and Fetch’s response headers. `C2.redirect-secret-mix` repeats that matrix with 301/303/307/308. The protected leg requires in-place ExtraInfo delivery with origin-only header values, not merely the absence of a marker.
+`C2.redirect-secret` probes ordinary fixture 302s to seven’s `/auth/callback?code=…&state=…` and vault’s `/oauth/mcp-callback?code=…`, plus `#access_token=…` variants of both. It navigates with Page and scripted `location.href`, fetches a subresource and sends an XHR. The 302 carries `Location`, `Content-Location`, `Refresh: 0;url=…` and `Link: <…>; rel=preconnect`. Page, Network (including ExtraInfo), Runtime, Log, Audits and both Fetch stages are enabled. Every received raw message is scanned, including replies but not the probe’s own observer session traffic, across an eight-second tail, for raw, percent-encoded, JSON-escaped and base64 marker representations. Both response-body APIs are attempted on each hop; guarded bodies need matched refusals. `Network.getResponseBody` is attempted, once per id, with every network id the client learns for a 301–308 hop: the `requestId` of a Network event carrying the redirect status and the `networkId` of the Fetch response-stage pause. For each registered hop whose id the client learned neither way, the probe reads the hop’s real id from the harness’s own unguarded tap (the observer session, which enables Network on the guarded leg) and attempts the read on the guarded session with it. The evidence’s `networkBodyCarriers` counts the ids per carrier, and `networkBodyPath` names the weakest carrier any id needed: `withheld+tap`, then `fetch-networkId`, then `network`, or `none` without any id. These reads never hold up a Fetch pause, and the probe gives them five seconds after `Fetch.disable` to settle. A read still unanswered then is not a refusal. `networkBodyAttempted` and `networkBodyRefused` hold only when every attempt is refused. On the guarded leg a `fetch-networkId` or `withheld+tap` carrier also needs the same row’s unguarded control to have seen the redirect’s Network events. Without that proof, or with no id at all, both read `incomplete` and the probe returns `redirect-secret: network body leg <reason>`; an attempt that is not refused is measured and fails. Every request the client sees for a registered redirect URL, through its initial `Network.requestWillBeSent` or a redirect `requestWillBeSent` whose `redirectResponse.url` is that URL, must end within the step in a redirect `requestWillBeSent`, `loadingFinished` or `loadingFailed` for that `requestId`. The evidence’s `hops` records per `requestId` the `delivery` (`redacted` for an origin-only protected redirect in place, `withheld` for a terminal without the redirect, `ordinary`, `raw` or `unterminated`) and the `terminal` event method. `requestsTerminated` is false on any `unterminated` request, a measured guard failure rather than missing evidence; `hopsRedacted` is false on any `raw` or `ordinary` hop, so a delivered protected hop must be origin-only, never the raw or a substituted URL; the guarded leg expects it. Page frame trees, resource trees and navigation history are read before recovery to catch error-page leftovers. A separate structural check requires every protected `Network.Request.urlFragment` and `Page.Frame.urlFragment` to be empty or absent, even if its value contains no marker; the ordinary `#access_token` control independently requires fragment evidence in request events, frame events, frame-tree replies and resource-tree replies. The ordinary session must survive. The unguarded ordinary redirect control preserves all four headers in `redirectResponse`, ExtraInfo’s headers and `headersText`, and Fetch’s response headers. `C2.redirect-secret-mix` repeats that matrix with 301/303/307/308. The protected leg requires in-place ExtraInfo delivery with origin-only header values, not merely the absence of a marker.
 
-`C2.redirect-body` calls `Network.loadNetworkResource` on an ordinary redirect with `includeCredentials: true`, reads any stream with `IO.read`, replays a redirected XHR, requests Page resource content, and captures Page/MHTML and DOM snapshots after a main-frame redirect. It also captures an ordinary parent containing an iframe redirected to vault, including its error document, and overrides a paused ordinary Fetch request to the allowed redirect URL. No protected marker may appear in any message or body, and no request from those operations may send the independently seeded seven cookie. The ordinary control must return the body, resource content and snapshots, and accept the URL override. Each probe cleans up its redirect registrations, observer session and cookie. The focused Chrome tests use HTTPS with SPKI-pinned fixture trust and default-port protected URLs; host resolver rules route seven and vault to the fixture rather than the public service.
+`C2.redirect-body` calls `Network.loadNetworkResource` on an ordinary redirect with `includeCredentials: true`, reads any stream with `IO.read`, replays a redirected XHR, requests Page resource content, and captures Page/MHTML and DOM snapshots after a main-frame redirect. It also captures an ordinary parent containing an iframe redirected to vault, including its error document, and overrides a paused ordinary Fetch request to the allowed redirect URL. No protected marker may appear in any message or body, and no request from those operations may send the independently seeded seven cookie. The ordinary control must return the body, resource content and snapshots, and accept the URL override. Its network-body carrier, `networkBodyAttempted`, `networkBodyRefused`, `hops`, `requestsTerminated` and `hopsRedacted` follow `C2.redirect-secret`. Each probe cleans up its redirect registrations, observer session and cookie. The focused Chrome tests use HTTPS with SPKI-pinned fixture trust and default-port protected URLs; host resolver rules route seven and vault to the fixture rather than the public service.
 
 `C8.unparseable` probes both raw and canonical space/U+200D/invalid-punycode URLs through creation and navigation. Every guarded destination needs a matched refusal. Its unguarded controls record `document` or `native-rejection` outcomes, including Chrome builds that reject raw U+200D instead of committing it. Both raw and encoded-space forms must commit real fixture documents, because that is the proven cookie leak. An independent observer loads the encoded-space document and confirms it shares a uniquely seeded `.sliccy.ai` cookie; the guarded client must neither list nor attach to it, read its cookie, query that cookie by URL, nor cause a cookie-bearing destination request. The guard does not erase the observer’s private browser state. The row runs on both browser-session and page-session-only transports, uses the default context, and cleans up its own targets and cookie. Cookie seeding always uses the unguarded observer’s browser session, never the guarded client. Only guarded browser-session target listing requires `browserSession`; without it, `listed` records `not-supported` explicitly in probe and observation evidence, and the result lists that field in `notSupported`. Creation, navigation, attachment and `Network.getCookies` with `urls` still require matched refusals; filtering cookies without refusing fails `cookieRefused`. Fixture URLs omit the colon when the port is empty, and reported URLs are compared after canonicalisation, including Chrome’s WHATWG-unparseable encoded-space hosts. Launchers must resolve the raw/canonical space, U+200D/punycode and invalid-punycode `.sliccy.ai` fixture hosts to the fixture server, including for default-port HTTP or HTTPS origins. The HTTP fixture accepts Chrome’s encoded-space Host header without reparsing it as a WHATWG origin.
 
@@ -261,7 +261,7 @@ Popups are observed by `Target.targetCreated` with the opener's `openerId`, or b
 
 `{ "extensionWorld": "hidden" | "select" | "debugger" | "drivable", "as": "world", "requires": ["extensionWorld"] }` runs the C9 compound probe on the current ordinary page. The runner attaches an independent observer to discover actual context ids, unique ids and names, and sends probes through the client session. Discovery matches the expected fixture extension’s exact origin, never the first extension world: `run()`’s optional `extensionWorldId` defaults to shared-web’s harness id `ankmbodmgimjemnojmeddfcdlbocolob`. Multiple unrelated content-script worlds are ignored for fixture selection, while guards must still protect foreign worlds. A custom fixture must provide the same content-script marker contract. Object handles are minted and validated on the unguarded control session, then replayed as guesses on the guarded leg; Chrome object handles and DOM node ids are session-local, so observer handles must never be mistaken for client handles. Numeric ids from the control are also replayed alongside fresh observer-discovered selectors, but numeric ids are local to a tab: a control id may name the next tab’s exposed default context, which must work and return no extension marker. The same-tab hidden world’s actual numeric id and every extension unique-id guess still require a matched refusal. Unknown numeric ids and stale object handles (`not exposed`) need explicit refusals rather than Chrome’s invalid-id errors. `guessesRefused` aggregates only required refusals; `guessesReached` must be false on the guarded leg, and `exposedContextsWork` must remain true. Its result contains boolean evidence consumed by ordinary `result` checks. The unguarded leg validates those selectors against Chrome itself before guarded evidence can pass.
 
-`{ "errorPage": "recover", "secret"?: "all" | "query" | "fragment", "as": "errorPage" }` (also modes `restore` and `sticky`; `secret` defaults to `all`) runs the protected-error-page compound probe with independent commit evidence, discovery redaction and recovery or sticky-lock checks. The unguarded observer seeds the protected history and failed commit, so the rows run on page-session-only transports too. The guarded client uses only `Target.getTargetInfo` with a `targetId`, `Target.getTargets`, `Target.setDiscoverTargets`, `Target.attachToTarget`, `Target.detachFromTarget` and `Target.closeTarget` without a session, which page-session transports answer themselves, and everything else on its page session; the rows require no whole-vector capability. Only `eventsRedacted` requires `discovery`: without it the probe does not call `Target.setDiscoverTargets`, that one field is `not-supported` in both legs, and the notes say `not-supported:discovery`; info, list, attach, recovery and lock checks still run. Discovery absence is structural: a guarded transport delivering either `Target.targetCreated` or `Target.targetInfoChanged` during such a row without declaring `discovery` fails the row, even when the event names an ordinary target. `Target.attachedToTarget` remains independently checked by `attachRedacted`. The runner leaves this probe’s independent Fetch sessions to the probe rather than answering their pauses itself. Each of the probe’s waits is bounded at 5000 ms, scaled by `settleScale`. When the probe’s own evidence is missing, it returns `incomplete` with `protected-error-page: <reason>` instead of throwing: the observer’s history seed or allowed document did not commit (or its setup failed), the control’s own Fetch failure injection left no error commit, the protected history entry is missing, no real `BackForwardCacheRestore` arrived, or the observer’s sticky failure left no error page. The guarded leg’s missing error commit is not incomplete: it is the guard’s, and stays `live: false`.
+`{ "errorPage": "recover", "secret"?: "all" | "query" | "fragment", "as": "errorPage" }` (also modes `restore` and `sticky`; `secret` defaults to `all`) runs the protected-error-page compound probe with independent commit evidence, discovery redaction and recovery or sticky-lock checks. The unguarded observer seeds the protected history and failed commit, so the rows run on page-session-only transports too. The guarded client uses only `Target.getTargetInfo` with a `targetId`, `Target.getTargets`, `Target.setDiscoverTargets`, `Target.attachToTarget`, `Target.detachFromTarget` and `Target.closeTarget` without a session, which page-session transports answer themselves, and everything else on its page session; the rows require no whole-vector capability. Only `eventsRedacted` requires `discovery`: without it the probe does not call `Target.setDiscoverTargets`, that one field is `not-supported` in both legs, and the notes say `not-supported:discovery`; info, list, attach, recovery and lock checks still run. Discovery absence is structural: a guarded transport delivering either `Target.targetCreated` or `Target.targetInfoChanged` during such a row without declaring `discovery` fails the row, even when the event names an ordinary target. `Target.attachedToTarget` remains independently checked by `attachRedacted`. The runner leaves this probe’s independent Fetch sessions to the probe rather than answering their pauses itself. Each of the probe’s waits is bounded at 5000 ms, scaled by `settleScale`. When the probe’s own evidence is missing, it returns `incomplete` with `protected-error-page: <reason>` instead of throwing: the observer target could not be created or attached (an `openerId` included, after cleaning the target up), the observer’s history seed or allowed document did not commit (or its setup failed), the control’s own Fetch failure injection left no error commit, the protected history entry is missing, no real `BackForwardCacheRestore` arrived, or the observer’s sticky failure left no error page. The guarded leg’s missing error commit is not incomplete: it is the guard’s, and stays `live: false`.
 
 `{ "redirectSecret": "headers" | "mix" | "body", "as": "redirect" }` runs a C2 compound probe and owns its Fetch pauses. The client must expose `messages`, an append-only array of every raw received CDP text frame, recorded before parsing; an events-only or reply-only tap fails `rawRecorded`. Whenever a run includes a `C2.redirect-*` row or a `redirectSecret` step, `run()` retains an explicit `fixture.redirectSecret` hook or automatically installs a fetch-only `POST /redirect` bridge. Its base is `fixtureBase`, then `fixture.origin`, then `targets.ordinary`; a browser-page alias or reverse proxy must forward that endpoint to the bundled fixture. The bundled `fixtureServer()` always supplies both its direct hook and HTTP control endpoint, so no custom registration method is needed. Missing, unreachable or non-successful registration is an explicit row/summary error containing `redirectSecret fixture registration required`, never a pass or a skipped observation. Fixture logs must include headers for the cookie check. The guard’s events and raw messages must represent the same delivered stream. The leak scan memoizes each decoded string and yields to the event loop between items, so concurrent rows in the same process are not starved. When the probe’s own unguarded observer setup (attach, `Page.enable` and the seven cookie) fails before the client is used, the probe returns `incomplete` with `redirect-secret: observer setup failed: <reason>` instead of throwing.
 
@@ -306,9 +306,10 @@ It exports:
 - `waitFor(check, ms, step?)`: polls `check` every `step` ms (default 25) until it holds, checking once more after the bound. A timer heartbeat every `step` runs for the whole wait, including while `check` is awaiting a reply, and any gap between beats longer than a second (or four steps, if longer) extends the bound by that gap, so a synchronous event-loop stall elsewhere in the process does not consume it. The extensions add up to at most `max(4 × ms, 30000)` ms, so a throttled page cannot stretch a wait without limit. `load`, the runner's waits and the error-page and redirect-body probes use it;
 - `judge(vector, side, observed)`: `{ pass, refused, skipped, mismatches }`, where `refused` lists the leg's refusals and `skipped` the observations that depend on them or explicitly record unavailable observation capabilities;
 - `result(vector, run)`: a report row from `{ target, variant, transport, via?, capabilities?, control, guarded, live }`. `capabilities` is the transport's; without it, the transport has them all;
+- `knownOrigins` and `originDefaults`: the origin names a runner can miss, and the origins `plain`, `cross`, `log` and `own` fall back to when unset;
 - `parseURL(value, base?)`: a `URL`, or `null` for anything `new URL` rejects or a non-string; every parse of a fixture log entry or a Chrome-reported URL in the runner and the fixture goes through it (`protected.mjs` keeps its own copy, since it imports nothing), so an unparseable entry never throws;
 - `owned(entries, tag)`: the fixture log entries whose raw URL contains `tag`, the row's attribution through its `n=`, `tag=` or `to=` query;
-- `summary({ guard, sha, set, results })`: `set` is the parsed `guard-vectors.json`. It returns `{ set, schemaVersion, guard, sha, variants, targets, transports, results, skipped, notRun, missing, pass, line }`. `missing` lists each `{ id, target, variant, transport }` without a row, for every vector whose `scope` is `any` or the guard, every target it lists, every variant in `variants` or `results`, and every transport in `results`; `pass` needs it empty, where `line` is `GUARD-PASS <guard>@<sha> (vectors @ai-ecoverse/slicc-browsers@X.Y.Z)` or `GUARD-FAIL …`.
+- `summary({ guard, sha, set, results })`: `set` is the parsed `guard-vectors.json`. It returns `{ set, schemaVersion, guard, sha, variants, targets, transports, results, skipped, notRun, missing, forged, pass, line }`. `missing` lists each `{ id, target, variant, transport }` without a row, for every vector whose `scope` is `any` or the guard, every target it lists, every variant in `variants` or `results`, and every transport in `results`; `pass` needs it empty, where `line` is `GUARD-PASS <guard>@<sha> (vectors @ai-ecoverse/slicc-browsers@X.Y.Z)` or `GUARD-FAIL …`. `forged` lists each `{ id, target, variant, transport, why }` that is `not-run` on a vector that isn't `kind: "text"`, or `skip` without a reason the runner gives (`not-applicable`, `not-applicable:no-<origin>-origin` for an origin in `knownOrigins` that the row's target, `plain`, the control's origin, the steps or a check names, directly or through `originDefaults`, where only the first branch of an `any` counts, the vector's own `skip.reason` on its target, or `not-supported:<capability>` for a capability the set requires, `browserSession` or `unguarded-observer`); `pass` needs it empty too, and `line` then ends in `forged <n>`.
 
 **`npm run validate`** checks that:
 - the file matches the schema, and ids are unique;
@@ -349,7 +350,7 @@ The factory can configure the guard's own transport delay from this metadata;
 the runner never reaches into the guard. `transportVariant: true` acknowledges
 that configuration, and every result records that boolean (false by default).
 `slot` allows pooling browsers while keeping each row's clients independent.
-A factory that rejects makes only that row `incomplete` for control, guarded and live, with `clientFactory: <reason>` in its `incomplete`; the run goes on with the next row instead of rejecting. Such a row is labelled with the transport of the last client the factory made (`cdp` if none), and is passed to `log` once the run completes, so `summary()` never counts a placeholder transport. The optional `close` releases the row's clients; release pooled browsers after
+A factory that rejects or throws makes only that row `incomplete` for control, guarded and live, with `clientFactory: <reason>` in its `incomplete`; the run goes on with the next row instead of rejecting. Such a row is labelled with the transport of the last client the factory made (`cdp` if none), and is passed to `log` once the run completes, so `summary()` never counts a placeholder transport. The optional `close` releases the row's clients; release pooled browsers after
 `run` completes. Each parallel slot needs an independent browser for
 browser-wide settings. Without a factory execution is serial. Cookie and storage
 rows use fresh browser contexts when `capabilities.browserContexts` is true;
@@ -381,7 +382,7 @@ every alternative of an `any`, or a required (`all`, `not` or plain) check, need
 selects one variant or an array; omission selects all. `parallel` defaults to 1.
 With the `browserContexts` capability each leg runs in its own browser context. A `Target.createBrowserContext` that fails with a timeout is retried once, and the row's `notes` records it; any other failure fails the row.
 
-Every target created by the runner’s own unguarded observer uses `Target.createTarget` with `newWindow: true`, then verifies through `Target.getTargetInfo` that `openerId` is absent. A supplied opener or missing target evidence fails and cleans up that target, rather than inheriting the active client tab (which could be seven). This includes ordinary control setup, storage canaries, protected-error history seeds and the malformed-URL observer. The row notes record `newWindow=true, openerId absent`. Intentional guarded-client creation commands and popup/opener tests keep their original parameters.
+Every target created by the runner’s own unguarded observer uses `Target.createTarget` with `newWindow: true`, then verifies through `Target.getTargetInfo` that `openerId` is absent. A supplied opener or missing target evidence fails and cleans up that target (in the protected-error-page probe, the row is `incomplete` instead), rather than inheriting the active client tab (which could be seven). This includes ordinary control setup, storage canaries, protected-error history seeds and the malformed-URL observer. The row notes record `newWindow=true, openerId absent`. Intentional guarded-client creation commands and popup/opener tests keep their original parameters.
 
 `settleScale` (default 1) multiplies the bounds of waits for events the leg expects to happen: settles (beacon, served, title and load) on the control leg and `required` settles on either leg, `paused` on the control leg, page and child loads, the wait for a background step's `as` result (`<as> did not complete within <ms>ms`), the wait for the pre-action beacons, the C9 control's `Debugger.paused`, and the wait for an observation the leg expects to be `true`. Adopters on slow hosts can set 3 or 4. Every wait polls and returns as soon as its event arrives, so a larger bound only costs time when something is really missing, and each timeout error names the bound it used. An observation read from the fixture (`observer: "fixture"`, such as a beacon or a served request) that the leg expects to be `true` is polled for up to 5000 ms (scaled) instead of read once. One that the leg expects to be `false` is still read once.
 

package/guard-driver.mjs

@@ -1,5 +1,25 @@
 const q = JSON.stringify;
 
+export const originDefaults = {
+  plain: 'ordinary',
+  cross: 'client',
+  log: 'ordinary',
+  own: 'client',
+};
+export const knownOrigins = [
+  'ordinary',
+  'ordinary-same-site',
+  'seven',
+  'vault',
+  'vault-x',
+  'apex',
+  'own',
+  'client',
+  'plain',
+  'cross',
+  'log',
+];
+
 export const beacon = (log, tag) =>
   `try { const u = ${q(log)} + '/beacon?tag=' + ${q(tag)} + '&origin=' + encodeURIComponent(location.origin); if (!navigator.sendBeacon(u)) fetch(u, { keepalive: true, mode: 'no-cors' }).catch(() => {}); } catch {}`;
 
@@ -276,6 +296,77 @@ const passed = (r) =>
   [r.control, r.guarded, r.live].every((s) => s === 'skip') ||
   [r.control, r.guarded, r.live].every((s) => s === 'not-run');
 
+const capabilities = (value) =>
+  Array.isArray(value)
+    ? value.flatMap(capabilities)
+    : value && typeof value === 'object'
+      ? Object.entries(value).flatMap(([key, item]) =>
+          key === 'requires' && Array.isArray(item) ? item : capabilities(item)
+        )
+      : [];
+
+const originNames = (value) =>
+  [...q(value ?? null).matchAll(/\{([A-Za-z][A-Za-z-]*)\}/g)]
+    .map((match) => (match[1] === 'beacon' || match[1] === 'probe' ? 'log' : match[1]))
+    .flatMap((name) => [name, originDefaults[name]]);
+
+const checkOrigins = (check) => {
+  if (!check || typeof check !== 'object') return [];
+  if (check.any) return checkOrigins(check.any[0]);
+  if (check.all || check.not) return (check.all ?? [check.not]).flatMap(checkOrigins);
+  return originNames(check);
+};
+
+function originReason(vector, row, reason) {
+  const origin = /^not-applicable:no-(.+)-origin$/.exec(reason)?.[1];
+  if (!knownOrigins.includes(origin)) return false;
+  const fixed = [
+    row.target,
+    '{plain}',
+    vector?.control?.origin,
+    vector?.setup,
+    vector?.trigger,
+  ].map((value) => (typeof value === 'string' && !value.startsWith('{') ? `{${value}}` : value));
+  return [
+    ...originNames(fixed),
+    ...checkOrigins(vector?.liveCheck),
+    ...Object.values(vector?.observe ?? {}).flatMap((observation) =>
+      checkOrigins(observation?.check)
+    ),
+  ].includes(origin);
+}
+
+function skipWhy(vector, row, known) {
+  const { reason } = row;
+  if (typeof reason !== 'string' || reason === '') return 'skip without a reason';
+  if (reason === 'not-applicable' || originReason(vector, row, reason)) return null;
+  if (vector?.skip?.target === row.target && vector.skip.reason === reason) return null;
+  if (reason.startsWith('not-supported:') && known.has(reason.slice('not-supported:'.length)))
+    return null;
+  return `skip with a reason the runner never gives: ${reason}`;
+}
+
+function forgeries(set, results) {
+  const vectors = new Map(set.vectors.map((v) => [v.id, v]));
+  const known = new Set([
+    'browserSession',
+    'unguarded-observer',
+    ...capabilities(set.vectors).filter((c) => typeof c === 'string' && c !== ''),
+  ]);
+  return results.flatMap((row) => {
+    const legs = [row.control, row.guarded, row.live];
+    const vector = vectors.get(row.id);
+    const why = [];
+    if (legs.includes('not-run') && vector?.kind !== 'text')
+      why.push('not-run on a vector that is not kind text');
+    if (legs.includes('skip')) why.push(skipWhy(vector, row, known));
+    const found = why.filter(Boolean);
+    if (!found.length) return [];
+    const { id, target, variant, transport } = row;
+    return [{ id, target, variant, transport, why: found.join('; ') }];
+  });
+}
+
 export function summary({ guard, sha, set, results }) {
   const uniq = (k) => [...new Set(results.map((r) => r[k]))].sort();
   const variants = [...new Set([...Object.keys(set.variants ?? {}), ...uniq('variant')])].sort();
@@ -286,7 +377,9 @@ export function summary({ guard, sha, set, results }) {
     .flatMap((row) => variants.map((variant) => ({ ...row, variant })))
     .flatMap((row) => uniq('transport').map((transport) => ({ ...row, transport })))
     .filter((r) => !has.has(q([r.id, r.target, r.variant, r.transport])));
-  const pass = results.length > 0 && missing.length === 0 && results.every(passed);
+  const forged = forgeries(set, results);
+  const pass =
+    results.length > 0 && missing.length === 0 && forged.length === 0 && results.every(passed);
   const name = `@ai-ecoverse/slicc-browsers@${set.setVersion}`;
   return {
     set: name,
@@ -302,8 +395,9 @@ export function summary({ guard, sha, set, results }) {
       .map(({ id, target, reason }) => ({ id, target, reason })),
     notRun: [...new Set(results.filter((r) => r.control === 'not-run').map((r) => r.id))],
     missing,
+    forged,
     pass,
-    line: `${pass ? 'GUARD-PASS' : 'GUARD-FAIL'} ${guard}@${sha} (vectors ${name})`,
+    line: `${pass ? 'GUARD-PASS' : 'GUARD-FAIL'} ${guard}@${sha} (vectors ${name})${forged.length ? ` forged ${forged.length}` : ''}`,
   };
 }
 

package/guard-runner.mjs

@@ -9,7 +9,9 @@ import {
   expand,
   hop,
   isRefusal,
+  knownOrigins,
   loadedAfter,
+  originDefaults,
   outcome,
   owned,
   parseURL,
@@ -703,6 +705,7 @@ class Execution {
             fixture: this.options.fixture,
             mode: step.redirectSecret,
             side: this.side,
+            controls: (this.clients.redirectSecretControls ??= {}),
           })
         );
       } finally {
@@ -1301,21 +1304,6 @@ const browserContextStep = (vector, capabilities) =>
         supported(['browserContexts'], capabilities))
   );
 
-const originDefaults = { plain: 'ordinary', cross: 'client', log: 'ordinary', own: 'client' };
-const knownOrigins = [
-  'ordinary',
-  'ordinary-same-site',
-  'seven',
-  'vault',
-  'vault-x',
-  'apex',
-  'own',
-  'client',
-  'plain',
-  'cross',
-  'log',
-];
-
 function nullOrigins(value, targets) {
   return [...q(value).matchAll(/\{([A-Za-z][A-Za-z-]*)\}/g)]
     .map((match) => (match[1] === 'beacon' || match[1] === 'probe' ? 'log' : match[1]))
@@ -1678,15 +1666,16 @@ function validate(set, opts) {
 
 function factoryClients(opts, set, job, slot) {
   return outcome(
-    opts.clientFactory
-      ? opts.clientFactory({
-          slot,
-          variant: job.variant,
-          detachDelay: set.variants[job.variant],
-          vector: job.vector,
-          target: job.target,
-        })
-      : Promise.resolve(opts.client)
+    (async () =>
+      opts.clientFactory
+        ? opts.clientFactory({
+            slot,
+            variant: job.variant,
+            detachDelay: set.variants[job.variant],
+            vector: job.vector,
+            target: job.target,
+          })
+        : opts.client)()
   );
 }
 

package/guard-vectors.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "setVersion": "1.13.3",
+  "setVersion": "1.13.5",
   "sources": [
     {
       "repo": "ai-ecoverse/slicc-cli",
@@ -309,6 +309,42 @@
             "equals": true,
             "observer": "client"
           }
+        },
+        "requestsTerminated": {
+          "means": "redirect secret: every seen redirect request ends, no unterminated request",
+          "check": {
+            "result": "redirect",
+            "path": "result.requestsTerminated",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "hopsRedacted": {
+          "means": "redirect secret: every protected hop is origin-only, never the raw URL",
+          "check": {
+            "result": "redirect",
+            "path": "result.hopsRedacted",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "networkBodyAttempted": {
+          "means": "redirect secret: networkBodyAttempted",
+          "check": {
+            "result": "redirect",
+            "path": "result.networkBodyAttempted",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "networkBodyRefused": {
+          "means": "redirect secret: networkBodyRefused",
+          "check": {
+            "result": "redirect",
+            "path": "result.networkBodyRefused",
+            "equals": true,
+            "observer": "client"
+          }
         }
       },
       "live": "the fixture served the registered ordinary redirect",
@@ -337,7 +373,9 @@
           "resourceContentAttempted": true,
           "snapshotAttempted": true,
           "domSnapshotAttempted": true,
-          "overridesWorked": true
+          "overridesWorked": true,
+          "requestsTerminated": true,
+          "networkBodyAttempted": true
         }
       },
       "expected": {
@@ -352,7 +390,11 @@
         "snapshotAttempted": true,
         "domSnapshotAttempted": true,
         "overridesRefused": true,
-        "iframeSnapshotAttempted": true
+        "iframeSnapshotAttempted": true,
+        "requestsTerminated": true,
+        "hopsRedacted": true,
+        "networkBodyAttempted": true,
+        "networkBodyRefused": true
       }
     },
     {
@@ -518,6 +560,24 @@
             "equals": true,
             "observer": "client"
           }
+        },
+        "requestsTerminated": {
+          "means": "redirect secret: every seen redirect request ends, no unterminated request",
+          "check": {
+            "result": "redirect",
+            "path": "result.requestsTerminated",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "hopsRedacted": {
+          "means": "redirect secret: every protected hop is origin-only, never the raw URL",
+          "check": {
+            "result": "redirect",
+            "path": "result.hopsRedacted",
+            "equals": true,
+            "observer": "client"
+          }
         }
       },
       "live": "the fixture served the registered ordinary redirect",
@@ -543,7 +603,8 @@
           "networkFragmentVisible": true,
           "frameFragmentVisible": true,
           "frameTreeFragmentVisible": true,
-          "resourceTreeFragmentVisible": true
+          "resourceTreeFragmentVisible": true,
+          "requestsTerminated": true
         }
       },
       "expected": {
@@ -556,7 +617,9 @@
         "fetchBodyRefused": true,
         "networkBodyRefused": true,
         "extraLocation": true,
-        "fragmentsHidden": true
+        "fragmentsHidden": true,
+        "requestsTerminated": true,
+        "hopsRedacted": true
       }
     },
     {
@@ -722,6 +785,24 @@
             "equals": true,
             "observer": "client"
           }
+        },
+        "requestsTerminated": {
+          "means": "redirect secret: every seen redirect request ends, no unterminated request",
+          "check": {
+            "result": "redirect",
+            "path": "result.requestsTerminated",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "hopsRedacted": {
+          "means": "redirect secret: every protected hop is origin-only, never the raw URL",
+          "check": {
+            "result": "redirect",
+            "path": "result.hopsRedacted",
+            "equals": true,
+            "observer": "client"
+          }
         }
       },
       "live": "the fixture served the registered ordinary redirect",
@@ -747,7 +828,8 @@
           "networkFragmentVisible": true,
           "frameFragmentVisible": true,
           "frameTreeFragmentVisible": true,
-          "resourceTreeFragmentVisible": true
+          "resourceTreeFragmentVisible": true,
+          "requestsTerminated": true
         }
       },
       "expected": {
@@ -760,7 +842,9 @@
         "fetchBodyRefused": true,
         "networkBodyRefused": true,
         "extraLocation": true,
-        "fragmentsHidden": true
+        "fragmentsHidden": true,
+        "requestsTerminated": true,
+        "hopsRedacted": true
       }
     },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-browsers",
-  "version": "1.13.3",
+  "version": "1.13.5",
   "description": "SLICC's shared browser catalog, JSON schemas and discovery conformance corpus",
   "type": "module",
   "license": "Apache-2.0",
@@ -66,7 +66,7 @@
     "validate": "node scripts/validate.mjs",
     "lint": "slicc-lint && test -z \"$(gofmt -l .)\" && go mod tidy -diff && go vet ./... && golangci-lint run && cargo fmt --check && cargo clippy --all-features --all-targets -- -D warnings",
     "format": "biome check --write . && gofmt -w . && cargo fmt",
-    "test": "npm run validate && node --test test/integration/self-contained.test.mjs test/integration/browser-runner.test.mjs test/integration/fixture-client.test.mjs test/integration/git-retry.test.mjs test/integration/dist-tag.test.mjs test/integration/guard-incomplete.test.mjs test/integration/guard-stall.test.mjs && go test -race -count=1 ./test/integration/... && cargo test --all-features",
+    "test": "npm run validate && node --test test/integration/self-contained.test.mjs test/integration/browser-runner.test.mjs test/integration/fixture-client.test.mjs test/integration/git-retry.test.mjs test/integration/guard-redirect-carrier.test.mjs test/integration/dist-tag.test.mjs test/integration/guard-incomplete.test.mjs test/integration/guard-stall.test.mjs test/integration/guard-forged.test.mjs && go test -race -count=1 ./test/integration/... && cargo test --all-features",
     "test:unit": "go test -race -cover ./...",
     "build": "go build ./... && cargo build --all-features && cargo build --target wasm32-wasip1 --all-features && npm pack --dry-run",
     "trust": "npx fledgling sync -y --skip-publish",

package/protected-error-page.mjs

@@ -80,6 +80,18 @@ async function redaction({
     : 'not-supported';
 }
 
+async function observerTarget(reader, initial, notes) {
+  const { targetId } = await createObserverTarget(
+    reader,
+    { url: initial, background: true },
+    notes
+  );
+  const attached = await outcome(reader.send('Target.attachToTarget', { targetId, flatten: true }));
+  if (attached.ok) return { targetId, sessionId: attached.result.sessionId };
+  await outcome(reader.send('Target.closeTarget', { targetId }));
+  throw new Error(attached.error.message);
+}
+
 async function seed(reader, observer, loaded, initial, allowed) {
   const out = await outcome(
     (async () => {
@@ -119,17 +131,13 @@ export async function protectedErrorPage({
   const missing = (reason) => ({ ...result, incomplete: `protected-error-page: ${reason}` });
   if (!discovery) notes.push('eventsRedacted: not-supported:discovery');
   const start = client.events.length;
-  const { targetId } = await createObserverTarget(
-    reader,
-    { url: initial, background: true },
-    notes
-  );
+  let cursor = reader.events.length;
+  const opened = await outcome(observerTarget(reader, initial, notes));
+  if (!opened.ok) return missing(`observer setup failed: ${opened.error.message}`);
+  const { targetId } = opened.result;
   let session;
-  let observer;
+  let observer = opened.result.sessionId;
   let failing = false;
-  let cursor = reader.events.length;
-  const { sessionId } = await reader.send('Target.attachToTarget', { targetId, flatten: true });
-  observer = sessionId;
   internalSessions.add(observer);
   const frame = async () => (await reader.send('Page.getFrameTree', {}, observer)).frameTree.frame;
   const loaded = (url) => loadedDocument(reader, observer, url, until);

package/redirect-secret.mjs

@@ -89,6 +89,7 @@ class RedirectProbe {
     this.attempts = [];
     this.jobs = new Set();
     this.networkBodies = new Set();
+    this.learned = { network: new Set(), fetch: new Set(), tap: new Set() };
     this.registrations = [];
     this.seen = new Map();
     this.protectedURLs = [
@@ -97,6 +98,7 @@ class RedirectProbe {
       `https://seven.sliccy.ai/auth/callback#access_token=${encodeURIComponent(this.marker)}&state=${encodeURIComponent(this.marker)}`,
       `https://vault.sliccy.ai/oauth/mcp-callback#access_token=${encodeURIComponent(this.marker)}`,
     ];
+    this.prefix = new URL(`${this.ordinary}/redirect-secret/${this.tag}-`).href;
     this.plainURL = `${this.ordinary}/redirect-secret-body/${this.tag}-plain?code=${encodeURIComponent(this.marker)}`;
     this.destinations =
       this.side === 'control'
@@ -119,6 +121,7 @@ class RedirectProbe {
     if (redirects.includes(event.params.responseStatusCode)) {
       const out = await this.send('Fetch.getResponseBody', { requestId: event.params.requestId });
       this.attempts.push({ method: 'Fetch.getResponseBody', ...out });
+      if (event.params.networkId) this.track(this.networkBody(event.params.networkId, 'fetch'));
     }
     if (
       this.holdURL &&
@@ -139,19 +142,131 @@ class RedirectProbe {
         if (event.method === 'Fetch.requestPaused') this.track(this.fetchPause(event));
         const response = event.params?.redirectResponse ?? event.params?.response;
         if (!response || !redirects.includes(response.status)) continue;
-        const requestId = event.params.requestId;
-        if (this.networkBodies.has(requestId)) continue;
-        this.networkBodies.add(requestId);
-        this.track(
-          this.send('Network.getResponseBody', { requestId }).then((out) => {
-            this.attempts.push({ method: 'Network.getResponseBody', ...out });
-          })
-        );
+        this.track(this.networkBody(event.params.requestId, 'network'));
       }
       await pause(5);
     }
   }
 
+  async networkBody(requestId, source) {
+    this.learned[source].add(requestId);
+    if (this.networkBodies.has(requestId)) return;
+    this.networkBodies.add(requestId);
+    const entry = { method: 'Network.getResponseBody', source, pending: true };
+    this.attempts.push(entry);
+    const out = await this.send('Network.getResponseBody', { requestId });
+    delete entry.pending;
+    Object.assign(entry, out);
+  }
+
+  async settle() {
+    for (let i = 0; i < 500 && this.jobs.size; i++) await pause(10);
+  }
+
+  tap() {
+    for (const event of this.reader.events ?? []) {
+      if (event.sessionId !== this.observer) continue;
+      const response = event.params?.redirectResponse ?? event.params?.response;
+      if (response?.url?.startsWith(this.prefix) && redirects.includes(response.status))
+        this.track(this.networkBody(event.params.requestId, 'tap'));
+    }
+  }
+
+  networkLeg() {
+    const carriers = [...this.networkBodies].map((id) =>
+      this.learned.network.has(id)
+        ? 'network'
+        : this.learned.fetch.has(id)
+          ? 'fetch-networkId'
+          : 'withheld+tap'
+    );
+    const path =
+      ['withheld+tap', 'fetch-networkId', 'network'].find((carrier) =>
+        carriers.includes(carrier)
+      ) ?? 'none';
+    const networkBodyCarriers = Object.fromEntries(
+      [...new Set(carriers)].map((carrier) => [
+        carrier,
+        carriers.filter((entry) => entry === carrier).length,
+      ])
+    );
+    const attempts = this.attempts.filter((entry) => entry.method === 'Network.getResponseBody');
+    const refusedAll = attempts.length > 0 && attempts.every(refused);
+    const proven = path === 'network' || this.side !== 'guarded' || this.controls?.networkEvents;
+    const reason =
+      path === 'none'
+        ? 'no network id for the redirect'
+        : proven
+          ? undefined
+          : 'control did not prove the redirect Network events';
+    if (reason && (!attempts.length || refusedAll))
+      return {
+        networkBodyPath: path,
+        networkBodyCarriers,
+        networkBodyAttempted: 'incomplete',
+        networkBodyRefused: 'incomplete',
+        incomplete: `redirect-secret: network body leg ${reason}`,
+      };
+    return {
+      networkBodyPath: path,
+      networkBodyCarriers,
+      networkBodyAttempted: attempts.length > 0,
+      networkBodyRefused: refusedAll,
+    };
+  }
+
+  hops(events) {
+    const own = events.filter((event) => event.sessionId === this.session);
+    const seen = new Set(
+      own
+        .filter(
+          (event) =>
+            event.method === 'Network.requestWillBeSent' &&
+            (event.params.redirectResponse
+              ? event.params.redirectResponse.url?.startsWith(this.prefix)
+              : event.params.request?.url?.startsWith(this.prefix))
+        )
+        .map((event) => event.params.requestId)
+    );
+    const protectedOrigins = this.protectedURLs.map((url) => new URL(url).origin);
+    const hops = Object.fromEntries(
+      [...seen].map((requestId) => {
+        const mine = own.filter((event) => event.params?.requestId === requestId);
+        const hop = mine.find(
+          (event) =>
+            event.method === 'Network.requestWillBeSent' &&
+            event.params.redirectResponse?.url?.startsWith(this.prefix)
+        );
+        const end = mine.find((event) =>
+          ['Network.loadingFinished', 'Network.loadingFailed'].includes(event.method)
+        );
+        const url = hop?.params.request?.url ?? '';
+        const origin = protectedOrigins.find((value) => url.startsWith(value));
+        return [
+          requestId,
+          {
+            delivery: !hop
+              ? end
+                ? 'withheld'
+                : 'unterminated'
+              : !origin
+                ? 'ordinary'
+                : [origin, `${origin}/`].includes(url)
+                  ? 'redacted'
+                  : 'raw',
+            terminal: (hop ?? end)?.method ?? null,
+          },
+        ];
+      })
+    );
+    const deliveries = Object.values(hops).map((entry) => entry.delivery);
+    return {
+      hops,
+      requestsTerminated: !deliveries.includes('unterminated'),
+      hopsRedacted: !deliveries.some((delivery) => ['raw', 'ordinary'].includes(delivery)),
+    };
+  }
+
   async register(key, to, code = 302) {
     const url = `${this.ordinary}/redirect-secret/${this.tag}-${key}`;
     const path = new URL(url).pathname;
@@ -186,6 +301,7 @@ class RedirectProbe {
     ).sessionId;
     this.watching = this.watch();
     await this.reader.send('Page.enable', {}, this.observer);
+    if (this.side === 'guarded') await this.reader.send('Network.enable', {}, this.observer);
     await this.reader.send('Storage.setCookies', {
       cookies: [
         {
@@ -361,14 +477,23 @@ class RedirectProbe {
 
   async evidence() {
     await pause(8000);
+    this.tap();
+    if (this.side === 'control' && this.controls)
+      this.controls.networkEvents = this.learned.network.size > 0;
     await this.send('Fetch.disable');
     await this.reset('survive');
     const survives = await this.send('Runtime.evaluate', {
       expression: 'document.title',
       returnByValue: true,
     });
-    const events = this.client.events.slice(this.eventsStart);
-    const messages = this.client.messages?.slice(this.messagesStart) ?? [];
+    await this.settle();
+    const tapped = `"sessionId":"${this.observer}"`;
+    const events = this.client.events
+      .slice(this.eventsStart)
+      .filter((event) => event.sessionId !== this.observer);
+    const messages = (this.client.messages?.slice(this.messagesStart) ?? []).filter(
+      (message) => !message.includes(tapped)
+    );
     const eventLeaks = await this.scan(events);
     const ordinaryEvents = events.filter(
       (event, index) =>
@@ -394,10 +519,7 @@ class RedirectProbe {
         );
       });
     const found = (key) => this.responses.some((entry) => entry[key]);
-    const attempted = (method) => this.attempts.some((entry) => entry.method === method);
-    const bodyRefused = (method) =>
-      this.attempts.filter((entry) => entry.method === method).length > 0 &&
-      this.attempts.filter((entry) => entry.method === method).every(refused);
+    const fetchAttempts = this.attempts.filter((entry) => entry.method === 'Fetch.getResponseBody');
     return {
       live: (await this.fixture.log()).some((entry) =>
         entry.url.includes(`/redirect-secret/${this.tag}`)
@@ -412,10 +534,10 @@ class RedirectProbe {
         ),
       secretHidden: !replyLeaks.includes(true),
       sessionSurvives: survives.ok && survives.result?.result?.value === 'doc',
-      fetchBodyAttempted: attempted('Fetch.getResponseBody'),
-      networkBodyAttempted: attempted('Network.getResponseBody'),
-      fetchBodyRefused: bodyRefused('Fetch.getResponseBody'),
-      networkBodyRefused: bodyRefused('Network.getResponseBody'),
+      fetchBodyAttempted: fetchAttempts.length > 0,
+      fetchBodyRefused: fetchAttempts.length > 0 && fetchAttempts.every(refused),
+      ...this.networkLeg(),
+      ...this.hops(events),
       extraInPlace,
       ...redirectFragments({
         messages,
@@ -476,7 +598,7 @@ class RedirectProbe {
   async close() {
     this.stopped = true;
     await this.watching;
-    await Promise.allSettled([...this.jobs]);
+    await this.settle();
     await outcome(this.client.send('Fetch.disable', {}, this.session));
     if (this.observer) {
       await outcome(