@ai-ecoverse/slicc-browsers 1.14.9 → 1.15.0

package/README.md

@@ -185,6 +185,9 @@ Every CDP guard runs the vectors in `guard-vectors.json` (schema `schema/guard-v
 - the cert lane's E and B rows;
 - `C5.continue-request` and `C5.continue-response`, added next to `C5.document`;
 - the `C8` rows for privileged pages: `C8.navigate` (a page navigates to `chrome://settings`, `chrome://password-manager`, an extension page or `file:///`; refused), `C8.view-source` (the same through `view-source:`; refused), `C8.create` (`Target.createTarget` straight on those pages; refused), `C8.browser-ui-listed` (`Target.getTargets` lists no `browser_ui` target) and `C8.browser-ui-attach` (`Target.attachToTarget` by a `browser_ui` target's id; refused). All five have an unguarded control, since the guard refuses them only on the privileged target. Two cases aren't rows, because Chrome itself blocks them, so an unguarded client can't tell a guard from none: a page's `window.open('chrome://settings')`, and an `about:` alias such as `about:settings`, which `Page.navigate` and `Target.createTarget` both turn into `about:blank#blocked`. The `about:` aliases are in `protected.json` instead.
+- slicc-cdp's owner vectors in `test/integration/guard-native.test.mjs` at `d85ac3c`: `C5.script`, a protected script subresource under the client's own `Fetch.enable` `*` at both stages (the guard neither pauses it for the client nor lets the client fulfil it, and the page runs the stand-in's real `/script`, while the control's paused request carries its headers as an object with `User-Agent` and runs the forged script), and `X1.after-exit`, the client lifecycle row below.
+
+`X1.after-exit` (family `X`, client lifecycle) needs `clientExit`. Through the guard, the client opens an ordinary tab, registers `Page.addScriptToEvaluateOnNewDocument` with `{beacon}`, `Network.setExtraHTTPHeaders` with `x-probe: {tag}` and `Fetch.enable` `*` with a rule that fulfils the destination with a forged `FULFILLED` page, then loads the `/page` trigger whose `go()` navigates to `{target}/canary/{tag}`. Before the exit it must see its init-script beacon, its header on the trigger request and the trigger's `Fetch.requestPaused`: those are the positive evidence on both legs. Then the client exits, the unguarded observer calls `go()`, and the destination must be served and read as the real `canary` document, with no beacon from `{target}`, no `x-probe` on its request, no forged body and no `Fetch.requestPaused` for it reaching the client: nothing the client registered may outlive it. The control runs the same on `{plain}` through the guard, and expects the same, since an ordinary navigation after the exit must be just as clean. A guard that keeps its upstream session, or its own init scripts, headers or interception, past the client's exit fails the row.
 
 The `C9` foreign extension isolated-world family requires `extensionWorld`: a browser hosting a foreign content-script extension on the ordinary fixture page. `C9.world-hidden` requires the page default context to remain visible after `Runtime.enable`, while the extension context and Runtime/Debugger identifiers remain hidden without cutting or detaching the session. `C9.world-select` probes numeric and unique context selectors, object and argument handles, promises, properties, named bindings and DOM node resolution; each command selecting the hidden world must fail with the `slicc: refused:` prefix, never an ordinary browser error. Numeric guesses also sweep ids 1–32: an id not exposed to this client must be refused, while every exposed numeric context must remain usable; none of those guarded probes may reach the fixture content-script marker. The marker combines the content script’s global lexical `root` binding with its extension-id DOM marker and `chrome.runtime.id`, and is independently required to be absent from the page default world. `C9.world-debugger` pauses inside that content script: the control must reach its frame, while the guard must refuse or hide it. The control waits up to 5000 ms (scaled by `settleScale`) for `Debugger.paused`; when it never pauses, `reachable` records `"incomplete"`, not `false`, and the row fails with `extensionWorld debugger: no Debugger.paused within <ms>ms`. The guarded leg waits up to 1500 ms, scaled by `refusalScale`. `C9.page-drivable` evaluates `self.origin`, captures a DOM snapshot and dispatches an Input click on the same ordinary page; cutting the entire session fails this regression row. All four use an unguarded control, the default browser context and observer discovery of the real extension world, not an invented isolated world. Protected default contexts remain session-cutting evidence; hiding a foreign isolated world does not weaken any seven-origin row.
 
@@ -213,11 +216,11 @@ A client may register `Fetch.enable` patterns naming a protected origin in eithe
 - `setVersion`: the package version. The release flow stamps it into the npm package and the crate (`scripts/set-crate-version.mjs`). In git, and so in the Go module, it reads `0.0.0`; Go code gets the version from the module.
 - `targets`: the names a runner maps to a scheme, host and port: `seven`, `vault`, `vault-x` (a vault branch preview), `apex`, `own` (the client page's origin, `{client}`), `ordinary`, `ordinary-same-site`, `chrome-newtab`, `chrome-new-tab-page`, `chrome-settings`, `chrome-passwords`, `chrome-search`, `network-error`, `chrome-extension-page` and `file-root`. Each has a `description` and, for the protected ones, a default `host`. `chrome-newtab` (`chrome://newtab/`), `chrome-new-tab-page` (`chrome://new-tab-page/`), `chrome-settings` (`chrome://settings/`), `chrome-passwords` (`chrome://password-manager/`), `chrome-search` (`chrome-search://most-visited/`), `network-error` (`http://nonexistent.invalid/`), `chrome-extension-page` (a page of Chrome's built-in PDF viewer extension) and `file-root` (`file:///`) carry a `url`, which the runner uses unless `targets` maps the name to something else. No other URL in the file is one a runner must use.
 - `variants`: the detach variants in ms. `prompt` and `lagging` are documented; a runner may add others, such as `lagging-8s`, and reports the name it ran.
-- `capabilities`: what a transport may lack. `autoAttach` covers `Target.setAutoAttach`, `children` steps and child sessions; `browserSession` covers calls on the browser session; `browserContexts` covers `Target.createBrowserContext` and `Target.disposeBrowserContext`; `extensionWorld` means it can host a foreign content-script extension isolated world on the ordinary fixture; `discovery` means session-less `Target.setDiscoverTargets` and `Target.targetCreated`/`Target.targetInfoChanged` delivery; `chromeUrlsAttach` means the transport can attach to and drive `chrome://` pages. CDP over a DevTools port can; `chrome.debugger` can't, since Chrome refuses it every `chrome://` page, even with `--extensions-on-chrome-urls`.
+- `capabilities`: what a transport may lack. `autoAttach` covers `Target.setAutoAttach`, `children` steps and child sessions; `browserSession` covers calls on the browser session; `browserContexts` covers `Target.createBrowserContext` and `Target.disposeBrowserContext`; `extensionWorld` means it can host a foreign content-script extension isolated world on the ordinary fixture; `discovery` means session-less `Target.setDiscoverTargets` and `Target.targetCreated`/`Target.targetInfoChanged` delivery; `chromeUrlsAttach` means the transport can attach to and drive `chrome://` pages. CDP over a DevTools port can; `chrome.debugger` can't, since Chrome refuses it every `chrome://` page, even with `--extensions-on-chrome-urls`. `clientExit` means the harness can close the guarded client in the middle of a row: the client has `close()`, the `clientFactory` makes a fresh guarded client for the next leg, and an unguarded observer independent of the client outlives it.
 - `placeholders`: every `{name}` used in the vectors, with what it stands for. `{client}` is the client page's origin, which the runner maps.
 
 **A vector** has:
-- `id`, and `family` (`C`, `E` or `B`, the id's first letter);
+- `id`, and `family` (`C`, `E`, `B` or `X`, the id's first letter);
 - `kind`: `cdp` (runnable steps) or `text` (rows in words, which runners report as `not-run`, never `pass`);
 - `scope`: `any`, or the one guard the vector is for;
 - `setup` and `trigger`, both lists of steps;
@@ -226,7 +229,7 @@ A client may register `Fetch.enable` patterns naming a protected origin in eithe
 - `observe?`: each observed name, as `{ "means", "dependsOn"?, "requires"?, "eitherWhen"? }`. `requires` gates only that observation when it is not also a whole-vector requirement: unavailable evidence is recorded as `"not-supported"`, excluded from that field's expectations, and reported in the row's `notSupported` list. `dependsOn` lists the refusals the observation depends on (see Refusals). `eitherWhen` is a check: when it holds on the guarded leg, that observation's expectation becomes `"either"` there (see Design-dependent outcomes);
 - `live`: the liveness check;
 - `control` (`origin: "ordinary"`, `via`, `expected`) and `expected`: an object of names and booleans, or text;
-- `skip?` (`target`, `reason`): `reason` starts with a code, as in `not-applicable: …`.
+- `skip?` (`target`, `reason`): `reason` starts with a code, as in `not-applicable: …`. A runner reports the row on `target` as `skip` with this `reason`, unless a capability is missing.
 
 **Steps** are declarative and transport-neutral. Any step can take `on` (`control` or `guarded`), which runs it on that leg only.
 Any `cdp`, `page` or `children` step can take `requires`, the capabilities it needs: `autoAttach` for `Target.setAutoAttach`, `children` and `session: "child"`, `browserSession` for `session: "browser"`, `browserContexts` for `Target.createBrowserContext` and `Target.disposeBrowserContext`, and `chromeUrlsAttach` for a step that must attach to a `chrome://` page to pass.
@@ -238,7 +241,7 @@ Any `cdp`, `page` or `children` step can take `requires`, the capabilities it ne
   - `open`: `window.open` with a user gesture;
   - `iframe`: add an iframe;
   - `framed`: load the `/framed` page from `from`, with `url` in an iframe;
-  - `fetch`, `xhr`, `image`: load `url` and name the body (`width N` for an image, or `<status> <body>` with `status`); `background` doesn't wait;
+  - `fetch`, `xhr`, `image`, `script`: load `url` and name the body (`width N` for an image, `String(globalThis.vectorScript)` after a `<script src>` loads, `error` when it fails, or `<status> <body>` with `status`); `background` doesn't wait;
   - `eval`: evaluate `expression`.
   `hops` routes `url` through `/hop` on each `origin`, with its `code`.
 - `{ "answer": { "url", "stage"?, "cdp"?, "params"?, "hold"? } }`: answer each paused request or auth challenge for `url` with that call; `hold` leaves it paused. Every other paused request continues unchanged.
@@ -247,6 +250,7 @@ Any `cdp`, `page` or `children` step can take `requires`, the capabilities it ne
 - `{ "wait": ms }`.
 - `{ "paused": { "url", "ms" } }`: wait until the client has seen the pause that an `answer` rule for `url` matches (`Fetch.requestPaused` at the rule's stage, or `Fetch.authRequired` for a `Fetch.continueWithAuth` rule). It waits up to `ms`. On the control leg, a pause that never comes fails the row with `paused: no pause for <url> within <ms>ms`. On the guarded leg the guard may hide that pause, so the step waits the full `ms` and doesn't fail. The C5 guessed-id vectors and `C5.auth` use it before their second request, so the probe's interception id falls between the two ids the guess spans.
 - `{ "guess": { "between", "cdp", "params" }, "as" }`: the call for each request id between the ids paused for the two URLs.
+- `{ "client": "exit" }`: the guarded client exits. The runner calls its `close()`, waits up to 5000 ms (scaled by `settleScale`) for the page target to be no longer attached, noting in `notes` when it stays attached, attaches its unguarded observer to the page, and runs every later step of the leg through that observer. Observations still read the exited client's events. It runs only at the top level of `setup` or `trigger`, and the vector requires `clientExit`.
 - `{ "text": … }`: a step in words.
 
 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`.
@@ -256,6 +260,8 @@ Popups are observed by `Target.targetCreated` with the opener's `openerId`, or b
 - `/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;
+- `/script?n=`: a script setting `globalThis.vectorScript` to `real-<n>`;
+- `/page?k=&to=`: a trigger page whose `go()` sends the page to `to` (`k=href`, `replace`, `popup` or `form`), and `/canary/<tag>`: a document titled `canary` with the marker;
 - `/img`: a 1×1 PNG;
 - `/auth`: Basic `u`:`p`, then `authed`;
 - `/rewritten` (title `rewritten`);
@@ -309,11 +315,11 @@ It exports:
 - `waitFor(check, ms, step?)`: polls `check` every `step` ms (default 25) until it holds, checking once more after the bound. A timer heartbeat every `step` runs for the whole wait, including while `check` is awaiting a reply, and any gap between beats longer than a second (or four steps, if longer) extends the bound by that gap, so a synchronous event-loop stall elsewhere in the process does not consume it. The extensions add up to at most `max(4 × ms, 30000)` ms, so a throttled page cannot stretch a wait without limit. `load`, the runner's waits and the error-page and redirect-body probes use it;
 - `judge(vector, side, observed)`: `{ pass, refused, skipped, mismatches }`, where `refused` lists the leg's refusals and `skipped` the observations that depend on them or explicitly record unavailable observation capabilities;
 - `result(vector, run)`: a report row from `{ target, variant, transport, via?, capabilities?, control, guarded, live }`. `capabilities` is the transport's; without it, the transport has them all;
-- `inapplicable(vector, target, scope)`: whether the row is `not-applicable`: the vector's `skip.target` is `target`, its `observable[target]` is `false`, or its `scope` is neither `any` nor `scope`;
+- `skipReason(vector, target, scope)`: the reason the runner skips the row with when it has every capability: the vector's `skip.reason` when its `skip.target` is `target`, `not-applicable` when its `observable[target]` is `false` or its `scope` is neither `any` nor `scope`, otherwise `null`; `inapplicable(vector, target, scope)` is whether it isn't `null`;
 - `knownOrigins` and `originDefaults`: the origin names a runner can miss, and the origins `plain`, `cross`, `log` and `own` fall back to when unset;
 - `parseURL(value, base?)`: a `URL`, or `null` for anything `new URL` rejects or a non-string; every parse of a fixture log entry or a Chrome-reported URL in the runner and the fixture goes through it (`protected.mjs` keeps its own copy, since it imports nothing), so an unparseable entry never throws;
 - `owned(entries, tag)`: the fixture log entries whose raw URL contains `tag`, the row's attribution through its `n=`, `tag=` or `to=` query;
-- `summary({ guard, sha, set, results })`: `set` is the parsed `guard-vectors.json`. It returns `{ set, schemaVersion, guard, sha, variants, targets, transports, results, skipped, notRun, missing, forged, pass, line }`. `missing` lists each `{ id, target, variant, transport }` without a row, for every vector whose `scope` is `any` or the guard, every target it lists, every variant in `variants` or `results`, and every transport in `results`; `pass` needs it empty, where `line` is `GUARD-PASS <guard>@<sha> (vectors @ai-ecoverse/slicc-browsers@X.Y.Z)` or `GUARD-FAIL …`. `forged` lists each `{ id, target, variant, transport, why }` that is `not-run` on a vector that isn't `kind: "text"`, or `skip` without a reason the runner gives (`not-applicable` when the vector's `skip.target` is the row's target, its `observable` is `false` for that target, or its `scope` is neither `any` nor the guard, the same `inapplicable(vector, target, scope)` the runner uses; `not-applicable:no-<origin>-origin` for an origin in `knownOrigins` that the row's target, `plain`, the control's origin, the steps or a check names, directly or through `originDefaults`, where only the first branch of an `any` counts, the vector's own `skip.reason` on its target, or `not-supported:<capability>` for a capability the set requires, `browserSession` or `unguarded-observer`); `pass` needs it empty too, and `line` then ends in `forged <n>`.
+- `summary({ guard, sha, set, results })`: `set` is the parsed `guard-vectors.json`. It returns `{ set, schemaVersion, guard, sha, variants, targets, transports, results, skipped, notRun, missing, forged, pass, line }`. `missing` lists each `{ id, target, variant, transport }` without a row, for every vector whose `scope` is `any` or the guard, every target it lists, every variant in `variants` or `results`, and every transport in `results`; `pass` needs it empty, where `line` is `GUARD-PASS <guard>@<sha> (vectors @ai-ecoverse/slicc-browsers@X.Y.Z)` or `GUARD-FAIL …`. `forged` lists each `{ id, target, variant, transport, why }` that is `not-run` on a vector that isn't `kind: "text"`, or `skip` without a reason the runner gives (`skipReason(vector, target, guard)`, the reason the runner gives: the vector's own `skip.reason` on its `skip.target`, or `not-applicable` for a target it marks unobservable or a `scope` other than `any` and the guard; `not-applicable:no-<origin>-origin` for an origin in `knownOrigins` that the row's target, `plain`, the control's origin, the steps or a check names, directly or through `originDefaults`, where only the first branch of an `any` counts, or `not-supported:<capability>` for a capability the set requires, `browserSession` or `unguarded-observer`); `pass` needs it empty too, and `line` then ends in `forged <n>`.
 
 **`npm run validate`** checks that:
 - the file matches the schema, and ids are unique;
@@ -325,6 +331,7 @@ It exports:
 - `observe` defines every expected name;
 - in a vector with a refusable step, every observation, except an `as` of a step before the first refusable one, has `dependsOn`, and each name in it is a refusable step's refusal name;
 - every `Target.setAutoAttach`, `children`, child-session, browser-session and browser-context step has the matching `requires`, and a vector's `requires` includes its steps' requirements; observation-only requirements can remain local;
+- a client exit step is top-level and its vector requires `clientExit`, and only a vector with a client exit step scopes a check with `exit`;
 - every `{name}` is in `placeholders`;
 - no URL uses a port from 9222 to 9229.
 
@@ -348,7 +355,7 @@ means guarded transport only; rows requiring an observer report
 `skips`, the number of skipped rows per reason, and appends
 `skips <n> (<reason>=<count>, ...)` to `line` whenever any row was skipped, so a
 certification line never reads skipped rows as coverage.
-`clientFactory({ variant, detachDelay, vector, target, slot })` is called per row
+`clientFactory({ variant, detachDelay, vector, target, slot, leg? })` is called per row
 and may return either a client or `{ client, unguarded, close, transportVariant }`.
 The factory can configure the guard's own transport delay from this metadata;
 the runner never reaches into the guard. `transportVariant: true` acknowledges
@@ -363,6 +370,15 @@ of supported names, and a capability that isn't declared is unsupported: a CDP
 transport over a DevTools port declares `chromeUrlsAttach: true`, and an
 extension on `chrome.debugger` leaves it out, so `C8.newtab` is skipped with
 `not-supported:chromeUrlsAttach`. `capabilities.scope` selects owner-specific rows; pass the same name as `guard` to `summary()`.
+A row with a client exit step needs `clientExit` declared, a `clientFactory` and an
+unguarded observer that isn't the guarded client: without the capability or the factory
+it is `skip` with `not-supported:clientExit`, and without such an observer, with
+`not-supported:unguarded-observer`, since nothing could watch the page after the exit.
+When the control leg exits, the runner calls `clientFactory` again with `leg: "guarded"`
+for the guarded leg's clients and releases them with their `close` after the row. If
+that call fails, or its observer is the client, the guarded leg is `incomplete`, with
+`clientFactory: <reason>` or `client exit: <reason>` in `incomplete`, never a pass. A
+leg whose client can't exit (it has no `close()`) fails with `client exit: <reason>`.
 
 Map `ordinary`, `ordinary-same-site`, `seven`, `vault`, `vault-x`, `apex`, `own`
 and `client` to origins. `chrome-newtab`, `chrome-new-tab-page`, `chrome-settings`, `chrome-passwords`, `chrome-search`, `network-error`, `chrome-extension-page` and `file-root` default to their `url`.
@@ -410,7 +426,9 @@ Checks include: `beacon`, `served`, `header` with
 `compare`, `refused`, `reached`, `attached`, `delivered`, `title`, `expression`,
 `hops` (each exact nested redirect URL), `detached`, `loaded`, `pre`, `blocked`,
 `history`, `frameBlocked`, `registration`, `state` and `filtered`. The diagnostic `executed` and `live`
-checks are not valid liveness proofs.
+checks are not valid liveness proofs. A `beacon`, `served` or `header` check with
+`exit: "before"` reads only the requests logged before the leg's client exit, and with
+`exit: "after"` only those logged after it; on a leg that never exited it is false.
 Compose checks with `all`, `any` or `not`. Predicates support nested partial
 objects, `$contains`, `$regex`, `$some`, nonempty `$every`, and `$encoded` with
 `{ value, prefix }` for a base64-encoded value with an optional prefix. Reads of titles and
@@ -497,7 +515,7 @@ Without `tls`, the server and logged URLs remain HTTP. It returns
 The server serves document, frame, redirect, CSP, authentication, data, image,
 canary and beacon paths. Configure host resolution in your test browser, not in
 the runner. `npm run test:guard` exercises Chromium twice with no guard, one target per
-invocation: controls must pass and guarded protection expectations must fail; the `C8.newtab` reachability control must instead pass both legs. For a single
+invocation: controls must pass and guarded protection expectations must fail; the `C8.newtab` reachability control and `X1.after-exit`, whose plain client leaves nothing behind when it exits, must instead pass both legs. For a single
 target use `GUARD_TARGET=seven npm run test:guard-target`. The fixture also serves
 `/live` image requests from stand-in documents, independently of injected code.
 

package/guard-driver.mjs

@@ -336,18 +336,20 @@ function originReason(vector, row, reason) {
   ].includes(origin);
 }
 
-export const inapplicable = (vector, target, scope) =>
-  Boolean(vector) &&
-  (vector.skip?.target === target ||
-    vector.observable?.[target] === false ||
-    (vector.scope !== 'any' && vector.scope !== scope));
+export const skipReason = (vector, target, scope) => {
+  if (!vector) return null;
+  if (vector.skip?.target === target) return vector.skip.reason;
+  if (vector.observable?.[target] === false) return 'not-applicable';
+  return vector.scope !== 'any' && vector.scope !== scope ? 'not-applicable' : null;
+};
+
+export const inapplicable = (vector, target, scope) => skipReason(vector, target, scope) !== null;
 
 function skipWhy(vector, row, known, guard) {
   const { reason } = row;
   if (typeof reason !== 'string' || reason === '') return 'skip without a reason';
-  if (reason === 'not-applicable' && inapplicable(vector, row.target, guard)) return null;
+  if (reason === skipReason(vector, row.target, guard)) return null;
   if (originReason(vector, row, reason)) return null;
-  if (vector?.skip?.target === row.target && vector.skip.reason === reason) return null;
   if (reason.startsWith('not-supported:') && known.has(reason.slice('not-supported:'.length)))
     return null;
   return `skip with a reason the runner never gives: ${reason}`;

package/guard-runner.mjs

@@ -18,6 +18,7 @@ import {
   parseURL,
   summary as report,
   result,
+  skipReason,
   steps,
   waitFor,
 } from './guard-driver.mjs';
@@ -104,6 +105,9 @@ function pageExpression(step, url) {
     case 'image':
       expression = `new Promise(resolve=>{const i=new Image();i.onload=()=>resolve('width '+i.naturalWidth);i.onerror=()=>resolve('error');i.src=${q(url)};})`;
       break;
+    case 'script':
+      expression = `new Promise(resolve=>{const s=document.createElement('script');s.onload=()=>resolve(String(globalThis.vectorScript));s.onerror=()=>resolve('error');s.src=${q(url)};document.head.append(s);})`;
+      break;
     default:
       throw new Error(`Unknown page kind: ${step.page}`);
   }
@@ -147,6 +151,34 @@ class Execution {
     this.stopped = false;
   }
 
+  actor() {
+    return this.exitedTo ?? this.client;
+  }
+
+  async exit() {
+    const gone = this.client;
+    if (typeof gone.close !== 'function') throw new Error('the guarded client has no close()');
+    this.exitRequestStart = (await this.options.fixture.log()).length;
+    this.clients.exited = true;
+    await gone.close();
+    const released = await this.poll(async () => {
+      const read = await outcome(
+        this.reader.send('Target.getTargetInfo', { targetId: this.pageTarget })
+      );
+      return read.ok && read.result.targetInfo?.attached === false;
+    }, 5000);
+    if (!released)
+      this.notes.push(`client exit: the page stayed attached for ${this.bound(5000)}ms`);
+    const { sessionId } = await this.reader.send('Target.attachToTarget', {
+      targetId: this.pageTarget,
+      flatten: true,
+    });
+    await this.reader.send('Page.enable', {}, sessionId);
+    this.exitedTo = this.reader;
+    this.sessions.page = sessionId;
+    return { sessionId, released };
+  }
+
   session(kind) {
     if (kind === 'browser') return undefined;
     return this.sessions[kind === 'child' ? 'child' : 'page'];
@@ -641,6 +673,7 @@ class Execution {
       (key) => step[key]
     );
     if (probe && !out.ok) this.errors.push(`${probe}: ${out.error?.message ?? 'probe failed'}`);
+    if (step.client && !out.ok) this.errors.push(`client exit: ${out.error.message}`);
     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;
@@ -692,6 +725,7 @@ class Execution {
       await this.settle(step.settle);
       return;
     }
+    if (step.client) return outcome(this.exit());
     if (step.redirectSecret) {
       this.internalSessions.add(session);
       try {
@@ -792,7 +826,7 @@ class Execution {
             (await this.requestCheck({ served: this.actionDestination }, this.actionRequestStart)))
         );
       if (settle.title) return this.check({ title: settle.title, session: settle.session });
-      const events = this.client.events.slice(this.actionEventStart);
+      const events = this.actor().events.slice(this.actionEventStart);
       return events.some(
         (event, index) =>
           event.method === 'Page.frameNavigated' &&
@@ -849,7 +883,7 @@ class Execution {
       session === undefined
     )
       params.browserContextId = this.vars.context;
-    const out = await outcome(this.client.send(step.cdp, params, session));
+    const out = await outcome(this.actor().send(step.cdp, params, session));
     if (step.cdp === 'Target.setAutoAttach' && out.ok) {
       if (params.autoAttach) this.attachSettings.set(session, true);
       else this.attachSettings.delete(session);
@@ -872,7 +906,8 @@ class Execution {
   }
 
   async page(step, session, phase) {
-    this.actionEventStart = this.client.events.length;
+    const client = this.actor();
+    this.actionEventStart = client.events.length;
     this.actionRequestStart = (await this.options.fixture.log()).length;
     this.actionDestination = step.hops ? step.url : undefined;
     const url = step.hops ? hop(step.hops, step.url) : step.url;
@@ -884,7 +919,7 @@ class Execution {
       const tab = await this.create(
         url,
         step.context ?? this.vars.context,
-        this.client,
+        client,
         step.background ?? true
       );
       this.sessions.page = tab.sessionId;
@@ -893,20 +928,20 @@ class Execution {
     }
     if (pre && step.page !== 'framed') this.preSent.push(url);
     if (step.page === 'navigate') {
-      if (pre) await this.evaluate(pre, session);
-      return this.navigate(this.client, session, url);
+      if (pre) await this.evaluate(pre, session, client);
+      return this.navigate(client, session, url);
     }
     if (step.page === 'framed') {
       if (phase === 'trigger') this.preSent.push(url);
       return this.navigate(
-        this.client,
+        client,
         session,
         `${step.from}/framed?tag=${encodeURIComponent(this.vars.tag)}&url=${encodeURIComponent(url)}&log=${encodeURIComponent(this.vars.log)}`
       );
     }
     let expression = pageExpression(step, url);
     if (pre) expression = `(() => { ${pre} return (${expression}); })()`;
-    const promise = this.evaluate(expression, session);
+    const promise = this.evaluate(expression, session, client);
     if (step.background) {
       const done = promise.then((out) => {
         if (typeof step.as === 'string') this.calls[step.as] = out;
@@ -1126,7 +1161,12 @@ class Execution {
   }
 
   async requestCheck(c, start = this.requestStart) {
-    const logs = (await this.options.fixture.log()).slice(start);
+    if (c.exit && this.exitRequestStart === undefined) return false;
+    const all = await this.options.fixture.log();
+    const logs = all.slice(
+      c.exit === 'after' ? this.exitRequestStart : start,
+      c.exit === 'before' ? this.exitRequestStart : all.length
+    );
     if (c.hops)
       return c.hops.every((_, i) =>
         logs.some((entry) => entry?.url === hop(c.hops.slice(i), c.to))
@@ -1293,6 +1333,15 @@ const inactive = (vector, target, capabilities) =>
   inapplicable(vector, target, capabilities.scope) || !supported(vector.requires, capabilities);
 
 const allSteps = (list) => list.flatMap((step) => [step, ...allSteps(step.children ?? [])]);
+const exitsClient = (vector) =>
+  [...(vector.setup ?? []), ...(vector.trigger ?? [])].some((step) => step.client === 'exit');
+const skipRow = (base, reason) => ({
+  ...base,
+  control: 'skip',
+  guarded: 'skip',
+  live: 'skip',
+  reason,
+});
 const browserContextStep = (vector, capabilities) =>
   allSteps([...vector.setup, ...vector.trigger]).some(
     (step) =>
@@ -1493,7 +1542,9 @@ async function executeRow(job, opts, made, set, slot, index, flights) {
       control: 'skip',
       guarded: 'skip',
       live: 'skip',
-      reason: missing ? `not-supported:${missing}` : 'not-applicable',
+      reason: missing
+        ? `not-supported:${missing}`
+        : skipReason(vector, target, opts.capabilities.scope),
     };
   }
   if (
@@ -1507,35 +1558,16 @@ async function executeRow(job, opts, made, set, slot, index, flights) {
       live: 'skip',
       reason: 'not-supported:browserSession',
     };
-  if (needsObserver(vector) && !clients.unguarded)
-    return {
-      ...base,
-      control: 'skip',
-      guarded: 'skip',
-      live: 'skip',
-      reason: 'not-supported:unguarded-observer',
-    };
+  const observerReason = observerSkip(vector, opts, made, clients);
+  if (observerReason) return skipRow(base, observerReason);
   const legs = {};
+  const renewed = [];
   flights.add({ flight, base, clients });
   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 {
-        legs[side] = await execution.run();
-      } catch (error) {
-        legs[side] = {
-          observed: {},
-          live: false,
-          errors: [...execution.errors, String(error.message ?? error)],
-          notes: execution.notes,
-        };
-      }
-    }
-  })();
+  const sides = runLegs({ vector, opts, clients, set, job, slot, index, legs, renewed });
   const stuck = await watch(sides, opts.rowTimeoutMs, () => view(flight, base, clients));
   for (const entry of flights) if (entry.flight === flight) flights.delete(entry);
+  await closeAll(renewed);
   if (stuck) {
     flight.abandoned = true;
     return timedOut(stuck, base, made, sides, opts);
@@ -1570,6 +1602,65 @@ async function executeRow(job, opts, made, set, slot, index, flights) {
   return row;
 }
 
+function observerSkip(vector, opts, made, clients) {
+  if (needsObserver(vector) && !clients.unguarded) return 'not-supported:unguarded-observer';
+  if (!exitsClient(vector)) return undefined;
+  if (!opts.clientFactory) return 'not-supported:clientExit';
+  if (!made.unguarded || made.unguarded === made.client) return 'not-supported:unguarded-observer';
+  return undefined;
+}
+
+async function runLegs({ vector, opts, clients, set, job, slot, index, legs, renewed }) {
+  for (const side of ['control', 'guarded']) {
+    if (clients.exited) {
+      const missing = await renew(job, opts, set, slot, clients, renewed);
+      if (missing) {
+        legs[side] = unmeasured(vector, missing);
+        continue;
+      }
+    }
+    const vars = variables(opts.targets, job.target, side, slot, index);
+    const execution = new Execution(vector, side, opts, clients, vars, set.variants[job.variant]);
+    try {
+      legs[side] = await execution.run();
+    } catch (error) {
+      legs[side] = {
+        observed: {},
+        live: false,
+        errors: [...execution.errors, String(error.message ?? error)],
+        notes: execution.notes,
+      };
+    }
+  }
+}
+
+async function closeAll(closers) {
+  for (const close of closers) await close?.();
+}
+
+async function renew(job, opts, set, slot, clients, renewed) {
+  clients.exited = false;
+  const factory = await factoryClients(opts, set, { ...job, leg: 'guarded' }, slot);
+  if (!factory.ok) return `clientFactory: ${factory.error.message}`;
+  const fresh = normalize(factory.result, opts);
+  renewed.push(fresh.close);
+  if (!fresh.unguarded || fresh.unguarded === fresh.client)
+    return 'client exit: the fresh client has no independent unguarded observer';
+  clients.client = tracked(fresh.client, clients.flight.calls, 'client');
+  clients.unguarded = tracked(fresh.unguarded, clients.flight.calls, 'unguarded');
+  return undefined;
+}
+
+function unmeasured(vector, reason) {
+  return {
+    observed: Object.fromEntries(Object.keys(vector.expected).map((name) => [name, 'incomplete'])),
+    live: 'incomplete',
+    errors: [],
+    notes: [],
+    incomplete: [reason],
+  };
+}
+
 function settleIncomplete(row, vector, base, legs) {
   const incomplete = ['control', 'guarded'].flatMap((side) =>
     (legs[side].incomplete ?? []).map((reason) => `${side} ${reason}`)
@@ -1672,11 +1763,25 @@ function factoryClients(opts, set, job, slot) {
             detachDelay: set.variants[job.variant],
             vector: job.vector,
             target: job.target,
+            ...(job.leg ? { leg: job.leg } : {}),
           })
         : opts.client)()
   );
 }
 
+function normalize(made, opts) {
+  const clients =
+    typeof made?.send === 'function'
+      ? {
+          client: made,
+          unguarded: opts.unguarded ?? made.unguarded,
+          transportVariant: made.transportVariant,
+        }
+      : (made ?? { client: undefined, unguarded: opts.unguarded });
+  clients.unguarded ??= opts.unguarded;
+  return clients;
+}
+
 function unmade(job, message) {
   const reason = `clientFactory: ${message}`;
   return {
@@ -1736,15 +1841,7 @@ async function runAll(set, options, flights) {
       }
       const made = factory.result;
       transport = (typeof made?.send === 'function' ? made : made?.client)?.transport ?? transport;
-      const clients =
-        typeof made?.send === 'function'
-          ? {
-              client: made,
-              unguarded: opts.unguarded ?? made.unguarded,
-              transportVariant: made.transportVariant,
-            }
-          : (made ?? { client: undefined, unguarded: opts.unguarded });
-      clients.unguarded ??= opts.unguarded;
+      const clients = normalize(made, opts);
       try {
         const stateful = [...job.vector.setup, ...job.vector.trigger].some((s) =>
           /Cookie|Storage|IndexedDB|CacheStorage/.test(s.cdp ?? '')

package/guard-vectors.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "setVersion": "1.14.9",
+  "setVersion": "1.15.0",
   "sources": [
     {
       "repo": "ai-ecoverse/slicc-cli",
@@ -21,6 +21,11 @@
       "repo": "cert lane",
       "ref": "guard-rows.md",
       "path": "E1-E6, B1-B7"
+    },
+    {
+      "repo": "ai-ecoverse/slicc-cdp",
+      "ref": "d85ac3c93d398cbadefda9fc8602f5bbd686b5c6",
+      "path": "test/integration/guard-native.test.mjs"
     }
   ],
   "targets": {
@@ -92,7 +97,8 @@
     "browserContexts": "Target.createBrowserContext and Target.disposeBrowserContext",
     "extensionWorld": "a browser hosting a foreign content-script extension isolated world on the ordinary fixture page",
     "discovery": "session-less Target.setDiscoverTargets and targetCreated/targetInfoChanged delivery; absent transports must emit neither event",
-    "chromeUrlsAttach": "attaching to and driving chrome:// pages, which CDP over a DevTools port can and chrome.debugger can't"
+    "chromeUrlsAttach": "attaching to and driving chrome:// pages, which CDP over a DevTools port can and chrome.debugger can't",
+    "clientExit": "closing the guarded client mid-row: the client has close(), the clientFactory makes a fresh guarded client for the next leg, and an independent unguarded observer outlives it"
   },
   "placeholders": {
     "target": "the target's origin; {plain} on the control",
@@ -9984,6 +9990,172 @@
         "observer": "client"
       }
     },
+    {
+      "id": "C5.script",
+      "family": "C",
+      "kind": "cdp",
+      "scope": "any",
+      "setup": [
+        {
+          "text": "a plain page whose own Fetch.enable pauses every request at both stages, and fulfils the probe's script with a forged one"
+        },
+        {
+          "page": "tab",
+          "url": "{ordinary}/doc?n=fetcher-{tag}"
+        },
+        {
+          "cdp": "Fetch.enable",
+          "params": {
+            "patterns": [
+              {
+                "urlPattern": "*",
+                "requestStage": "Request"
+              },
+              {
+                "urlPattern": "*",
+                "requestStage": "Response"
+              }
+            ]
+          }
+        },
+        {
+          "answer": {
+            "url": "{target}/script?n={tag}",
+            "stage": "Request",
+            "cdp": "Fetch.fulfillRequest",
+            "params": {
+              "responseCode": 200,
+              "responseHeaders": [
+                {
+                  "name": "content-type",
+                  "value": "text/javascript"
+                },
+                {
+                  "name": "access-control-allow-origin",
+                  "value": "*"
+                }
+              ],
+              "body": "Z2xvYmFsVGhpcy52ZWN0b3JTY3JpcHQ9J2Z1bGZpbGxlZCc="
+            }
+          }
+        }
+      ],
+      "trigger": [
+        {
+          "page": "script",
+          "url": "{target}/script?n={tag}",
+          "as": "body"
+        }
+      ],
+      "targets": ["seven", "vault", "vault-x", "apex"],
+      "observe": {
+        "seen": {
+          "means": "a Fetch.requestPaused for {target}/script?n={tag} reached the client",
+          "check": {
+            "event": "Fetch.requestPaused",
+            "where": {
+              "params": {
+                "request": {
+                  "url": "{target}/script?n={tag}"
+                }
+              }
+            },
+            "observer": "client"
+          }
+        },
+        "headers": {
+          "means": "the Fetch.requestPaused for {target}/script?n={tag} carried its request headers as an object with User-Agent",
+          "check": {
+            "event": "Fetch.requestPaused",
+            "where": {
+              "params": {
+                "request": {
+                  "url": "{target}/script?n={tag}",
+                  "headers": {
+                    "$regex": "^\\{.*\"[Uu]ser-[Aa]gent\":"
+                  }
+                }
+              }
+            },
+            "observer": "client"
+          }
+        },
+        "fulfilled": {
+          "means": "body is 'fulfilled'",
+          "check": {
+            "result": "body",
+            "path": "result.result.value",
+            "equals": "fulfilled",
+            "observer": "client"
+          }
+        },
+        "answered": {
+          "means": "body is 'real-{tag}', the stand-in's own script",
+          "check": {
+            "result": "body",
+            "path": "result.result.value",
+            "equals": "real-{tag}",
+            "observer": "client"
+          }
+        }
+      },
+      "live": "the runner's own CDP sees {target}'s document load (title, marker or URL), or the guard returned its refusal for a refusable step",
+      "control": {
+        "origin": "ordinary",
+        "via": "guard",
+        "expected": {
+          "seen": true,
+          "headers": true,
+          "fulfilled": true,
+          "answered": false
+        }
+      },
+      "expected": {
+        "seen": false,
+        "headers": false,
+        "fulfilled": false,
+        "answered": true
+      },
+      "liveCheck": {
+        "any": [
+          {
+            "loaded": "{target}/script?n={tag}",
+            "observer": "fixture"
+          },
+          {
+            "all": [
+              {
+                "pre": "{target}/script?n={tag}",
+                "observer": "fixture"
+              },
+              {
+                "any": [
+                  {
+                    "blocked": {
+                      "url": "{target}/script?n={tag}",
+                      "session": "page",
+                      "frame": false
+                    },
+                    "observer": "client"
+                  },
+                  {
+                    "blocked": {
+                      "url": "{target}/script?n={tag}",
+                      "session": "page",
+                      "frame": false
+                    },
+                    "observer": "unguarded"
+                  }
+                ],
+                "observer": "client"
+              }
+            ],
+            "observer": "client"
+          }
+        ],
+        "observer": "client"
+      }
+    },
     {
       "id": "C5.auth",
       "family": "C",
@@ -17809,6 +17981,209 @@
         ],
         "observer": "client"
       }
+    },
+    {
+      "id": "X1.after-exit",
+      "family": "X",
+      "kind": "cdp",
+      "scope": "any",
+      "requires": ["clientExit"],
+      "setup": [
+        {
+          "text": "a plain page whose client registers an init script, an x-probe header and Fetch.enable '*' that fulfils the destination with a forged body, then loads a trigger page whose navigation into {target} is pending when the client exits"
+        },
+        {
+          "page": "tab",
+          "url": "{ordinary}/doc?n=exit-{tag}"
+        },
+        {
+          "cdp": "Page.addScriptToEvaluateOnNewDocument",
+          "params": {
+            "source": "{beacon}"
+          }
+        },
+        {
+          "cdp": "Network.setExtraHTTPHeaders",
+          "params": {
+            "headers": {
+              "x-probe": "{tag}"
+            }
+          }
+        },
+        {
+          "cdp": "Fetch.enable",
+          "params": {
+            "patterns": [
+              {
+                "urlPattern": "*"
+              }
+            ]
+          }
+        },
+        {
+          "answer": {
+            "url": "{target}/canary/{tag}",
+            "stage": "Request",
+            "cdp": "Fetch.fulfillRequest",
+            "params": {
+              "responseCode": 200,
+              "responseHeaders": [
+                {
+                  "name": "content-type",
+                  "value": "text/html"
+                }
+              ],
+              "body": "PCFkb2N0eXBlIGh0bWw+PHRpdGxlPmZvcmdlZDwvdGl0bGU+PHA+RlVMRklMTEVEPC9wPg=="
+            }
+          }
+        }
+      ],
+      "trigger": [
+        {
+          "page": "navigate",
+          "url": "{ordinary}/page?k=href&to={target}/canary/{tag}&tag={tag}"
+        },
+        {
+          "settle": {
+            "beacon": "{ordinary}",
+            "required": true
+          }
+        },
+        {
+          "client": "exit"
+        },
+        {
+          "page": "eval",
+          "expression": "go()"
+        },
+        {
+          "settle": {
+            "title": "canary",
+            "ms": 5000
+          }
+        }
+      ],
+      "targets": ["seven", "vault"],
+      "observe": {
+        "instrumented": {
+          "means": "the client's init script sent its beacon from {ordinary} before the exit",
+          "check": {
+            "beacon": "{ordinary}",
+            "exit": "before",
+            "observer": "fixture"
+          }
+        },
+        "headed": {
+          "means": "the trigger page's request carried the client's x-probe header before the exit",
+          "check": {
+            "header": "x-probe",
+            "on": "/page",
+            "exit": "before",
+            "observer": "fixture"
+          }
+        },
+        "intercepted": {
+          "means": "a Fetch.requestPaused for the trigger page reached the client before the exit",
+          "check": {
+            "event": "Fetch.requestPaused",
+            "where": {
+              "params": {
+                "request": {
+                  "url": "{ordinary}/page?k=href&to={target}/canary/{tag}&tag={tag}"
+                }
+              }
+            },
+            "observer": "client"
+          }
+        },
+        "served": {
+          "means": "the stand-in served {target}/canary/{tag} after the exit",
+          "check": {
+            "served": "{target}/canary/{tag}",
+            "exit": "after",
+            "observer": "fixture"
+          }
+        },
+        "document": {
+          "means": "the unguarded observer reads {target}'s real document, title 'canary'",
+          "check": {
+            "title": "canary",
+            "via": "unguarded",
+            "observer": "unguarded"
+          }
+        },
+        "forged": {
+          "means": "the unguarded observer reads the client's forged FULFILLED body",
+          "check": {
+            "expression": "document.body ? document.body.innerText.includes('FULFILLED') : false",
+            "equals": true,
+            "via": "unguarded",
+            "observer": "unguarded"
+          }
+        },
+        "scripted": {
+          "means": "the client's init script sent a beacon from {target} after the exit",
+          "check": {
+            "beacon": "{target}",
+            "exit": "after",
+            "observer": "fixture"
+          }
+        },
+        "probed": {
+          "means": "a request for {target}/canary/{tag} carried the client's x-probe header after the exit",
+          "check": {
+            "header": "x-probe",
+            "on": "{target}/canary/{tag}",
+            "exit": "after",
+            "observer": "fixture"
+          }
+        },
+        "paused": {
+          "means": "a Fetch.requestPaused for {target}/canary/{tag} reached the client",
+          "check": {
+            "event": "Fetch.requestPaused",
+            "where": {
+              "params": {
+                "request": {
+                  "url": "{target}/canary/{tag}"
+                }
+              }
+            },
+            "observer": "client"
+          }
+        }
+      },
+      "live": "the stand-in serves {target}'s document after the client exits",
+      "control": {
+        "origin": "ordinary",
+        "via": "guard",
+        "expected": {
+          "instrumented": true,
+          "headed": true,
+          "intercepted": true,
+          "served": true,
+          "document": true,
+          "forged": false,
+          "scripted": false,
+          "probed": false,
+          "paused": false
+        }
+      },
+      "expected": {
+        "instrumented": true,
+        "headed": true,
+        "intercepted": true,
+        "served": true,
+        "document": true,
+        "forged": false,
+        "scripted": false,
+        "probed": false,
+        "paused": false
+      },
+      "liveCheck": {
+        "loaded": "{target}/canary/{tag}",
+        "observer": "fixture"
+      }
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-browsers",
-  "version": "1.14.9",
+  "version": "1.15.0",
   "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 test/integration/guard-redirect-carrier.test.mjs test/integration/dist-tag.test.mjs test/integration/guard-incomplete.test.mjs test/integration/guard-stall.test.mjs test/integration/guard-forged.test.mjs && go test -race -count=1 ./test/integration/... && cargo test --all-features",
+    "test": "npm run validate && node --test test/integration/self-contained.test.mjs test/integration/browser-runner.test.mjs test/integration/fixture-client.test.mjs test/integration/git-retry.test.mjs test/integration/guard-redirect-carrier.test.mjs test/integration/dist-tag.test.mjs test/integration/guard-incomplete.test.mjs test/integration/guard-stall.test.mjs test/integration/guard-forged.test.mjs test/integration/guard-exit-steps.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/guard-parallel.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/guard-client-exit.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",

package/schema/guard-vectors.schema.json

@@ -87,7 +87,8 @@
         "browserContexts",
         "chromeUrlsAttach",
         "extensionWorld",
-        "discovery"
+        "discovery",
+        "clientExit"
       ],
       "properties": {
         "autoAttach": {
@@ -107,7 +108,8 @@
         "chromeUrlsAttach": {
           "type": "string",
           "minLength": 1
-        }
+        },
+        "clientExit": { "type": "string", "minLength": 1 }
       }
     },
     "placeholders": {
@@ -136,7 +138,8 @@
         "browserContexts",
         "chromeUrlsAttach",
         "extensionWorld",
-        "discovery"
+        "discovery",
+        "clientExit"
       ]
     },
     "requires": {
@@ -233,10 +236,10 @@
       "properties": {
         "id": {
           "type": "string",
-          "pattern": "^[CEB][1-9](\\.[A-Za-z0-9-]+)*$"
+          "pattern": "^[CEBX][1-9](\\.[A-Za-z0-9-]+)*$"
         },
         "family": {
-          "enum": ["C", "E", "B"]
+          "enum": ["C", "E", "B", "X"]
         },
         "kind": {
           "enum": ["cdp", "text"]
@@ -482,6 +485,14 @@
             }
           }
         },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["client"],
+          "properties": {
+            "client": { "const": "exit" }
+          }
+        },
         {
           "type": "object",
           "additionalProperties": false,
@@ -561,6 +572,7 @@
                 "fetch",
                 "xhr",
                 "image",
+                "script",
                 "eval"
               ]
             },
@@ -805,6 +817,9 @@
             },
             "observer": {
               "const": "fixture"
+            },
+            "exit": {
+              "enum": ["before", "after"]
             }
           }
         },
@@ -824,6 +839,9 @@
             },
             "tagged": {
               "type": "boolean"
+            },
+            "exit": {
+              "enum": ["before", "after"]
             }
           }
         },
@@ -843,6 +861,9 @@
             },
             "observer": {
               "const": "fixture"
+            },
+            "exit": {
+              "enum": ["before", "after"]
             }
           }
         },