@ai-ecoverse/slicc-browsers 1.13.4 → 1.13.6

package/README.md

@@ -190,7 +190,7 @@ 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 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 `Network.requestWillBeSent` the client sees for a registered redirect 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-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. 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.
 
@@ -224,7 +224,7 @@ A client may register `Fetch.enable` patterns naming a protected origin in eithe
 - `observe?`: each observed name, as `{ "means", "dependsOn"?, "requires"?, "eitherWhen"? }`. `requires` gates only that observation when it is not also a whole-vector requirement: unavailable evidence is recorded as `"not-supported"`, excluded from that field's expectations, and reported in the row's `notSupported` list. `dependsOn` lists the refusals the observation depends on (see Refusals). `eitherWhen` is a check: when it holds on the guarded leg, that observation's expectation becomes `"either"` there (see Design-dependent outcomes);
 - `live`: the liveness check;
 - `control` (`origin: "ordinary"`, `via`, `expected`) and `expected`: an object of names and booleans, or text;
-- `skip?` (`target`, `reason`): `reason` starts with a code, as in `not-applicable: …`.
+- `skip?` (`target`, `reason`): `reason` starts with a code, as in `not-applicable: …`. A runner reports the row on `target` as `skip` with this `reason`, unless a capability is missing.
 
 **Steps** are declarative and transport-neutral. Any step can take `on` (`control` or `guarded`), which runs it on that leg only.
 Any `cdp`, `page` or `children` step can take `requires`, the capabilities it needs: `autoAttach` for `Target.setAutoAttach`, `children` and `session: "child"`, `browserSession` for `session: "browser"`, `browserContexts` for `Target.createBrowserContext` and `Target.disposeBrowserContext`, and `chromeUrlsAttach` for a step that must attach to a `chrome://` page to pass.
@@ -279,7 +279,7 @@ For remote/page harnesses, `fixtureClient(base)` is exported by `./guard-runner`
 
 **Design-dependent outcomes.** A key listed in `designDependent` may expect `"either"`, which `true` and `false` both match: a guard that refuses a setup step lets the real document load, and one that blocks before commit doesn't. `detached` is design-dependent on the rows whose guarded leg proves the block (the pre-action beacon plus an exact-URL block or the history form): its `eitherWhen` holds the same proof, so a guard that blocks without detaching passes, and one that neither blocks nor detaches still fails. The hard negatives stay required.
 
-**Observability.** `observable.own: false` marks a vector the guard host's own origin can't show (headers, auth, redirects); a runner whose `own` is a static server reports it as `skip` with `not-observable`.
+**Observability.** `observable.own: false` marks a vector the guard host's own origin can't show (headers, auth, redirects); a runner reports it as `skip` with `not-applicable` on that target.
 
 **Applies to.** `appliesTo` lists the triggers a vector runs with (`href`, `iframe`, `popup`, `redirect`). Chrome doesn't apply some session overrides inside a cross-site iframe, so those E6 rows list `href` only.
 
@@ -306,9 +306,11 @@ 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;
+- `skipReason(vector, target, scope)`: the reason the runner skips the row with when it has every capability: the vector's `skip.reason` when its `skip.target` is `target`, `not-applicable` when its `observable[target]` is `false` or its `scope` is neither `any` nor `scope`, otherwise `null`; `inapplicable(vector, target, scope)` is whether it isn't `null`;
+- `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 (`skipReason(vector, target, guard)`, the reason the runner gives: the vector's own `skip.reason` on its `skip.target`, or `not-applicable` for a target it marks unobservable or a `scope` other than `any` and the guard; `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, 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;
@@ -357,7 +359,7 @@ otherwise they run serially. `capabilities` is an object of booleans or an array
 of supported names, and a capability that isn't declared is unsupported: a CDP
 transport over a DevTools port declares `chromeUrlsAttach: true`, and an
 extension on `chrome.debugger` leaves it out, so `C8.newtab` is skipped with
-`not-supported:chromeUrlsAttach`. `capabilities.scope` selects owner-specific rows.
+`not-supported:chromeUrlsAttach`. `capabilities.scope` selects owner-specific rows; pass the same name as `guard` to `summary()`.
 
 Map `ordinary`, `ordinary-same-site`, `seven`, `vault`, `vault-x`, `apex`, `own`
 and `client` to origins. `chrome-newtab`, `chrome-new-tab-page`, `chrome-settings`, `chrome-passwords`, `chrome-search`, `network-error`, `chrome-extension-page` and `file-root` default to their `url`.

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,86 @@ 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);
+}
+
+export const skipReason = (vector, target, scope) => {
+  if (!vector) return null;
+  if (vector.skip?.target === target) return vector.skip.reason;
+  if (vector.observable?.[target] === false) return 'not-applicable';
+  return vector.scope !== 'any' && vector.scope !== scope ? 'not-applicable' : null;
+};
+
+export const inapplicable = (vector, target, scope) => skipReason(vector, target, scope) !== null;
+
+function skipWhy(vector, row, known, guard) {
+  const { reason } = row;
+  if (typeof reason !== 'string' || reason === '') return 'skip without a reason';
+  if (reason === skipReason(vector, row.target, guard)) return null;
+  if (originReason(vector, row, 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, guard) {
+  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, guard));
+    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 +386,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, guard);
+  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 +404,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

@@ -8,13 +8,17 @@ import {
   canary,
   expand,
   hop,
+  inapplicable,
   isRefusal,
+  knownOrigins,
   loadedAfter,
+  originDefaults,
   outcome,
   owned,
   parseURL,
   summary as report,
   result,
+  skipReason,
   steps,
   waitFor,
 } from './guard-driver.mjs';
@@ -1287,10 +1291,7 @@ const needsObserver = (vector) =>
   );
 
 const inactive = (vector, target, capabilities) =>
-  vector.skip?.target === target ||
-  vector.observable?.[target] === false ||
-  !supported(vector.requires, capabilities) ||
-  (vector.scope !== 'any' && vector.scope !== capabilities.scope);
+  inapplicable(vector, target, capabilities.scope) || !supported(vector.requires, capabilities);
 
 const allSteps = (list) => list.flatMap((step) => [step, ...allSteps(step.children ?? [])]);
 const browserContextStep = (vector, capabilities) =>
@@ -1302,21 +1303,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]))
@@ -1508,7 +1494,9 @@ async function executeRow(job, opts, made, set, slot, index, flights) {
       control: 'skip',
       guarded: 'skip',
       live: 'skip',
-      reason: missing ? `not-supported:${missing}` : 'not-applicable',
+      reason: missing
+        ? `not-supported:${missing}`
+        : skipReason(vector, target, opts.capabilities.scope),
     };
   }
   if (

package/guard-vectors.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "setVersion": "1.13.4",
+  "setVersion": "1.13.6",
   "sources": [
     {
       "repo": "ai-ecoverse/slicc-cli",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-browsers",
-  "version": "1.13.4",
+  "version": "1.13.6",
   "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/guard-redirect-carrier.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/redirect-secret.mjs

@@ -222,8 +222,9 @@ class RedirectProbe {
         .filter(
           (event) =>
             event.method === 'Network.requestWillBeSent' &&
-            !event.params.redirectResponse &&
-            event.params.request?.url?.startsWith(this.prefix)
+            (event.params.redirectResponse
+              ? event.params.redirectResponse.url?.startsWith(this.prefix)
+              : event.params.request?.url?.startsWith(this.prefix))
         )
         .map((event) => event.params.requestId)
     );