@ai-ecoverse/slicc-browsers 1.14.0 → 1.14.3

package/README.md

@@ -264,9 +264,9 @@ 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.
+`{ "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.
+`{ "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.
 
 **Host-harness requirements for every guard.** Host Node processes may use `fixtureServer()` from `./fixture`; browser pages must import only the browser-safe runner graph, served with JavaScript MIME types, and need no Node-global shim. All guards supply a guarded client, an independent unguarded observer, mapped fixture origins and the relevant advertised capabilities. C2 clients additionally record every received raw CDP frame in `client.messages` before parsing. Route protected seven/vault hosts to the fixture with `--host-resolver-rules`, including default-port callback URLs; a live protected-body negative needs HTTPS fixture trust (the reference harness pins its SPKI).
 
@@ -288,7 +288,7 @@ For remote/page harnesses, `fixtureClient(base)` is exported by `./guard-runner`
 
 **Variants.** `variants` gives the delay in milliseconds before the client's `Target.detachFromTarget`: `prompt` 0, `lagging` 8000. A runner may add its own variant names.
 
-**Reports.** There is one row per id, target, variant and transport. `control`, `guarded` and `live` are each `pass`, `fail`, `skip` (with the skip's `reason`) or `not-run` (for text rows):
+**Reports.** There is one row per id, target, variant and transport. `control`, `guarded` and `live` are each `pass`, `fail`, `incomplete` (missing probe evidence, listed in the row's `incomplete`), `skip` (with the skip's `reason`) or `not-run` (for text rows):
 
 ```json
 { "id": "C1.script-nav", "target": "vault", "variant": "lagging", "transport": "cli", "via": "guard", "control": "pass", "guarded": "pass", "live": "pass" }
@@ -306,6 +306,7 @@ It exports:
 - `refusals(vector)`: the vector's refusal names;
 - `outcome`, `call(client, step, sessionId)` and `isRefusal(outcome, step)`;
 - `instrument(client, sessionId, log, tag)`, `load(client, sessionId, url)` and `popup(client, openerId)`;
+- `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;
 - `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;
@@ -330,7 +331,7 @@ It exports:
 `guard-runner.mjs` is dependency-free browser ESM. `run(set, options)` returns
 `{ results, summary(metadata) }`; the module also exports `summary`. Results have
 `id`, `target`, `variant`, `control`, `guarded`, `live`, boolean observations and
-errors. Statuses are `pass`, `fail`, `skip` and `not-run`. Text vectors are reported
+errors. Statuses are `pass`, `fail`, `incomplete`, `skip` and `not-run`. Text vectors are reported
 as `not-run`; they are not silently certified. A missing observation check is an
 error before execution.
 
@@ -351,7 +352,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.
-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;
@@ -383,12 +384,14 @@ 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.
 
 `refusalScale` (default 1) multiplies the bounds of waits for what the guarded leg expects to be absent, the beacon, request, title or navigation that the guard should block: settles that are not `required`, and `paused`, on the guarded leg. Such a wait runs to its full bound whenever the guard works, so `settleScale` leaves it alone. The trade-off: a larger `refusalScale` gives more sensitivity to a leak that arrives late on a slow host, because the observations after the wait see it, at the cost of that much more time per guarded row. Adopters should keep `refusalScale` at 1 or higher, never below 1; the runner refuses a `refusalScale` below 1 with `refusalScale must be a number of at least 1`.
 
+**Incomplete.** A probe that returns `incomplete` (only `errorPage` and `redirectSecret` steps) records the reason in the row's `incomplete` as `<leg> <probe>: <reason>`. Its unmeasured observations read `"incomplete"`, and so does guarded liveness when the probe never measured it. A leg whose measured observations all match is then `incomplete`, never `pass`, and `live` is `incomplete` when only its evidence is missing; a measured mismatch still makes the leg `fail`, and any row error still fails both legs. `summary()` counts `incomplete` per leg, returns the number of rows with any `incomplete` status as `incomplete`, appends `incomplete <n>` to `line`, and never passes such a run. A leg that throws keeps the errors it recorded before the throw.
+
 `onStart(row)` receives each row's `id`, `target`, `variant`, `transport` and `via` as the row starts. `run()` returns a promise that also has `inFlight()`, and its result has `inFlight` too. `inFlight()` lists the rows that are running now, each as `{ id, target, variant, leg, phase, step, clients }`, where `step` is the index of the current step in its `phase` (`setup`, `trigger` or `child`), and `clients` lists each client's pending CDP calls as `{ method, session, ageMs }` (`client`, plus `unguarded` when it is a separate client). With `rowTimeoutMs`, a row still running after that many milliseconds fails on its own. Its `errors` hold `row timed out after <ms>ms: <the in-flight view>`, `inFlight` holds the view, and the clients that `clientFactory` made for it are closed. The run then goes on to the next row. It is off by default, and a client passed as `client` is never closed.
 
 `log(row)` receives completed rows. Besides `control`, `guarded`, `live`, `why` and `errors`, a row may carry `notSupported` (unavailable observation fields), `ran` (steps that ran on one leg only) and `notes` (settles skipped because their registration was refused). Both are informational: they explain a row's verdict, and adopters (bios, slicc-cli, slicc-cdp) must not count them as failures, or as passes. The verdict is `control`, `guarded` and `live`. A variant supplies the wait before an
@@ -643,15 +646,15 @@ Changing a table in `slicc-cli/internal/browser` means changing `catalog.json` h
 
 ## Releases
 
-semantic-release cuts one version from `main` for all three packages (`.github/workflows/release.yml`):
+semantic-release cuts one version from `main` for all three packages (`.github/workflows/release.yml`). The maintenance branch `1.13.x` (`.releaserc.json`: range `1.13.x`, channel `release-1.13.x`) cuts `1.13.N` patches the same way; it takes only `fix:` commits, cherry-picked from `main` after they merge there, through pull requests that merge on green CI.
 1. The tag `vX.Y.Z` and a GitHub release are the Go module's release. `scripts/major-guard.mjs` fails the release when the major doesn't fit the module path in `go.mod` (no suffix allows v0 and v1, `/vN` only vN). The workflow then asks `proxy.golang.org` for the new version and `pkg.go.dev` to fetch it; both only warn.
-2. **npm:** with the repository variable `SLICC_BROWSERS_NPM_PUBLISH` set to `true`, the package is stamped with the version and published through npm trusted publishing (OIDC, with provenance). A version that is already on npm is skipped.
+2. **npm:** with the repository variable `SLICC_BROWSERS_NPM_PUBLISH` set to `true`, the package is stamped with the version and published through npm trusted publishing (OIDC, with provenance). A version that is already on npm is skipped. `scripts/dist-tag.mjs <version> <ref> <latest>` picks the dist-tag: `latest` for a run from `main` whose version is not below the current `latest`, otherwise `release-X.Y.x`; a run from `main` fails when it cannot read `latest`. So a `1.13.x` release publishes to `release-1.13.x` and never moves `latest`. The GitHub release of a maintenance version is not marked latest, and the Go proxy and crates.io order by version.
 3. **crates.io:** with the repository variable `SLICC_BROWSERS_CRATES_PUBLISH` set to `true`, `Cargo.toml` is stamped with the version and `cargo publish` runs with a short-lived token from crates.io trusted publishing (`rust-lang/crates-io-auth-action`). A version that is already on crates.io is skipped.
 4. **Cert line:** after the npm publish, the workflow runs `npm pack @ai-ecoverse/slicc-browsers@X.Y.Z` against the registry and appends `cert: @ai-ecoverse/slicc-browsers@X.Y.Z sha256=<hex> gitHead=<sha>` to the `vX.Y.Z` GitHub release and the job summary, once; the cert lane copies it from there.
 
 GitHub sometimes rejects the push of `refs/notes/semantic-release-vX.Y.Z` with a bare `(failed)` right after the tag push; no ruleset covers `refs/notes/*`. The semantic-release step runs with `pipefail` and puts `scripts/git-retry.mjs` first on `PATH` as `git`: it runs the real git (`REAL_GIT`) and retries a push of a `refs/notes/` ref up to five times, 5, 10, 15 and 20 seconds apart; any other git command runs once. When semantic-release still fails, the job fails before npm and crates.io publish. Recover without moving the tag: create the GitHub release on the existing tag, then run `gh workflow run release.yml --ref main -f tag=vX.Y.Z`. A tag without its note counts as on the default channel (semantic-release reads a missing note as `channels: [null]`), so the next release builds on it. `test/integration/git-retry.test.mjs` tests the retry with a fake git.
 
-A run started by hand publishes what's missing without a new release: `gh workflow run release.yml --ref main` when `main`'s head has its tag, or `gh workflow run release.yml --ref main -f tag=vX.Y.Z` for any existing tag. `gh workflow run release.yml --ref main -f cert-only=true` only adds the cert line for the latest npm version.
+A run started by hand publishes what's missing without a new release: `gh workflow run release.yml --ref main` when `main`'s head has its tag, or `gh workflow run release.yml --ref main -f tag=vX.Y.Z` for any existing tag. `gh workflow run release.yml --ref main -f cert-only=true` only adds the cert line for the latest npm version. On the maintenance line, use `--ref 1.13.x -f tag=v1.13.N`.
 
 **Go module versions.** A pushed tag is the release: `proxy.golang.org` caches it and `sum.golang.org` records its hash for good. Never move or delete a pushed tag; retract a bad version in `go.mod` and release anew. A `BREAKING CHANGE` needs a `/vN` module path first.
 

package/guard-driver.mjs

@@ -111,10 +111,37 @@ export async function load(client, sessionId, url, ms = 20000) {
   const start = client.events.length;
   const { loaderId } = await client.send('Page.navigate', { url }, sessionId);
   if (!loaderId) return;
-  const deadline = Date.now() + ms;
-  while (!loadedAfter(client.events.slice(start), sessionId, loaderId)) {
-    if (Date.now() > deadline) throw new Error(`load of ${url} timed out`);
-    await new Promise((resolve) => setTimeout(resolve, 25));
+  if (!(await waitFor(() => loadedAfter(client.events.slice(start), sessionId, loaderId), ms)))
+    throw new Error(`load of ${url} timed out`);
+}
+
+export async function waitFor(check, ms, step = 25) {
+  const start = Date.now();
+  const limit = start + ms + Math.max(ms * 4, 30000);
+  let deadline = start + ms;
+  let last = start;
+  const beat = () => {
+    const now = Date.now();
+    const gap = now - last;
+    if (gap > Math.max(step * 4, 1000)) deadline = Math.min(limit, deadline + gap - step);
+    last = now;
+  };
+  let timer;
+  const tick = () => {
+    beat();
+    timer = setTimeout(tick, step);
+  };
+  timer = setTimeout(tick, step);
+  try {
+    for (;;) {
+      if (await check()) return true;
+      beat();
+      if (Date.now() > deadline) return false;
+      await new Promise((resolve) => setTimeout(resolve, step));
+      beat();
+    }
+  } finally {
+    clearTimeout(timer);
   }
 }
 

package/guard-runner.mjs

@@ -16,6 +16,7 @@ import {
   summary as report,
   result,
   steps,
+  waitFor,
 } from './guard-driver.mjs';
 import { createObserverTarget, discoveryViolation } from './observer-target.mjs';
 import { protectedErrorPage } from './protected-error-page.mjs';
@@ -120,6 +121,7 @@ class Execution {
     this.contexts = [];
     this.pending = [];
     this.errors = [];
+    this.incomplete = [];
     this.preSent = [];
     this.notes = [];
     this.answers = [];
@@ -193,12 +195,7 @@ class Execution {
   }
 
   async poll(predicate, ms = 1500, absent = false) {
-    const deadline = Date.now() + this.bound(ms, absent);
-    do {
-      if (await predicate()) return true;
-      await sleep(25);
-    } while (Date.now() < deadline);
-    return false;
+    return waitFor(predicate, this.bound(ms, absent));
   }
 
   async prepareState(spec) {
@@ -641,6 +638,8 @@ class Execution {
       (key) => step[key]
     );
     if (probe && !out.ok) this.errors.push(`${probe}: ${out.error?.message ?? 'probe failed'}`);
+    if (['errorPage', 'redirectSecret'].includes(probe) && out.ok && out.result?.incomplete)
+      this.incomplete.push(`${probe}: ${out.result.incomplete}`);
     if (step.as && !out.result?.pending) this.calls[step.as] = out;
     if (step.cdp) (this.calls.$cdp ??= []).push({ method: step.cdp, ...out });
   }
@@ -726,6 +725,7 @@ class Execution {
           secret: step.secret,
           discovery: supported(['discovery'], this.options.capabilities),
           notes: this.notes,
+          budget: this.bound(5000),
         })
       );
     if (step.unparseable)
@@ -956,7 +956,10 @@ class Execution {
     const want = (this.side === 'control' ? this.vector.control.expected : this.vector.expected)?.[
       name
     ];
-    if (check?.result && at(this.calls[check.result], check.path) === 'incomplete')
+    if (
+      check?.result &&
+      (at(this.calls[check.result], check.path) === 'incomplete' || this.unmeasured(check))
+    )
       return 'incomplete';
     if (want !== true || check?.observer !== 'fixture') return this.check(check);
     let seen = false;
@@ -967,6 +970,11 @@ class Execution {
     return seen;
   }
 
+  unmeasured(check) {
+    const out = check?.result ? this.calls[check.result] : undefined;
+    return Boolean(out?.result?.incomplete) && at(out, check.path) === undefined;
+  }
+
   async check(check) {
     const c = expand(check, this.vars);
     if (!(await this.ready(c))) return false;
@@ -1186,6 +1194,8 @@ class Execution {
     if (this.side === 'control') return { live: true };
     const alive = () => this.check(this.vector.liveCheck);
     let live = await alive();
+    if (!live && this.unmeasured(this.vector.liveCheck))
+      return { live: 'incomplete', liveWhy: 'incomplete' };
     if (!live && !unseen.length) live = await this.poll(alive, 1500);
     if (!unseen.length || (live && !incomplete.length)) return { live };
     const detail = incomplete.length ? ` (${incomplete.join(', ')} incomplete)` : '';
@@ -1216,7 +1226,14 @@ class Execution {
         side: this.side,
       });
       const { live, liveWhy } = await this.liveness(unseen, incomplete);
-      return { observed, live, liveWhy, errors: this.errors, notes: this.notes };
+      return {
+        observed,
+        live,
+        liveWhy,
+        errors: this.errors,
+        notes: this.notes,
+        incomplete: this.incomplete,
+      };
     } finally {
       this.stopped = true;
       await pumping;
@@ -1517,18 +1534,17 @@ async function executeRow(job, opts, made, set, slot, index, flights) {
   opts.onStart?.(base);
   const sides = (async () => {
     for (const side of ['control', 'guarded']) {
+      const vars = variables(opts.targets, target, side, slot, index);
+      const execution = new Execution(vector, side, opts, clients, vars, set.variants[variant]);
       try {
-        const vars = variables(opts.targets, target, side, slot, index);
-        legs[side] = await new Execution(
-          vector,
-          side,
-          opts,
-          clients,
-          vars,
-          set.variants[variant]
-        ).run();
+        legs[side] = await execution.run();
       } catch (error) {
-        legs[side] = { observed: {}, live: false, errors: [String(error.message ?? error)] };
+        legs[side] = {
+          observed: {},
+          live: false,
+          errors: [...execution.errors, String(error.message ?? error)],
+          notes: execution.notes,
+        };
       }
     }
   })();
@@ -1559,6 +1575,7 @@ async function executeRow(job, opts, made, set, slot, index, flights) {
     ...(legs.guarded.notes ?? []).map((note) => `guarded ${note}`),
   ];
   if (notes.length) row.notes = notes;
+  settleIncomplete(row, vector, base, legs);
   if (row.errors.length) {
     row.control = 'fail';
     row.guarded = 'fail';
@@ -1567,6 +1584,37 @@ async function executeRow(job, opts, made, set, slot, index, flights) {
   return row;
 }
 
+function settleIncomplete(row, vector, base, legs) {
+  const incomplete = ['control', 'guarded'].flatMap((side) =>
+    (legs[side].incomplete ?? []).map((reason) => `${side} ${reason}`)
+  );
+  if (!incomplete.length) return;
+  row.incomplete = incomplete;
+  if (row.errors.length) return;
+  const fill = (side) => {
+    const want = side === 'control' ? vector.control.expected : vector.expected;
+    return Object.fromEntries(
+      Object.entries(legs[side].observed).map(([name, value]) => [
+        name,
+        value === 'incomplete' && Object.hasOwn(want, name)
+          ? want[name] === 'either' || want[name]
+          : value,
+      ])
+    );
+  };
+  const filled = result(vector, {
+    ...base,
+    control: fill('control'),
+    guarded: fill('guarded'),
+    live: legs.control.live === true && [true, 'incomplete'].includes(legs.guarded.live),
+  });
+  for (const side of ['control', 'guarded'])
+    if (legs[side].incomplete?.length && row[side] === 'fail' && filled[side] === 'pass')
+      row[side] = 'incomplete';
+  if (legs.guarded.live === 'incomplete' && filled.live === 'pass') row.live = 'incomplete';
+  row.why = [filled.why, `incomplete: ${incomplete.join('; ')}`].filter(Boolean).join('; ');
+}
+
 const invalidBlocked = (check) =>
   Boolean(
     check?.blocked &&
@@ -1628,6 +1676,38 @@ function validate(set, opts) {
   return variants;
 }
 
+function factoryClients(opts, set, job, slot) {
+  return outcome(
+    (async () =>
+      opts.clientFactory
+        ? opts.clientFactory({
+            slot,
+            variant: job.variant,
+            detachDelay: set.variants[job.variant],
+            vector: job.vector,
+            target: job.target,
+          })
+        : opts.client)()
+  );
+}
+
+function unmade(job, message) {
+  const reason = `clientFactory: ${message}`;
+  return {
+    id: job.vector.id,
+    target: job.target,
+    variant: job.variant,
+    via: job.vector.control.via,
+    transportVariant: false,
+    control: 'incomplete',
+    guarded: 'incomplete',
+    live: 'incomplete',
+    why: `incomplete: ${reason}`,
+    errors: [],
+    incomplete: [reason],
+  };
+}
+
 export function run(set, options) {
   const flights = new Set();
   const inFlight = () =>
@@ -1655,20 +1735,21 @@ async function runAll(set, options, flights) {
   const results = new Array(jobs.length);
   let next = 0;
   let serial = Promise.resolve();
+  let transport = 'cdp';
+  const unmadeRows = [];
   const worker = async (slot) => {
     for (;;) {
       const index = next++;
       if (index >= jobs.length) break;
       const job = jobs[index];
-      const made = opts.clientFactory
-        ? await opts.clientFactory({
-            slot,
-            variant: job.variant,
-            detachDelay: set.variants[job.variant],
-            vector: job.vector,
-            target: job.target,
-          })
-        : opts.client;
+      const factory = await factoryClients(opts, set, job, slot);
+      if (!factory.ok) {
+        results[index] = unmade(job, factory.error.message);
+        unmadeRows.push(results[index]);
+        continue;
+      }
+      const made = factory.result;
+      transport = (typeof made?.send === 'function' ? made : made?.client)?.transport ?? transport;
       const clients =
         typeof made?.send === 'function'
           ? {
@@ -1702,6 +1783,10 @@ async function runAll(set, options, flights) {
   };
   const width = opts.clientFactory ? opts.parallel : 1;
   await Promise.all(Array.from({ length: width }, (_, slot) => worker(slot)));
+  for (const row of unmadeRows) {
+    row.transport = transport;
+    opts.log?.(row);
+  }
   return { results, summary: (metadata = {}) => summary({ set, results, ...metadata }) };
 }
 
@@ -1725,23 +1810,28 @@ export function summary({ set, results, guard = 'reference', sha = 'unknown' })
     if (row.control === 'skip')
       skips[row.reason ?? 'unknown'] = (skips[row.reason ?? 'unknown'] ?? 0) + 1;
   const skipped = Object.values(skips).reduce((sum, count) => sum + count, 0);
+  const incomplete = results.filter((row) =>
+    [row.control, row.guarded, row.live].includes('incomplete')
+  ).length;
   const line = observerSkipped ? value.line.replace('GUARD-PASS', 'GUARD-FAIL') : value.line;
+  const skipLine = skipped
+    ? `${line} skips ${skipped} (${Object.entries(skips)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([reason, count]) => `${reason}=${count}`)
+        .join(', ')})`
+    : line;
   return {
     ...value,
     pass: value.pass && observerSkipped === 0,
-    line: skipped
-      ? `${line} skips ${skipped} (${Object.entries(skips)
-          .sort(([a], [b]) => a.localeCompare(b))
-          .map(([reason, count]) => `${reason}=${count}`)
-          .join(', ')})`
-      : line,
+    line: incomplete ? `${skipLine} incomplete ${incomplete}` : skipLine,
     skips,
     observerSkipped,
+    incomplete,
     counts: Object.fromEntries(
       ['control', 'guarded', 'live'].map((side) => [
         side,
         Object.fromEntries(
-          ['pass', 'fail', 'skip', 'not-run'].map((status) => [
+          ['pass', 'fail', 'incomplete', 'skip', 'not-run'].map((status) => [
             status,
             results.filter((r) => r[side] === status).length,
           ])

package/guard-vectors.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-browsers",
-  "version": "1.14.0",
+  "version": "1.14.3",
   "description": "SLICC's shared browser catalog, JSON schemas and discovery conformance corpus",
   "type": "module",
   "license": "Apache-2.0",
@@ -66,14 +66,14 @@
     "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 && 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/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: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",
     "trust:dry": "npx fledgling sync --dry-run -y --skip-publish",
     "release": "semantic-release",
     "test:guard": "npm run test:guard-integration && npm run test:guard-sweep",
-    "test:guard-integration": "node --test --test-concurrency=2 test/integration/guard-lifecycle.test.mjs test/integration/guard-fit.test.mjs test/integration/guard-chain.test.mjs test/integration/guard-validation.test.mjs test/integration/guard-liveness.test.mjs test/integration/guard-observations.test.mjs test/integration/guard-child-latency.test.mjs test/integration/guard-adoption.test.mjs test/integration/guard-scoping.test.mjs test/integration/guard-late-pause.test.mjs test/integration/guard-legs.test.mjs test/integration/guard-fetch-enable.test.mjs test/integration/guard-diagnostics.test.mjs test/integration/guard-chrome.test.mjs test/integration/guard-worlds.test.mjs test/integration/guard-world-discovery.test.mjs test/integration/guard-world-guesses.test.mjs test/integration/guard-unparseable.test.mjs test/integration/guard-redirect-secret.test.mjs test/integration/guard-error-page.test.mjs test/integration/guard-discovery.test.mjs test/integration/guard-browser-page.test.mjs test/integration/guard-scales.test.mjs test/integration/guard-shared-log.test.mjs test/integration/guard-pre-beacon.test.mjs test/integration/guard-world-pause.test.mjs test/integration/self-contained.test.mjs",
+    "test:guard-integration": "node --test --test-concurrency=2 test/integration/guard-lifecycle.test.mjs test/integration/guard-fit.test.mjs test/integration/guard-chain.test.mjs test/integration/guard-validation.test.mjs test/integration/guard-liveness.test.mjs test/integration/guard-observations.test.mjs test/integration/guard-child-latency.test.mjs test/integration/guard-adoption.test.mjs test/integration/guard-scoping.test.mjs test/integration/guard-late-pause.test.mjs test/integration/guard-legs.test.mjs test/integration/guard-fetch-enable.test.mjs test/integration/guard-diagnostics.test.mjs test/integration/guard-chrome.test.mjs test/integration/guard-worlds.test.mjs test/integration/guard-world-discovery.test.mjs test/integration/guard-world-guesses.test.mjs test/integration/guard-unparseable.test.mjs test/integration/guard-redirect-secret.test.mjs test/integration/guard-error-page.test.mjs test/integration/guard-discovery.test.mjs test/integration/guard-browser-page.test.mjs test/integration/guard-scales.test.mjs test/integration/guard-shared-log.test.mjs test/integration/guard-pre-beacon.test.mjs test/integration/guard-world-pause.test.mjs test/integration/guard-parallel.test.mjs test/integration/self-contained.test.mjs",
     "test:guard-sweep": "node scripts/test-guards.mjs",
     "test:gates": "node --test test/integration/gates.test.mjs",
     "test:guard-target": "node --test test/integration/guard-runner.test.mjs",
@@ -81,7 +81,7 @@
     "test:unit:guard": "mkdir -p coverage/unit && node --experimental-vm-modules --no-warnings --experimental-test-coverage --test --test-coverage-include=guard-runner.mjs --test-coverage-include=fixture-server.mjs --test-coverage-include=fixture-client.mjs --test-coverage-include=observer-target.mjs --test-coverage-include=protected-error-page.mjs --test-coverage-include=unparseable-url.mjs --test-coverage-include=scripts/browser-runner.mjs --test-coverage-include=scripts/validate.mjs --test-reporter=lcov --test-reporter-destination=coverage/unit/guard.lcov test/unit/guard-*.test.mjs && slicc-diff-cover coverage/unit/guard.lcov"
   },
   "devDependencies": {
-    "@ai-ecoverse/slicc-shared-web": "2.3.3",
+    "@ai-ecoverse/slicc-shared-web": "2.3.5",
     "@biomejs/biome": "2.5.15",
     "ajv": "8.20.0",
     "ajv-formats": "3.0.1",

package/protected-error-page.mjs

@@ -1,19 +1,10 @@
-import { outcome } from './guard-driver.mjs';
+import { outcome, waitFor } from './guard-driver.mjs';
 import { createObserverTarget } from './observer-target.mjs';
 
 const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const refused = (out) => !out.ok && /^slicc: refused:/.test(out.error?.message ?? '');
 
-async function until(check) {
-  const deadline = Date.now() + 5000;
-  do {
-    if (await check()) return true;
-    await pause(25);
-  } while (Date.now() < deadline);
-  return false;
-}
-
-async function loadedDocument(reader, observer, url) {
+async function loadedDocument(reader, observer, url, until) {
   return until(async () => {
     const { frameTree } = await reader.send('Page.getFrameTree', {}, observer);
     if (frameTree.frame.url !== url || frameTree.frame.unreachableUrl) return false;
@@ -89,6 +80,30 @@ 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 () => {
+      await reader.send('Page.enable', {}, observer);
+      if (!(await loaded(initial))) return 'history seed did not commit';
+      await reader.send('Page.navigate', { url: allowed }, observer);
+      if (!(await loaded(allowed))) return 'allowed document did not commit';
+    })()
+  );
+  return out.ok ? out.result : `observer setup failed: ${out.error.message}`;
+}
+
 const secrets = {
   all: (tag) => `/doc/path-secret-${tag}?query-secret=${tag}#fragment-secret-${tag}`,
   query: (tag) => `/doc?query-secret=${tag}`,
@@ -107,26 +122,25 @@ export async function protectedErrorPage({
   secret = 'all',
   discovery = true,
   notes = [],
+  budget = 5000,
 }) {
   const initial = `${protectedOrigin}/doc?n=${tag}-history`;
   const failedURL = `${protectedOrigin}${secrets[secret](tag)}`;
   const result = {};
+  const until = (check) => waitFor(check, budget);
+  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);
+  const loaded = (url) => loadedDocument(reader, observer, url, until);
   let stopped = false;
   const fail = (async () => {
     while (!stopped) {
@@ -147,12 +161,8 @@ export async function protectedErrorPage({
     }
   })();
   try {
-    await reader.send('Page.enable', {}, observer);
-    if (!(await loaded(initial)))
-      throw new Error('protected-error-page: history seed did not commit');
-    await reader.send('Page.navigate', { url: `${ordinary}/blank` }, observer);
-    if (!(await loaded(`${ordinary}/blank`)))
-      throw new Error('protected-error-page: allowed document did not commit');
+    const unseeded = await seed(reader, observer, loaded, initial, `${ordinary}/blank`);
+    if (unseeded) return missing(unseeded);
     const attached = await outcome(
       client.send('Target.attachToTarget', { targetId, flatten: true })
     );
@@ -174,10 +184,11 @@ export async function protectedErrorPage({
       { expression: `setTimeout(()=>location.href=${JSON.stringify(failedURL)},0)` },
       session
     );
-    result.live = await until(async () => {
+    let evidence;
+    const live = await until(async () => {
       const f = await frame();
       const { targetInfo } = await reader.send('Target.getTargetInfo', { targetId });
-      result.evidence = { frame: f, targetInfo };
+      evidence = { frame: f, targetInfo };
       return (
         f.url === 'chrome-error://chromewebdata/' &&
         f.securityOrigin === '://' &&
@@ -185,11 +196,11 @@ export async function protectedErrorPage({
         targetInfo.url === failedURL
       );
     });
-    if (!result.live && side !== 'control') return result;
-    if (!result.live)
-      throw new Error(
-        `protected-error-page: missing error commit ${JSON.stringify(result.evidence)}`
-      );
+    result.evidence = evidence;
+    if (!live && side === 'control')
+      return missing(`missing error commit ${JSON.stringify(evidence)}`);
+    result.live = live;
+    if (!live) return result;
     await redaction({ client, targetId, failedURL, protectedOrigin, start, result, discovery });
     const beforeReload = (await frame()).loaderId;
     result.reload = (await outcome(client.send('Page.reload', {}, session))).ok;
@@ -227,14 +238,14 @@ export async function protectedErrorPage({
     failing = false;
     const { entries, currentIndex } = await reader.send('Page.getNavigationHistory', {}, observer);
     const index = entries.findIndex((e) => e.url === initial);
-    if (index < 0) throw new Error('protected-error-page: missing protected history');
+    if (index < 0) return missing('missing protected history');
     const beforeRestore = reader.events.length;
     await reader.send(
       'Runtime.evaluate',
       { expression: `setTimeout(() => history.go(${index - currentIndex}), 0)` },
       observer
     );
-    result.restored = await until(() =>
+    const restored = await until(() =>
       reader.events
         .slice(beforeRestore)
         .some(
@@ -245,8 +256,8 @@ export async function protectedErrorPage({
             e.params.frame.url === initial
         )
     );
-    if (!result.restored)
-      throw new Error('protected-error-page: real protected BFCache restore required');
+    if (!restored) return missing('real protected BFCache restore required');
+    result.restored = true;
     await pause(100);
     if (mode === 'sticky') {
       await reader.send('Target.detachFromTarget', { sessionId: observer });
@@ -260,11 +271,9 @@ export async function protectedErrorPage({
         observer
       );
       await reader.send('Page.navigate', { url: failedURL }, observer);
-      result.stickyError = await until(async () => (await frame()).unreachableUrl === failedURL);
-      if (!result.stickyError)
-        throw new Error(
-          `protected-error-page: missing sticky error ${JSON.stringify(await frame())}`
-        );
+      if (!(await until(async () => (await frame()).unreachableUrl === failedURL)))
+        return missing(`missing sticky error ${JSON.stringify(await frame())}`);
+      result.stickyError = true;
       await pause(100);
     }
     await lockChecks({ client, session, targetId, result });

package/redirect-secret.mjs

@@ -1,4 +1,4 @@
-import { load, outcome } from './guard-driver.mjs';
+import { load, outcome, waitFor } from './guard-driver.mjs';
 import { redirectFragments } from './redirect-fragments.mjs';
 
 const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -47,28 +47,33 @@ const headersTextMatch = (text, to) =>
       )
   );
 
-export function containsSecret(value, marker) {
+export function containsSecret(value, marker, seen = new Map()) {
   const visit = (value, depth = 0) => {
     if (typeof value === 'string') {
-      if (value.includes(marker)) return true;
-      if (depth >= 8) return false;
-      const decoded = [];
-      try {
-        decoded.push(decodeURIComponent(value));
-      } catch {}
-      try {
-        decoded.push(JSON.parse(value));
-      } catch {}
-      try {
-        decoded.push(JSON.parse(`"${value}"`));
-      } catch {}
-      decoded.push(...decodedBase64(value));
-      return decoded.some((text) => text !== value && visit(text, depth + 1));
+      const key = `${depth}:${value}`;
+      if (!seen.has(key)) seen.set(key, text(value, depth));
+      return seen.get(key);
     }
     if (value && typeof value === 'object')
       return Object.values(value).some((v) => visit(v, depth));
     return false;
   };
+  const text = (value, depth) => {
+    if (value.includes(marker)) return true;
+    if (depth >= 8) return false;
+    const decoded = [];
+    try {
+      decoded.push(decodeURIComponent(value));
+    } catch {}
+    try {
+      decoded.push(JSON.parse(value));
+    } catch {}
+    try {
+      decoded.push(JSON.parse(`"${value}"`));
+    } catch {}
+    decoded.push(...decodedBase64(value));
+    return decoded.some((text) => text !== value && visit(text, depth + 1));
+  };
   return visit(value);
 }
 
@@ -85,6 +90,7 @@ class RedirectProbe {
     this.jobs = new Set();
     this.networkBodies = new Set();
     this.registrations = [];
+    this.seen = new Map();
     this.protectedURLs = [
       `https://seven.sliccy.ai/auth/callback?code=${encodeURIComponent(this.marker)}&state=${encodeURIComponent(this.marker)}`,
       `https://vault.sliccy.ai/oauth/mcp-callback?code=${encodeURIComponent(this.marker)}`,
@@ -158,7 +164,23 @@ class RedirectProbe {
     await load(this.reader, this.observer, `${this.ordinary}/doc?n=${this.tag}-${suffix}`);
   }
 
-  async setup() {
+  contains(value) {
+    return containsSecret(value, this.marker, this.seen);
+  }
+
+  async scan(items) {
+    const flags = [];
+    let slice = Date.now();
+    for (const item of items) {
+      flags.push(this.contains(item));
+      if (Date.now() - slice < 10) continue;
+      await pause(0);
+      slice = Date.now();
+    }
+    return flags;
+  }
+
+  async observe() {
     this.observer = (
       await this.reader.send('Target.attachToTarget', { targetId: this.targetId, flatten: true })
     ).sessionId;
@@ -176,6 +198,9 @@ class RedirectProbe {
         },
       ],
     });
+  }
+
+  async setup() {
     for (const domain of ['Page', 'Network', 'Runtime', 'Log', 'Audits'])
       await this.send(`${domain}.enable`);
     await this.send('Fetch.enable', {
@@ -249,9 +274,9 @@ class RedirectProbe {
       resourceContentAttempted: true,
       snapshotAttempted: true,
       domSnapshotAttempted: true,
-      ordinaryResource: containsSecret(resource, this.marker),
-      ordinarySnapshot: containsSecret(snapshot, this.marker),
-      ordinaryDOM: containsSecret(dom, this.marker),
+      ordinaryResource: this.contains(resource),
+      ordinarySnapshot: this.contains(snapshot),
+      ordinaryDOM: this.contains(dom),
     });
   }
 
@@ -262,9 +287,8 @@ class RedirectProbe {
     await this.send('Runtime.evaluate', {
       expression: `fetch(${JSON.stringify(this.holdURL)}).catch(()=>{});void 0`,
     });
-    const deadline = Date.now() + 5000;
-    while (!this.held && Date.now() < deadline) await pause(10);
-    if (!this.held) throw new Error('redirect body: Fetch override pause missing');
+    if (!(await waitFor(() => Boolean(this.held), 5000, 10)))
+      throw new Error('redirect body: Fetch override pause missing');
     const requestId = this.held.params.requestId;
     const out = await this.send('Fetch.continueRequest', { requestId, url });
     this.responses.push({
@@ -330,8 +354,8 @@ class RedirectProbe {
     const dom = await this.send('DOMSnapshot.captureSnapshot', { computedStyles: [] });
     this.responses.push({
       iframeSnapshotAttempted: true,
-      ordinaryIframeSnapshot: containsSecret(snapshot, this.marker),
-      ordinaryIframeDOM: containsSecret(dom, this.marker),
+      ordinaryIframeSnapshot: this.contains(snapshot),
+      ordinaryIframeDOM: this.contains(dom),
     });
   }
 
@@ -345,11 +369,13 @@ class RedirectProbe {
     });
     const events = this.client.events.slice(this.eventsStart);
     const messages = this.client.messages?.slice(this.messagesStart) ?? [];
+    const eventLeaks = await this.scan(events);
     const ordinaryEvents = events.filter(
-      (event) =>
-        containsSecret(event, this.marker) &&
-        JSON.stringify(event).includes(new URL(this.plainURL).host)
+      (event, index) =>
+        eventLeaks[index] && JSON.stringify(event).includes(new URL(this.plainURL).host)
     );
+    const replies = [...messages, ...this.responses];
+    const replyLeaks = await this.scan(replies);
     const extra = events.filter(
       (event) =>
         event.sessionId === this.session &&
@@ -377,14 +403,14 @@ class RedirectProbe {
         entry.url.includes(`/redirect-secret/${this.tag}`)
       ),
       rawRecorded: this.messagesStart !== undefined && messages.length > events.length,
-      leakChannels: [...messages, ...this.responses]
-        .filter((message) => containsSecret(message, this.marker))
+      leakChannels: replies
+        .filter((_, index) => replyLeaks[index])
         .map((message) =>
           typeof message === 'string'
             ? (JSON.parse(message).method ?? 'reply')
             : (message.method ?? 'reply')
         ),
-      secretHidden: !containsSecret([...messages, ...this.responses], this.marker),
+      secretHidden: !replyLeaks.includes(true),
       sessionSurvives: survives.ok && survives.result?.result?.value === 'doc',
       fetchBodyAttempted: attempted('Fetch.getResponseBody'),
       networkBodyAttempted: attempted('Network.getResponseBody'),
@@ -396,7 +422,7 @@ class RedirectProbe {
         events,
         replies: this.responses,
         protectedOrigins: this.protectedURLs.map((url) => new URL(url).origin),
-        contains: (value) => containsSecret(value, this.marker),
+        contains: (value) => this.contains(value),
       }),
       redirectLocation: ordinaryEvents.some(
         (event) =>
@@ -472,6 +498,11 @@ export async function redirectSecret(options) {
     throw new Error('redirectSecret fixture registration required');
   const probe = new RedirectProbe(options);
   try {
+    const observed = await outcome(probe.observe());
+    if (!observed.ok)
+      return {
+        incomplete: `redirect-secret: observer setup failed: ${observed.error.message}`,
+      };
     await probe.setup();
     if (options.mode === 'body') await probe.body();
     else await probe.headers();