@ai-ecoverse/slicc-browsers 1.16.2 → 1.17.0

package/README.md

@@ -189,6 +189,8 @@ Every CDP guard runs the vectors in `guard-vectors.json` (schema `schema/guard-v
 
 `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?k=href&tag={tag}&to={target}/canary/{tag}` 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`, matched up to `&to=`, so a guard that redacts the embedded protected URL to its origin still matches: 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.
 
+`C4.iframe-preattach.blank` and `C4.iframe-preattach.srcdoc` read a protected frame's same-process child that committed before the client attached. The unguarded observer opens `<from>/framed` around `{target}/nest?n=<tag>&kind=blank` or `kind=srcdoc`: the protected frame holds an `about:blank` child that it fills, or an `about:srcdoc` child, each named `frame-marker-<tag>` and showing that marker, and then moves itself with `history.replaceState` to `/nest/path-secret-<tag>?query-secret=<tag>#fragment-secret-<tag>`. `from` is `{ordinary-same-site}` on the guarded leg, so both frames share the page's process under site isolation, and `{plain}` on the control. The `.shared` rows open the page from `{ordinary}` on both legs and require `siteIsolationOff`; a transport without it reports them as `skip` with `not-supported:siteIsolationOff`. The observer must find the child in the page's own frame tree and pierced document, and must see the marker or the secret through every read. Then the client attaches to the settled page and makes the same reads: `Page.getFrameTree`, `Accessibility.getFullAXTree` with the protected frame's and the child's `frameId`, `Accessibility.getPartialAXTree` of the marker element's `backendNodeId` with `fetchRelatives`, `DOM.getDocument` with `depth: -1` and `pierce: true`, `DOM.describeNode` of the child's document and `DOM.getOuterHTML` of the marker element, and `DOMSnapshot.captureSnapshot`. Each `<read>Shown` holds when a reply carries the marker or the secret path, query or fragment, and `eventsShown` when an event on the client's session does. The guarded leg expects all of them false: a refusal, an error or origin-only data passes, and a refused attach refuses every read. The control runs unguarded and expects every read to show the content. Missing evidence is `incomplete`, with `frame-read: <reason>`: no same-process child within 5000 ms (scaled by `settleScale`), an observer read that doesn't show the content (that field reads `incomplete`), a client read or attach that was never answered (an error that says `timed out` or `closed`), or a control attach without a session.
+
 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.
 
 The integration launcher loads shared-web 1.25.2’s harness extension exactly once through `Extensions.loadUnpacked` (`ankmbodmgimjemnojmeddfcdlbocolob`), whose content script runs on HTTP(S) pages. shared-web 1.25.2 also loads it by default in its own harness. A transport unable to host a foreign content-script extension omits `extensionWorld` and reports `not-supported:extensionWorld`; an advertised capability with no observed world fails, rather than silently skipping.
@@ -218,7 +220,7 @@ 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`. `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.
+- `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. `siteIsolationOff` means the browser runs without site isolation, so a cross-site iframe shares its parent's process.
 - `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:
@@ -264,6 +266,7 @@ Popups are observed by `Target.targetCreated` with the opener's `openerId`, or b
 - `/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;
+- `/nest?n=&kind=` (and any path under `/nest`): the `C4.iframe-preattach` frame, with its `about:blank` or `about:srcdoc` child;
 - `/img`: a 1×1 PNG;
 - `/auth`: Basic `u`:`p`, then `authed`;
 - `/rewritten` (title `rewritten`);
@@ -280,6 +283,8 @@ Popups are observed by `Target.targetCreated` with the opener's `openerId`, or b
 
 For remote/page harnesses, `fixtureClient(base)` is exported by `./guard-runner` and `./fixture-client`, or `run(set, { fixtureBase: base, ... })` constructs it. The bundled server serves CORS-safe `GET /log?since=N` as `{ from: N, entries: [...] }`, with an append-only history unaffected by `fixture.reset()`, and `POST /redirect` with a JSON-encoded string body (a simple text/plain request, without a preflight). Control requests do not appear in the log. Registration descriptors are `{ path, host?, search?, to?, code?, body, remove? }`: `path` starts with `/`, `host` selects the callback hostname, `search` distinguishes query-bearing callbacks, `to` creates a redirect with the four Location/Content-Location/Refresh/Link headers, `code` defaults to 302, an omitted `to` serves the callback body, and `remove: true` unregisters it. The bundled endpoint returns 204; custom servers must acknowledge with a successful status and actually serve the registered routes. Custom fixtures may instead supply an async `fixture.redirectSecret` hook directly; a separate log/control server can implement the same `GET /log` and `POST /redirect` contract. A Node harness using browser-only DNS aliases should pass a reachable `fixtureBase` or its direct hook.
 
+`{ "frameRead": "blank" | "srcdoc", "from", "as": "frames", "on"?, "requires"? }` runs the `C4.iframe-preattach` compound probe: the observer's page and reads, then the client's attach and reads, with boolean evidence for ordinary `result` checks.
+
 `{ "unparseable": true, "as": "unparseable" }` runs the C8 malformed-URL compound probe on the current ordinary page: independent browser ground truth, raw/canonical destination commands, discovery/attach and cookie checks. Boolean evidence is consumed by ordinary `result` checks, with native Chrome outcomes retained in its diagnostics.
 
 **The control rule.** Every vector has a control on an ordinary origin: the same setup and trigger against an unprotected origin must succeed. A missing or failing control fails the id. With `via: "guard"`, the control runs through the guard. With `via: "unguarded"`, the runner runs setup and trigger through its own CDP against the ordinary origin and against the protected stand-in, and both must show the effect. The runner reports the control's transport as `via`.
@@ -404,13 +409,13 @@ every alternative of an `any`, or a required (`all`, `not` or plain) check, need
 selects one variant or an array; omission selects all. `parallel` defaults to 1.
 With the `browserContexts` capability each leg runs in its own browser context. A `Target.createBrowserContext` that fails with a timeout is retried once, and the row's `notes` records it; any other failure fails the row.
 
-Every target created by the runner’s own unguarded observer uses `Target.createTarget` with `newWindow: true`, then verifies through `Target.getTargetInfo` that `openerId` is absent. A supplied opener or missing target evidence fails and cleans up that target (in the protected-error-page probe, the row is `incomplete` instead), rather than inheriting the active client tab (which could be seven). This includes ordinary control setup, storage canaries, protected-error history seeds and the malformed-URL observer. The row notes record `newWindow=true, openerId absent`. Intentional guarded-client creation commands and popup/opener tests keep their original parameters.
+Every target created by the runner’s own unguarded observer uses `Target.createTarget` with `newWindow: true`, then verifies through `Target.getTargetInfo` that `openerId` is absent. A supplied opener or missing target evidence fails and cleans up that target (in the protected-error-page probe, the row is `incomplete` instead), rather than inheriting the active client tab (which could be seven). This includes ordinary control setup, storage canaries, protected-error history seeds, the frame-read page and the malformed-URL observer. The row notes record `newWindow=true, openerId absent`. Intentional guarded-client creation commands and popup/opener tests keep their original parameters.
 
 `settleScale` (default 1) multiplies the bounds of waits for events the leg expects to happen: settles (beacon, served, title and load) on the control leg and `required` settles on either leg, `paused` on the control leg, page and child loads, the wait for a background step's `as` result (`<as> did not complete within <ms>ms`), the wait for the pre-action beacons, the C9 control's `Debugger.paused`, and the wait for an observation the leg expects to be `true`. Adopters on slow hosts can set 3 or 4. Every wait polls and returns as soon as its event arrives, so a larger bound only costs time when something is really missing, and each timeout error names the bound it used. An observation read from the fixture (`observer: "fixture"`, such as a beacon or a served request) that the leg expects to be `true` is polled for up to 5000 ms (scaled) instead of read once. One that the leg expects to be `false` is still read once.
 
 `refusalScale` (default 1) multiplies the bounds of waits for what the guarded leg expects to be absent, the beacon, request, title or navigation that the guard should block: settles that are not `required`, and `paused`, on the guarded leg. Such a wait runs to its full bound whenever the guard works, so `settleScale` leaves it alone. The trade-off: a larger `refusalScale` gives more sensitivity to a leak that arrives late on a slow host, because the observations after the wait see it, at the cost of that much more time per guarded row. Adopters should keep `refusalScale` at 1 or higher, never below 1; the runner refuses a `refusalScale` below 1 with `refusalScale must be a number of at least 1`.
 
-**Incomplete.** A probe that returns `incomplete` (only `errorPage` and `redirectSecret` steps) records the reason in the row's `incomplete` as `<leg> <probe>: <reason>`. Its unmeasured observations read `"incomplete"`, and so does guarded liveness when the probe never measured it. A leg whose measured observations all match is then `incomplete`, never `pass`, and `live` is `incomplete` when only its evidence is missing; a measured mismatch still makes the leg `fail`, and any row error still fails both legs. `summary()` counts `incomplete` per leg, returns the number of rows with any `incomplete` status as `incomplete`, appends `incomplete <n>` to `line`, and never passes such a run. A leg that throws keeps the errors it recorded before the throw.
+**Incomplete.** A probe that returns `incomplete` (only `errorPage`, `redirectSecret` and `frameRead` 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.
 
@@ -517,7 +522,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 and `X1.after-exit`, whose plain client leaves nothing behind when it exits, 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. Rows that require `siteIsolationOff` run in one more Chromium launched without site isolation. 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/fixture-server.mjs

@@ -29,6 +29,17 @@ function trigger(p) {
   return `<p>trigger</p><button onclick="go()">Go</button>${frame}<script>const to=${JSON.stringify(to)};function go(){const k=${JSON.stringify(kind)};if(k==='href'||k==='deferred')location.href=to;if(k==='replace')location.replace(to);if(k==='popup')window.open(to);if(k==='form'){const u=new URL(to);const f=document.createElement('form');f.action=u.origin+u.pathname;for(const [name,value] of u.searchParams){const i=document.createElement('input');i.type='hidden';i.name=name;i.value=value;f.append(i);}document.body.append(f);f.submit();}return 'went';}${kind === 'deferred' ? `setTimeout(go,${Number(p.get('defer') ?? 3000)});` : ''}</script>`;
 }
 
+function nest(p) {
+  const n = p.get('n') ?? '';
+  const marker = escape(`frame-marker-${n}`);
+  const child =
+    p.get('kind') === 'srcdoc'
+      ? `<iframe name="${marker}" srcdoc="${escape(`<p>${marker}</p>`)}"></iframe>`
+      : `<iframe name="${marker}"></iframe><script>const f=document.querySelector('iframe');const p=f.contentDocument.createElement('p');p.textContent=f.name;f.contentDocument.body.append(p)</script>`;
+  const tag = JSON.stringify(n).replaceAll('<', '\\u003c');
+  return `<p>${marker}</p>${child}<script>const n=${tag};history.replaceState(null,'',location.pathname+'/path-'+'secret-'+n+'?query-'+'secret='+n+'#fragment-'+'secret-'+n)</script>`;
+}
+
 function route(req, url, send, html, redirects) {
   const secret =
     redirects.get(`${url.hostname}${url.pathname}${url.search ?? ''}`) ??
@@ -95,6 +106,7 @@ function route(req, url, send, html, redirects) {
       'canary',
       `<p data-canary="${escape(p.get('value') ?? 'planted')}">canary-marker ${escape(url.host)}</p>`
     );
+  if (url.pathname.startsWith('/nest')) return html('nest', nest(p));
   const handler = routes[url.pathname];
   if (handler) return handler();
   return send(404, 'missing', 'text/plain');

package/frame-read.mjs

@@ -0,0 +1,182 @@
+import { outcome, parseURL, waitFor } from './guard-driver.mjs';
+import { createObserverTarget } from './observer-target.mjs';
+
+export const frameReads = ['frameTree', 'axFull', 'axPartial', 'document', 'node', 'snapshot'];
+
+const unanswered = (out) => !out.ok && /timed out|closed/i.test(out.error?.message ?? '');
+
+export function frameReadCalls(layout) {
+  return {
+    frameTree: [['Page.getFrameTree', {}]],
+    axFull: [
+      ['Accessibility.getFullAXTree', { frameId: layout.frame }],
+      ['Accessibility.getFullAXTree', { frameId: layout.child }],
+    ],
+    axPartial: [
+      ['Accessibility.getPartialAXTree', { backendNodeId: layout.marker, fetchRelatives: true }],
+    ],
+    document: [['DOM.getDocument', { depth: -1, pierce: true }]],
+    node: [
+      ['DOM.describeNode', { backendNodeId: layout.childDocument, depth: -1, pierce: true }],
+      ['DOM.getOuterHTML', { backendNodeId: layout.marker }],
+    ],
+    snapshot: [['DOMSnapshot.captureSnapshot', { computedStyles: [] }]],
+  };
+}
+
+export function frameNeedles(tag) {
+  return [
+    `frame-marker-${tag}`,
+    `path-secret-${tag}`,
+    `query-secret=${tag}`,
+    `fragment-secret-${tag}`,
+  ];
+}
+
+const shows = (value, needles) => {
+  const text = JSON.stringify(value) ?? '';
+  return needles.some((needle) => text.includes(needle));
+};
+
+function find(node, test) {
+  if (!node) return undefined;
+  if (test(node)) return node;
+  for (const next of [
+    ...(node.children ?? []),
+    node.contentDocument,
+    ...(node.shadowRoots ?? []),
+  ]) {
+    const hit = find(next, test);
+    if (hit) return hit;
+  }
+  return undefined;
+}
+
+export async function frameLayout(reader, session, { framed, marker, kind }) {
+  const { frameTree } = await reader.send('Page.getFrameTree', {}, session);
+  const host = (frameTree.childFrames ?? []).find((node) => {
+    const url = parseURL(node.frame.url);
+    return url?.origin === parseURL(framed)?.origin && url.pathname.startsWith('/nest');
+  });
+  const child = (host?.childFrames ?? []).find((node) => node.frame.name === marker);
+  if (!child || child.frame.url !== kind) return undefined;
+  const { root } = await reader.send('DOM.getDocument', { depth: -1, pierce: true }, session);
+  const owner = find(
+    root,
+    (node) =>
+      node.nodeName === 'IFRAME' &&
+      node.frameId === child.frame.id &&
+      (node.attributes ?? []).includes(marker)
+  );
+  const text = find(
+    owner?.contentDocument,
+    (node) => node.nodeType === 3 && node.nodeValue === marker
+  );
+  const paragraph = find(owner?.contentDocument, (node) => (node.children ?? []).includes(text));
+  if (!paragraph) return undefined;
+  return {
+    frame: host.frame.id,
+    child: child.frame.id,
+    childDocument: owner.contentDocument.backendNodeId,
+    marker: paragraph.backendNodeId,
+  };
+}
+
+async function read(client, session, calls, needles) {
+  let shown = false;
+  let silent = false;
+  for (const [method, params] of calls) {
+    const out = await outcome(client.send(method, params, session));
+    shown ||= shows(out, needles);
+    silent ||= unanswered(out);
+  }
+  return shown || (silent ? 'incomplete' : false);
+}
+
+async function enable(client, session) {
+  for (const method of ['Page.enable', 'DOM.enable', 'Accessibility.enable'])
+    await outcome(client.send(method, {}, session));
+}
+
+export async function frameRead({
+  client,
+  reader,
+  top,
+  framed,
+  tag,
+  mode,
+  side,
+  notes = [],
+  budget = 5000,
+}) {
+  const kind = mode === 'srcdoc' ? 'about:srcdoc' : 'about:blank';
+  const marker = `frame-marker-${tag}`;
+  const needles = frameNeedles(tag);
+  const nest = `${framed}/nest?n=${encodeURIComponent(tag)}&kind=${mode}`;
+  const page = `${top}/framed?tag=${encodeURIComponent(tag)}&url=${encodeURIComponent(nest)}`;
+  const result = {};
+  const missing = [];
+  const done = () =>
+    missing.length ? { ...result, incomplete: `frame-read: ${missing.join('; ')}` } : result;
+  const opened = await outcome(
+    createObserverTarget(reader, { url: 'about:blank', background: true }, notes)
+  );
+  if (!opened.ok)
+    return { incomplete: `frame-read: observer setup failed: ${opened.error.message}` };
+  const { targetId } = opened.result;
+  let session;
+  try {
+    const observer = (await reader.send('Target.attachToTarget', { targetId, flatten: true }))
+      .sessionId;
+    await enable(reader, observer);
+    await reader.send('Page.navigate', { url: page }, observer);
+    let layout;
+    await waitFor(async () => {
+      const out = await outcome(frameLayout(reader, observer, { framed, marker, kind }));
+      layout = out.result;
+      return Boolean(layout);
+    }, budget);
+    if (!layout) {
+      await outcome(reader.send('Target.detachFromTarget', { sessionId: observer }));
+      return {
+        incomplete: `frame-read: no ${kind} child of ${framed} in the page's renderer within ${budget}ms`,
+      };
+    }
+    result.live = true;
+    const calls = frameReadCalls(layout);
+    const proven = {};
+    for (const name of frameReads) {
+      proven[name] = (await read(reader, observer, calls[name], needles)) === true;
+      if (!proven[name]) missing.push(`observer ${name} did not show the frame's content`);
+    }
+    await outcome(reader.send('Target.detachFromTarget', { sessionId: observer }));
+    const start = client.events.length;
+    const attached = await outcome(
+      client.send('Target.attachToTarget', { targetId, flatten: true })
+    );
+    session = attached.result?.sessionId;
+    result.attached = Boolean(session);
+    if (!session && (unanswered(attached) || side === 'control')) {
+      missing.push(`attach ${attached.error?.message ?? 'returned no session'}`);
+      return done();
+    }
+    if (session) await enable(client, session);
+    for (const name of frameReads) {
+      const value = session ? await read(client, session, calls[name], needles) : false;
+      if (value === 'incomplete') missing.push(`${name} unanswered`);
+      result[`${name}Shown`] = value === true || proven[name] ? value : 'incomplete';
+    }
+    result.eventsShown = shows(
+      client.events
+        .slice(start)
+        .filter(
+          (event) => session && (event.sessionId === session || event.params?.sessionId === session)
+        ),
+      needles
+    );
+    return done();
+  } finally {
+    if (session) await outcome(client.send('Target.detachFromTarget', { sessionId: session }));
+    await outcome(reader.send('Target.closeTarget', { targetId }));
+  }
+}

