@ai-ecoverse/slicc-browsers 1.13.2 → 1.14.2

package/README.md

@@ -204,6 +204,8 @@ The `C8.newtab` reachability control attaches through the guard to a settled ord
 
 `C8.network-error` and `C8.iframe-error` are ordinary-error reachability controls: request the configured `network-error` URL (default `http://nonexistent.invalid/`) directly or in an ordinary iframe, observe a failed Document request, reattach to the settled tab, evaluate and snapshot its document, then navigate the same tab to an ordinary document. Both control and guarded legs must pass. The failing URL is unchanged on the control, rather than replaced with a healthy origin, and the rows require `browserSession` but not `chromeUrlsAttach`. With Chrome for Testing 156.0.8078.4, scheme-wide `chrome-error` protection made the direct-error row fail both legs because reattachment was refused; removing it passed both rows, with readable DOM and successful recovery. The old emulator still allowed the cross-process iframe parent because the iframe TargetInfo kept the failing HTTP URL, but that layout-specific behavior is not grounds for protecting the error scheme. Plain-client controls and reachability legs also passed both rows.
 
+`E4` and the `E6` rows are runnable, each with a guarded-through control on the ordinary origin that must show the effect. `E4` sets a `Debugger.setBreakpointByUrl` on line 0 of the `listener=1` document's `/listener.js?n=<tag>` with a condition that sends `{beacon}` and returns `false`; the control needs that beacon, and the guarded leg needs neither the beacon nor a `Debugger.paused` in the protected document. `E4.instrumentation` sets `Debugger.setInstrumentationBreakpoint` with `beforeScriptWithSourceMapExecution`, so only `/listener.js`, whose `SourceMap` header names a source map, pauses: `beforeScriptExecution` would also pause the runner's own `Runtime.evaluate` and any extension's content script first. `E4.event-listener` sets `DOMDebugger.setEventListenerBreakpoint` for `load`. Both set up before the trigger, need a `Debugger.paused` on the control (in `/listener.js`, or for `E4.event-listener` with `listener:load`, which only that document registers, since a listener pause reports no script URL), none on the guarded leg, and end with `Debugger.disable` to resume. The `E6` overrides are set on the page session before the trigger: `E6.headers` (`x-probe`), `E6.ua-network` and `E6.ua-emulation` (`User-Agent: slicc-probe-<tag>`) and `E6.cache-disabled` (`Pragma: no-cache`) are read from the stand-in's request log; `E6.network-conditions` (1500 ms latency) needs a navigation `duration` of at least 1000 ms, since Chrome delays the body rather than `responseStart`; `E6.locale` (`fr-CH`), `E6.timezone` (`Pacific/Chatham`) and `E6.network-state` (`navigator.onLine` false) are read by the unguarded observer in the destination document, and `E6.network-state` starts on `{cross}`, because Chrome drops that override on a same-site navigation once a second session is attached to the page. A guard that keeps its own session on the page, as the test emulator's Fetch shield does, can still lose it, and then fails that control rather than passing it; `E6.blocked-urls` has the observer fetch a blocked `/data` subresource there. Observer reads first check that the page is the exact destination URL, so a blocked or replaced document never shows the effect. The five overrides Chrome also applies inside a cross-site iframe have an `.iframe` row, triggered through `/framed`; `E6.network-conditions.iframe` reads the iframe's `duration` from the parent's resource timing. Each override is refusable at registration, with its observation depending on that refusal. These rows settle on the destination's load or request rather than on the detach variant, because each effect lands when the request is made or the script runs.
+
 A client may register `Fetch.enable` patterns naming a protected origin in either of two conformant ways: the guard allows registration but never pauses or forwards protected requests to the client and refuses continue, fulfil or fail calls for request ids it did not hand out; or the guard refuses registration with its declared refusal text. Setup calls explicitly naming a protected placeholder are refusable with `refusal.onlyProtected: true`, and interception-dependent observations depend on that refusal. Wildcard and ordinary-only patterns do not receive this exemption. The ordinary-origin control still runs through the guard and must succeed.
 
 **Top level.**
@@ -250,8 +252,9 @@ Any `cdp`, `page` or `children` step can take `requires`, the capabilities it ne
 Popups are observed by `Target.targetCreated` with the opener's `openerId`, or by the child's `Target.attachedToTarget`, never by the URL: a popup waiting for the debugger can still be `about:blank`.
 
 **The stand-in** serves these routes on every origin. It never listens on 9222 to 9229.
-- `/doc?n=`: an HTML page with the `data-canary` marker; `csp=1` adds `Content-Security-Policy: script-src 'none'` and an inline script that sends a beacon tagged `inline-<n>` to the log, which the CSP blocks unless it is bypassed;
+- `/doc?n=`: an HTML page with the `data-canary` marker; `listener=1` adds `<script src="/listener.js?n=<n>">`; `csp=1` adds `Content-Security-Policy: script-src 'none'` and an inline script that sends a beacon tagged `inline-<n>` to the log, which the CSP blocks unless it is bypassed;
 - `/hop?code=&to=` and `/framed?src=`;
+- `/listener.js`: one line registering a window `load` listener, served with `SourceMap: /listener.js.map`;
 - `/data?n=`: `real-<n>`, with CORS;
 - `/img`: a 1×1 PNG;
 - `/auth`: Basic `u`:`p`, then `authed`;
@@ -261,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’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).
 
@@ -281,11 +284,11 @@ For remote/page harnesses, `fixtureClient(base)` is exported by `./guard-runner`
 
 **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`.
 
-**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.
+**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 `E6.locale`, `E6.timezone`, `E6.network-state` and `E6.blocked-urls` have no `.iframe` row.
 
 **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" }
@@ -303,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;
@@ -327,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.
 
@@ -348,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 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;
@@ -386,6 +390,8 @@ Every target created by the runner’s own unguarded observer uses `Target.creat
 
 `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
@@ -640,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/fixture-server.mjs

@@ -12,9 +12,12 @@ const escape = (value) =>
 function document(url, html) {
   const p = url.searchParams;
   const csp = p.has('csp') || url.pathname === '/csp';
+  const listener = p.has('listener')
+    ? `<script src="/listener.js?n=${encodeURIComponent(p.get('n') ?? '')}"></script>`
+    : '';
   return html(
     'doc',
-    `<p>document ${escape(p.get('n') ?? '')}</p>${csp ? '<script>document.title="inline"; document.body.dataset.inline="true"</script>' : ''}`,
+    `<p>document ${escape(p.get('n') ?? '')}</p>${listener}${csp ? '<script>document.title="inline"; document.body.dataset.inline="true"</script>' : ''}`,
     csp ? { 'content-security-policy': "script-src 'none'" } : {}
   );
 }
@@ -54,6 +57,13 @@ function route(req, url, send, html, redirects) {
         `globalThis.vectorScript=${JSON.stringify(`real-${p.get('n') ?? ''}`)}`,
         'text/javascript'
       ),
+    '/listener.js': () =>
+      send(
+        200,
+        "addEventListener('load', function () { document.body.dataset.listened = 'true'; });",
+        'text/javascript',
+        { sourcemap: '/listener.js.map' }
+      ),
     '/page': () => html('trigger', trigger(p)),
     '/api/cookies': () => send(200, req.headers.cookie ?? 'none', 'text/plain'),
     '/plant': () =>

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,37 @@ function validate(set, opts) {
   return variants;
 }
 
+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)
+  );
+}
+
+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 +1734,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 +1782,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 +1809,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,
           ])