@ai-ecoverse/slicc-browsers 1.16.2 → 1.18.0

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 ?? ''}`) ??
@@ -80,6 +91,16 @@ function route(req, url, send, html, redirects) {
         `<script>navigator.sendBeacon(${JSON.stringify(pre)})</script><iframe src="${escape(to)}"></iframe>`
       );
     },
+    '/bfcache': () => {
+      const marker = JSON.stringify(`bfcache-marker-${p.get('n') ?? ''}`).replaceAll(
+        '<',
+        '\\u003c'
+      );
+      return html(
+        'bfcache',
+        `<p id="bfcache-marker"></p><script>globalThis.__bfcacheMarker=${marker};sessionStorage.setItem('bfcache-marker',globalThis.__bfcacheMarker);document.querySelector('p').textContent=globalThis.__bfcacheMarker;globalThis.__bfcachePersisted=false;addEventListener('pageshow',e=>{globalThis.__bfcachePersisted=e.persisted});addEventListener('keydown',()=>{globalThis.__bfcacheKeys=(globalThis.__bfcacheKeys||0)+1})</script>`
+      );
+    },
     '/doc': () => document(url, html),
     '/csp': () => document(url, html),
   };
@@ -95,6 +116,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

@@ -2,7 +2,9 @@ import { fixtureClient, prepareFixture } from './fixture-client.mjs';
 
 export { fixtureClient };
 
+import { bfcacheRestore } from './bfcache-restore.mjs';
 import { extensionWorld } from './extension-world.mjs';
+import { frameRead } from './frame-read.mjs';
 import {
   beacon,
   canary,
@@ -669,12 +671,21 @@ 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',
+      'bfcacheRestore',
+    ].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', 'bfcacheRestore'].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 +778,36 @@ class Execution {
           budget: this.bound(5000),
         })
       );
+    if (step.bfcacheRestore)
+      return outcome(
+        bfcacheRestore({
+          client: this.client,
+          reader: this.reader,
+          delayClient: this.clients.client,
+          ordinary: this.vars.ordinary,
+          protectedOrigin: step.origin,
+          tag: this.vars.tag,
+          mode: step.bfcacheRestore,
+          forwardAudit: supported(['forwardAudit'], this.options.capabilities),
+          side: this.side,
+          notes: this.notes,
+          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({
@@ -1278,6 +1319,11 @@ class Execution {
         errors: this.errors,
         notes: this.notes,
         incomplete: this.incomplete,
+        evidence: Object.fromEntries(
+          Object.entries(this.calls)
+            .filter(([, out]) => out?.result?.delay && out.result.probes)
+            .map(([name, out]) => [name, out.result])
+        ),
       };
     } finally {
       this.stopped = true;
@@ -1420,6 +1466,7 @@ function variables(targets, target, side, slot, index) {
     tag,
     cookie: `canary-${tag}`,
   };
+  vars.protectedTarget = targets[target];
   vars.target = side === 'control' ? vars.plain : targets[target];
   vars.targetHost = new URL(vars.target).hostname;
   vars.responseOrigin = vars.target === vars.ordinary ? '*' : vars.ordinary;
@@ -1501,6 +1548,14 @@ async function timedOut(stuck, base, made, work, opts) {
   return failed;
 }
 
+function probeEvidence(legs) {
+  return [legs.control.evidence, legs.guarded.evidence].some(
+    (evidence) => Object.keys(evidence ?? {}).length
+  )
+    ? { evidence: { control: legs.control.evidence, guarded: legs.guarded.evidence } }
+    : {};
+}
+
 async function executeRow(job, opts, made, set, slot, index, flights) {
   const { target, variant } = job;
   const calls = new Map();
@@ -1588,6 +1643,7 @@ async function executeRow(job, opts, made, set, slot, index, flights) {
     observations: { control: legs.control.observed, guarded: legs.guarded.observed },
     errors: [...legs.control.errors, ...legs.guarded.errors],
     designDependent: vector.designDependent ?? [],
+    ...probeEvidence(legs),
   };
   const notes = [
     ...(legs.control.notes ?? []).map((note) => `control ${note}`),
@@ -1604,6 +1660,11 @@ async function executeRow(job, opts, made, set, slot, index, flights) {
 }
 
 function observerSkip(vector, opts, made, clients) {
+  if (
+    vector.requires?.includes('inboundDelay') &&
+    typeof clients.client.inboundDelay !== 'function'
+  )
+    return 'not-supported:inboundDelay';
   if (needsObserver(vector) && !clients.unguarded) return 'not-supported:unguarded-observer';
   if (!exitsClient(vector)) return undefined;
   if (!opts.clientFactory) return 'not-supported:clientExit';
@@ -1687,8 +1748,7 @@ function settleIncomplete(row, vector, base, legs) {
     live: legs.control.live === true && [true, 'incomplete'].includes(legs.guarded.live),
   });
   for (const side of ['control', 'guarded'])
-    if (legs[side].incomplete?.length && row[side] === 'fail' && filled[side] === 'pass')
-      row[side] = 'incomplete';
+    if (legs[side].incomplete?.length && filled[side] === 'pass') row[side] = 'incomplete';
   if (legs.guarded.live === 'incomplete' && filled.live === 'pass') row.live = 'incomplete';
   row.why = [filled.why, `incomplete: ${incomplete.join('; ')}`].filter(Boolean).join('; ');
 }