package/guard-runner.mjs

@@ -3,6 +3,7 @@ import { fixtureClient, prepareFixture } from './fixture-client.mjs';
 export { fixtureClient };
 
 import { extensionWorld } from './extension-world.mjs';
+import { frameRead } from './frame-read.mjs';
 import {
   beacon,
   canary,
@@ -669,12 +670,20 @@ class Execution {
       );
     if (step.extensionWorld && out.result?.incomplete)
       this.errors.push(`extensionWorld ${step.extensionWorld}: ${out.result.incomplete}`);
-    const probe = ['redirectSecret', 'unparseable', 'errorPage', 'extensionWorld'].find(
-      (key) => step[key]
-    );
+    const probe = [
+      'redirectSecret',
+      'unparseable',
+      'errorPage',
+      'extensionWorld',
+      'frameRead',
+    ].find((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)
+    if (
+      ['errorPage', 'redirectSecret', 'frameRead'].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 });
@@ -767,6 +776,20 @@ class Execution {
           budget: this.bound(5000),
         })
       );
+    if (step.frameRead)
+      return outcome(
+        frameRead({
+          client: this.client,
+          reader: this.reader,
+          top: step.from,
+          framed: this.vars.target,
+          tag: this.vars.tag,
+          mode: step.frameRead,
+          side: this.side,
+          notes: this.notes,
+          budget: this.bound(5000),
+        })
+      );
     if (step.unparseable)
       return outcome(
         unparseableURLs({

package/guard-vectors.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "setVersion": "1.16.2",
+  "setVersion": "1.17.0",
   "sources": [
     {
       "repo": "ai-ecoverse/slicc-cli",
@@ -98,7 +98,8 @@
     "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",
-    "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"
+    "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",
+    "siteIsolationOff": "the browser runs without site isolation, so a cross-site iframe shares its parent's process"
   },
   "placeholders": {
     "target": "the target's origin; {plain} on the control",
@@ -13042,6 +13043,524 @@
         "observer": "client"
       }
     },
+    {
+      "id": "C4.iframe-preattach.blank",
+      "family": "C",
+      "kind": "cdp",
+      "scope": "any",
+      "defaultContext": true,
+      "setup": [
+        {
+          "page": "tab",
+          "url": "{ordinary}/blank"
+        }
+      ],
+      "trigger": [
+        {
+          "frameRead": "blank",
+          "from": "{ordinary-same-site}",
+          "on": "guarded",
+          "as": "frames"
+        },
+        {
+          "frameRead": "blank",
+          "from": "{plain}",
+          "on": "control",
+          "as": "frames"
+        }
+      ],
+      "targets": ["seven"],
+      "observe": {
+        "live": {
+          "means": "the observer saw the protected frame's about:blank child and its marker in the page's process",
+          "check": {
+            "result": "frames",
+            "path": "result.live",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "frameTreeShown": {
+          "means": "the client's Page.getFrameTree showed the child's marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.frameTreeShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "axFullShown": {
+          "means": "the client's frame-scoped Accessibility.getFullAXTree showed the marker",
+          "check": {
+            "result": "frames",
+            "path": "result.axFullShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "axPartialShown": {
+          "means": "the client's Accessibility.getPartialAXTree of the marker node showed the marker",
+          "check": {
+            "result": "frames",
+            "path": "result.axPartialShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "documentShown": {
+          "means": "the client's pierced DOM.getDocument showed the marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.documentShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "nodeShown": {
+          "means": "the client's DOM.describeNode and DOM.getOuterHTML of the child's nodes showed the marker",
+          "check": {
+            "result": "frames",
+            "path": "result.nodeShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "snapshotShown": {
+          "means": "the client's DOMSnapshot.captureSnapshot showed the marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.snapshotShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "eventsShown": {
+          "means": "an event on the client's session showed the marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.eventsShown",
+            "equals": true,
+            "observer": "client"
+          }
+        }
+      },
+      "live": "the independent observer, before the client attaches, sees {target}'s about:blank child frame and its marker in the page's own process through every read",
+      "liveCheck": {
+        "result": "frames",
+        "path": "result.live",
+        "equals": true,
+        "observer": "client"
+      },
+      "control": {
+        "origin": "ordinary",
+        "via": "unguarded",
+        "expected": {
+          "live": true,
+          "frameTreeShown": true,
+          "axFullShown": true,
+          "axPartialShown": true,
+          "documentShown": true,
+          "nodeShown": true,
+          "snapshotShown": true
+        }
+      },
+      "expected": {
+        "live": true,
+        "frameTreeShown": false,
+        "axFullShown": false,
+        "axPartialShown": false,
+        "documentShown": false,
+        "nodeShown": false,
+        "snapshotShown": false,
+        "eventsShown": false
+      }
+    },
+    {
+      "id": "C4.iframe-preattach.srcdoc",
+      "family": "C",
+      "kind": "cdp",
+      "scope": "any",
+      "defaultContext": true,
+      "setup": [
+        {
+          "page": "tab",
+          "url": "{ordinary}/blank"
+        }
+      ],
+      "trigger": [
+        {
+          "frameRead": "srcdoc",
+          "from": "{ordinary-same-site}",
+          "on": "guarded",
+          "as": "frames"
+        },
+        {
+          "frameRead": "srcdoc",
+          "from": "{plain}",
+          "on": "control",
+          "as": "frames"
+        }
+      ],
+      "targets": ["seven"],
+      "observe": {
+        "live": {
+          "means": "the observer saw the protected frame's about:srcdoc child and its marker in the page's process",
+          "check": {
+            "result": "frames",
+            "path": "result.live",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "frameTreeShown": {
+          "means": "the client's Page.getFrameTree showed the child's marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.frameTreeShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "axFullShown": {
+          "means": "the client's frame-scoped Accessibility.getFullAXTree showed the marker",
+          "check": {
+            "result": "frames",
+            "path": "result.axFullShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "axPartialShown": {
+          "means": "the client's Accessibility.getPartialAXTree of the marker node showed the marker",
+          "check": {
+            "result": "frames",
+            "path": "result.axPartialShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "documentShown": {
+          "means": "the client's pierced DOM.getDocument showed the marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.documentShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "nodeShown": {
+          "means": "the client's DOM.describeNode and DOM.getOuterHTML of the child's nodes showed the marker",
+          "check": {
+            "result": "frames",
+            "path": "result.nodeShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "snapshotShown": {
+          "means": "the client's DOMSnapshot.captureSnapshot showed the marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.snapshotShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "eventsShown": {
+          "means": "an event on the client's session showed the marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.eventsShown",
+            "equals": true,
+            "observer": "client"
+          }
+        }
+      },
+      "live": "the independent observer, before the client attaches, sees {target}'s about:srcdoc child frame and its marker in the page's own process through every read",
+      "liveCheck": {
+        "result": "frames",
+        "path": "result.live",
+        "equals": true,
+        "observer": "client"
+      },
+      "control": {
+        "origin": "ordinary",
+        "via": "unguarded",
+        "expected": {
+          "live": true,
+          "frameTreeShown": true,
+          "axFullShown": true,
+          "axPartialShown": true,
+          "documentShown": true,
+          "nodeShown": true,
+          "snapshotShown": true
+        }
+      },
+      "expected": {
+        "live": true,
+        "frameTreeShown": false,
+        "axFullShown": false,
+        "axPartialShown": false,
+        "documentShown": false,
+        "nodeShown": false,
+        "snapshotShown": false,
+        "eventsShown": false
+      }
+    },
+    {
+      "id": "C4.iframe-preattach.blank.shared",
+      "family": "C",
+      "kind": "cdp",
+      "scope": "any",
+      "defaultContext": true,
+      "setup": [
+        {
+          "page": "tab",
+          "url": "{ordinary}/blank"
+        }
+      ],
+      "trigger": [
+        {
+          "frameRead": "blank",
+          "from": "{ordinary}",
+          "as": "frames",
+          "requires": ["siteIsolationOff"]
+        }
+      ],
+      "targets": ["seven", "vault", "vault-x", "apex"],
+      "requires": ["siteIsolationOff"],
+      "observe": {
+        "live": {
+          "means": "the observer saw the protected frame's about:blank child and its marker in the page's process",
+          "check": {
+            "result": "frames",
+            "path": "result.live",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "frameTreeShown": {
+          "means": "the client's Page.getFrameTree showed the child's marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.frameTreeShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "axFullShown": {
+          "means": "the client's frame-scoped Accessibility.getFullAXTree showed the marker",
+          "check": {
+            "result": "frames",
+            "path": "result.axFullShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "axPartialShown": {
+          "means": "the client's Accessibility.getPartialAXTree of the marker node showed the marker",
+          "check": {
+            "result": "frames",
+            "path": "result.axPartialShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "documentShown": {
+          "means": "the client's pierced DOM.getDocument showed the marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.documentShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "nodeShown": {
+          "means": "the client's DOM.describeNode and DOM.getOuterHTML of the child's nodes showed the marker",
+          "check": {
+            "result": "frames",
+            "path": "result.nodeShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "snapshotShown": {
+          "means": "the client's DOMSnapshot.captureSnapshot showed the marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.snapshotShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "eventsShown": {
+          "means": "an event on the client's session showed the marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.eventsShown",
+            "equals": true,
+            "observer": "client"
+          }
+        }
+      },
+      "live": "the independent observer, before the client attaches, sees {target}'s about:blank child frame and its marker in the page's own process through every read",
+      "liveCheck": {
+        "result": "frames",
+        "path": "result.live",
+        "equals": true,
+        "observer": "client"
+      },
+      "control": {
+        "origin": "ordinary",
+        "via": "unguarded",
+        "expected": {
+          "live": true,
+          "frameTreeShown": true,
+          "axFullShown": true,
+          "axPartialShown": true,
+          "documentShown": true,
+          "nodeShown": true,
+          "snapshotShown": true
+        }
+      },
+      "expected": {
+        "live": true,
+        "frameTreeShown": false,
+        "axFullShown": false,
+        "axPartialShown": false,
+        "documentShown": false,
+        "nodeShown": false,
+        "snapshotShown": false,
+        "eventsShown": false
+      }
+    },
+    {
+      "id": "C4.iframe-preattach.srcdoc.shared",
+      "family": "C",
+      "kind": "cdp",
+      "scope": "any",
+      "defaultContext": true,
+      "setup": [
+        {
+          "page": "tab",
+          "url": "{ordinary}/blank"
+        }
+      ],
+      "trigger": [
+        {
+          "frameRead": "srcdoc",
+          "from": "{ordinary}",
+          "as": "frames",
+          "requires": ["siteIsolationOff"]
+        }
+      ],
+      "targets": ["seven", "vault", "vault-x", "apex"],
+      "requires": ["siteIsolationOff"],
+      "observe": {
+        "live": {
+          "means": "the observer saw the protected frame's about:srcdoc child and its marker in the page's process",
+          "check": {
+            "result": "frames",
+            "path": "result.live",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "frameTreeShown": {
+          "means": "the client's Page.getFrameTree showed the child's marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.frameTreeShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "axFullShown": {
+          "means": "the client's frame-scoped Accessibility.getFullAXTree showed the marker",
+          "check": {
+            "result": "frames",
+            "path": "result.axFullShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "axPartialShown": {
+          "means": "the client's Accessibility.getPartialAXTree of the marker node showed the marker",
+          "check": {
+            "result": "frames",
+            "path": "result.axPartialShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "documentShown": {
+          "means": "the client's pierced DOM.getDocument showed the marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.documentShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "nodeShown": {
+          "means": "the client's DOM.describeNode and DOM.getOuterHTML of the child's nodes showed the marker",
+          "check": {
+            "result": "frames",
+            "path": "result.nodeShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "snapshotShown": {
+          "means": "the client's DOMSnapshot.captureSnapshot showed the marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.snapshotShown",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "eventsShown": {
+          "means": "an event on the client's session showed the marker or the protected path, query or fragment",
+          "check": {
+            "result": "frames",
+            "path": "result.eventsShown",
+            "equals": true,
+            "observer": "client"
+          }
+        }
+      },
+      "live": "the independent observer, before the client attaches, sees {target}'s about:srcdoc child frame and its marker in the page's own process through every read",
+      "liveCheck": {
+        "result": "frames",
+        "path": "result.live",
+        "equals": true,
+        "observer": "client"
+      },
+      "control": {
+        "origin": "ordinary",
+        "via": "unguarded",
+        "expected": {
+          "live": true,
+          "frameTreeShown": true,
+          "axFullShown": true,
+          "axPartialShown": true,
+          "documentShown": true,
+          "nodeShown": true,
+          "snapshotShown": true
+        }
+      },
+      "expected": {
+        "live": true,
+        "frameTreeShown": false,
+        "axFullShown": false,
+        "axPartialShown": false,
+        "documentShown": false,
+        "nodeShown": false,
+        "snapshotShown": false,
+        "eventsShown": false
+      }
+    },
     {
       "id": "C5.fulfill",
       "family": "C",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-browsers",
-  "version": "1.16.2",
+  "version": "1.17.0",
   "description": "SLICC's shared browser catalog, JSON schemas and discovery conformance corpus",
   "type": "module",
   "license": "Apache-2.0",
@@ -58,6 +58,7 @@
     "redirect-secret.mjs",
     "redirect-fragments.mjs",
     "observer-target.mjs",
+    "frame-read.mjs",
     "fixture-client.mjs"
   ],
   "scripts": {
@@ -66,7 +67,7 @@
     "validate": "node scripts/validate.mjs",
     "lint": "slicc-lint && test -z \"$(gofmt -l .)\" && go mod tidy -diff && go vet ./... && golangci-lint run && cargo fmt --check && cargo clippy --all-features --all-targets -- -D warnings",
     "format": "biome check --write . && gofmt -w . && cargo fmt",
-    "test": "npm run validate && node --test test/integration/self-contained.test.mjs test/integration/browser-runner.test.mjs test/integration/fixture-client.test.mjs test/integration/git-retry.test.mjs test/integration/release-line.test.mjs test/integration/guard-redirect-carrier.test.mjs test/integration/guard-redirect-session-end.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": "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/release-line.test.mjs test/integration/guard-redirect-carrier.test.mjs test/integration/guard-redirect-session-end.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 test/integration/guard-frame-read.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",
@@ -78,10 +79,10 @@
     "test:gates": "node --test test/integration/gates.test.mjs",
     "test:guard-target": "node --test test/integration/guard-runner.test.mjs",
     "test:unit:redirect": "mkdir -p coverage/unit && node --experimental-test-coverage --test --test-coverage-include=redirect-secret.mjs --test-coverage-include=redirect-fragments.mjs --test-reporter=lcov --test-reporter-destination=coverage/unit/redirect.lcov test/unit/guard-redirect-*.test.mjs && slicc-diff-cover coverage/unit/redirect.lcov",
-    "test:unit:guard": "mkdir -p coverage/unit && node --experimental-vm-modules --no-warnings --experimental-test-coverage --test --test-coverage-include=guard-runner.mjs --test-coverage-include=fixture-server.mjs --test-coverage-include=fixture-client.mjs --test-coverage-include=observer-target.mjs --test-coverage-include=protected-error-page.mjs --test-coverage-include=unparseable-url.mjs --test-coverage-include=scripts/browser-runner.mjs --test-coverage-include=scripts/validate.mjs --test-reporter=lcov --test-reporter-destination=coverage/unit/guard.lcov test/unit/guard-*.test.mjs && slicc-diff-cover coverage/unit/guard.lcov"
+    "test:unit:guard": "mkdir -p coverage/unit && node --experimental-vm-modules --no-warnings --experimental-test-coverage --test --test-coverage-include=guard-runner.mjs --test-coverage-include=fixture-server.mjs --test-coverage-include=fixture-client.mjs --test-coverage-include=observer-target.mjs --test-coverage-include=frame-read.mjs --test-coverage-include=protected-error-page.mjs --test-coverage-include=unparseable-url.mjs --test-coverage-include=scripts/browser-runner.mjs --test-coverage-include=scripts/validate.mjs --test-reporter=lcov --test-reporter-destination=coverage/unit/guard.lcov test/unit/guard-*.test.mjs && slicc-diff-cover coverage/unit/guard.lcov"
   },
   "devDependencies": {
-    "@ai-ecoverse/slicc-shared-web": "2.7.4",
+    "@ai-ecoverse/slicc-shared-web": "2.7.5",
     "@biomejs/biome": "2.5.15",
     "ajv": "8.20.0",
     "ajv-formats": "3.0.1",

package/schema/guard-vectors.schema.json

@@ -88,7 +88,8 @@
         "chromeUrlsAttach",
         "extensionWorld",
         "discovery",
-        "clientExit"
+        "clientExit",
+        "siteIsolationOff"
       ],
       "properties": {
         "autoAttach": {
@@ -109,7 +110,8 @@
           "type": "string",
           "minLength": 1
         },
-        "clientExit": { "type": "string", "minLength": 1 }
+        "clientExit": { "type": "string", "minLength": 1 },
+        "siteIsolationOff": { "type": "string", "minLength": 1 }
       }
     },
     "placeholders": {
@@ -139,7 +141,8 @@
         "chromeUrlsAttach",
         "extensionWorld",
         "discovery",
-        "clientExit"
+        "clientExit",
+        "siteIsolationOff"
       ]
     },
     "requires": {
@@ -453,6 +456,18 @@
             "as": { "$ref": "#/$defs/name" }
           }
         },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["frameRead", "from", "as"],
+          "properties": {
+            "frameRead": { "enum": ["blank", "srcdoc"] },
+            "from": { "type": "string", "minLength": 1 },
+            "on": { "$ref": "#/$defs/on" },
+            "requires": { "$ref": "#/$defs/requires" },
+            "as": { "$ref": "#/$defs/name" }
+          }
+        },
         {
           "type": "object",
           "additionalProperties": false,