@ai-ecoverse/slicc-browsers 1.10.0 → 1.10.1

package/README.md

@@ -182,7 +182,7 @@ The `C9` foreign extension isolated-world family requires `extensionWorld`: a br
 
 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.
 
-`C8.unparseable` probes both raw and canonical space/U+200D/invalid-punycode URLs through creation and navigation. Every guarded destination needs a matched refusal. Its unguarded controls record `document` or `native-rejection` outcomes, including Chrome builds that reject raw U+200D instead of committing it. Both raw and encoded-space forms must commit real fixture documents, because that is the proven cookie leak. An independent observer loads the encoded-space document and confirms it shares a uniquely seeded `.sliccy.ai` cookie; the guarded client must neither list nor attach to it, read its cookie, query that cookie by URL, nor cause a cookie-bearing destination request. The guard does not erase the observer’s private browser state. The row requires `browserSession`, uses the default context, and cleans up its own targets and cookie. The HTTP fixture accepts Chrome’s encoded-space Host header without reparsing it as a WHATWG origin.
+`C8.unparseable` probes both raw and canonical space/U+200D/invalid-punycode URLs through creation and navigation. Every guarded destination needs a matched refusal. Its unguarded controls record `document` or `native-rejection` outcomes, including Chrome builds that reject raw U+200D instead of committing it. Both raw and encoded-space forms must commit real fixture documents, because that is the proven cookie leak. An independent observer loads the encoded-space document and confirms it shares a uniquely seeded `.sliccy.ai` cookie; the guarded client must neither list nor attach to it, read its cookie, query that cookie by URL, nor cause a cookie-bearing destination request. The guard does not erase the observer’s private browser state. The row runs on both browser-session and page-session-only transports, uses the default context, and cleans up its own targets and cookie. Cookie seeding always uses the unguarded observer’s browser session, never the guarded client. Only guarded browser-session target listing requires `browserSession`; without it, `listed` records `not-supported` explicitly in probe and observation evidence, and the result lists that field in `notSupported`. Creation, navigation, attachment and `Network.getCookies` with `urls` still require matched refusals; filtering cookies without refusing fails `cookieRefused`. Fixture URLs omit the colon when the port is empty, and reported URLs are compared after canonicalisation, including Chrome’s WHATWG-unparseable encoded-space hosts. Launchers must resolve the raw/canonical space, U+200D/punycode and invalid-punycode `.sliccy.ai` fixture hosts to the fixture server, including for default-port HTTP or HTTPS origins. The HTTP fixture accepts Chrome’s encoded-space Host header without reparsing it as a WHATWG origin.
 
 `C8.chrome-search` requests `chrome-search://most-visited/` through `Page.navigate` and requires an explicit guard refusal. Its unguarded control requires a CDP response, not a successful document commit: Chrome can answer with `errorText` when that internal data source is unavailable outside an Instant process. Browser-side load failure is not a guard refusal, and merely hiding the target must fail this row.
 
@@ -206,8 +206,8 @@ A client may register `Fetch.enable` patterns naming a protected origin in eithe
 - `scope`: `any`, or the one guard the vector is for;
 - `setup` and `trigger`, both lists of steps;
 - `targets`: the protected or reachability targets it runs against;
-- `requires?`: the capabilities it needs, the union of its steps' and observations' `requires`. A runner whose transport lacks one reports the vector as `skip` with the reason `not-supported:<capability>`. A row with a `page-or-browser` cookie step that would carry a `browserContextId` reports `not-supported:browserSession` without a browser session, because that parameter is only allowed on the browser target;
-- `observe?`: each observed name, as `{ "means", "dependsOn"?, "requires"?, "eitherWhen"? }`. `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);
+- `requires?`: the capabilities needed for the whole vector, including its steps' `requires`. Observation-only capabilities may be omitted here to keep independent legs runnable. A runner whose transport lacks one reports the vector as `skip` with the reason `not-supported:<capability>`. A row with a `page-or-browser` cookie step that would carry a `browserContextId` reports `not-supported:browserSession` without a browser session, because that parameter is only allowed on the browser target;
+- `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: …`.
@@ -247,7 +247,7 @@ Popups are observed by `Target.targetCreated` with the opener's `openerId`, or b
 
 `{ "extensionWorld": "hidden" | "select" | "debugger" | "drivable", "as": "world", "requires": ["extensionWorld"] }` runs the C9 compound probe on the current ordinary page. The runner attaches an independent observer to discover actual context ids, unique ids and names, and sends probes through the client session. Discovery matches the expected fixture extension’s exact origin, never the first extension world: `run()`’s optional `extensionWorldId` defaults to shared-web’s harness id `ankmbodmgimjemnojmeddfcdlbocolob`. Multiple unrelated content-script worlds are ignored for fixture selection, while guards must still protect foreign worlds. A custom fixture must provide the same content-script marker contract. Object handles are minted and validated on the unguarded control session, then replayed as guesses on the guarded leg; Chrome object handles and DOM node ids are session-local, so observer handles must never be mistaken for client handles. Numeric ids from the control are also replayed alongside fresh observer-discovered selectors, but numeric ids are local to a tab: a control id may name the next tab’s exposed default context, which must work and return no extension marker. The same-tab hidden world’s actual numeric id and every extension unique-id guess still require a matched refusal. Unknown numeric ids and stale object handles (`not exposed`) need explicit refusals rather than Chrome’s invalid-id errors. `guessesRefused` aggregates only required refusals; `guessesReached` must be false on the guarded leg, and `exposedContextsWork` must remain true. Its result contains boolean evidence consumed by ordinary `result` checks. The unguarded leg validates those selectors against Chrome itself before guarded evidence can pass.
 
-`{ "unparseable": true, "as": "unparseable", "requires": ["browserSession"] }` 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.
+`{ "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`.
 
@@ -281,7 +281,7 @@ It exports:
 - `refusals(vector)`: the vector's refusal names;
 - `outcome`, `call(client, step, sessionId)` and `isRefusal(outcome, step)`;
 - `instrument(client, sessionId, log, tag)`, `load(client, sessionId, url)` and `popup(client, openerId)`;
-- `judge(vector, side, observed)`: `{ pass, refused, skipped, mismatches }`, where `refused` lists the leg's refusals and `skipped` the observations that depend on them;
+- `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;
 - `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, 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 …`.
 
@@ -294,7 +294,7 @@ It exports:
 - a skip names one of the vector's targets;
 - `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` is the union of its steps' and observations';
+- 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;
 - every `{name}` is in `placeholders`;
 - no URL uses a port from 9222 to 9229.
 
@@ -362,7 +362,7 @@ With the `browserContexts` capability each leg runs in its own browser context.
 
 `onStart(row)` receives each row's `id`, `target`, `variant`, `transport` and `via` as the row starts. `run()` returns a promise that also has `inFlight()`, and its result has `inFlight` too. `inFlight()` lists the rows that are running now, each as `{ id, target, variant, leg, phase, step, clients }`, where `step` is the index of the current step in its `phase` (`setup`, `trigger` or `child`), and `clients` lists each client's pending CDP calls as `{ method, session, ageMs }` (`client`, plus `unguarded` when it is a separate client). With `rowTimeoutMs`, a row still running after that many milliseconds fails on its own. Its `errors` hold `row timed out after <ms>ms: <the in-flight view>`, `inFlight` holds the view, and the clients that `clientFactory` made for it are closed. The run then goes on to the next row. It is off by default, and a client passed as `client` is never closed.
 
-`log(row)` receives completed rows. Besides `control`, `guarded`, `live`, `why` and `errors`, a row may carry `ran` (steps that ran on one leg only) and `notes` (settles skipped because their registration was refused). Both are informational: they explain a row's verdict, and adopters (bios, slicc-cli, slicc-cdp) must not count them as failures, or as passes. The verdict is `control`, `guarded` and `live`. A variant supplies the wait before an
+`log(row)` receives completed rows. Besides `control`, `guarded`, `live`, `why` and `errors`, a row may carry `notSupported` (unavailable observation fields), `ran` (steps that ran on one leg only) and `notes` (settles skipped because their registration was refused). Both are informational: they explain a row's verdict, and adopters (bios, slicc-cli, slicc-cdp) must not count them as failures, or as passes. The verdict is `control`, `guarded` and `live`. A variant supplies the wait before an
 explicit `Target.detachFromTarget` step and for a `settle.variant` step.
 
 Every runnable vector has a declarative `liveCheck`; every observation has a

package/guard-driver.mjs

@@ -139,8 +139,10 @@ export function judge(vector, side, observed) {
     const mismatches = observed === true ? [] : [want];
     return { pass: mismatches.length === 0, refused, skipped: [], mismatches };
   }
-  const skipped = Object.keys(want).filter((k) =>
-    (vector.observe?.[k]?.dependsOn ?? []).some((d) => refused.includes(d))
+  const skipped = Object.keys(want).filter(
+    (k) =>
+      (observed?.[k] === 'not-supported' && vector.observe?.[k]?.requires?.length > 0) ||
+      (vector.observe?.[k]?.dependsOn ?? []).some((d) => refused.includes(d))
   );
   const mismatches = Object.entries(want)
     .filter(
@@ -227,6 +229,13 @@ export function result(vector, run) {
     guarded,
     live,
     ...(Object.keys(ran).length ? { ran } : {}),
+    ...(Object.values(run.guarded ?? {}).includes('not-supported')
+      ? {
+          notSupported: Object.keys(run.guarded).filter(
+            (name) => run.guarded[name] === 'not-supported'
+          ),
+        }
+      : {}),
     ...(why.length ? { why: why.join('; ') } : {}),
   };
 }

package/guard-runner.mjs

@@ -664,6 +664,7 @@ class Execution {
           origin: this.vars.ordinary,
           tag: this.vars.tag,
           fixture: this.options.fixture,
+          browserSession: supported(['browserSession'], this.options.capabilities),
         })
       );
     if (step.extensionWorld)
@@ -1086,7 +1087,10 @@ class Execution {
       await sleep(100);
       const observed = { ...this.refused };
       for (const [name, observation] of Object.entries(this.vector.observe ?? {})) {
-        if (!supported(observation.requires, this.options.capabilities)) continue;
+        if (!supported(observation.requires, this.options.capabilities)) {
+          observed[name] = 'not-supported';
+          continue;
+        }
         if ((observation.dependsOn ?? []).some((dep) => this.refused[dep])) continue;
         observed[name] = await this.observe(name, observation.check);
         if (observation.eitherWhen && this.side === 'guarded')

package/guard-vectors.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "setVersion": "1.10.0",
+  "setVersion": "1.10.1",
   "sources": [
     {
       "repo": "ai-ecoverse/slicc-cli",
@@ -133,12 +133,10 @@
       "trigger": [
         {
           "unparseable": true,
-          "as": "unparseable",
-          "requires": ["browserSession"]
+          "as": "unparseable"
         }
       ],
       "targets": ["ordinary"],
-      "requires": ["browserSession"],
       "observe": {
         "live": {
           "means": "unparseable URL protection live",
@@ -169,6 +167,7 @@
         },
         "listed": {
           "means": "unparseable URL protection listed",
+          "requires": ["browserSession"],
           "check": {
             "result": "unparseable",
             "path": "result.listed",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-browsers",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "description": "SLICC's shared browser catalog, JSON schemas and discovery conformance corpus",
   "type": "module",
   "license": "Apache-2.0",

package/schema/guard-vectors.schema.json

@@ -430,7 +430,7 @@
         {
           "type": "object",
           "additionalProperties": false,
-          "required": ["unparseable", "as", "requires"],
+          "required": ["unparseable", "as"],
           "properties": {
             "unparseable": {
               "const": true
@@ -439,11 +439,7 @@
               "$ref": "#/$defs/name"
             },
             "requires": {
-              "$ref": "#/$defs/requires",
-              "type": "array",
-              "contains": {
-                "const": "browserSession"
-              }
+              "$ref": "#/$defs/requires"
             }
           }
         },

package/unparseable-url.mjs

@@ -10,7 +10,25 @@ const hosts = [
   ['xn--a.sliccy.ai', 'xn--a.sliccy.ai'],
 ];
 
+export const rootURL = (root, host, path) =>
+  `${root.protocol}//${host}${root.port ? `:${root.port}` : ''}${path}`;
+
+export function canonicalURL(value) {
+  try {
+    return new URL(value).href;
+  } catch {
+    const match = /^(https?:)\/\/([^/?#]+)(.*)$/.exec(value);
+    if (!match) return value;
+    const [, protocol, authority, path] = match;
+    const host = authority.replace(/:\d*$/, '').replaceAll(' ', '%20');
+    const port = /:(\d*)$/.exec(authority)?.[1];
+    const parsed = new URL(`${protocol}//example.test${port ? `:${port}` : ''}${path}`);
+    return rootURL(parsed, host, `${parsed.pathname}${parsed.search}${parsed.hash}`);
+  }
+}
+
 async function document(reader, targetId, expected, allowNativeRejection = false) {
+  expected = canonicalURL(expected);
   const { sessionId } = await reader.send('Target.attachToTarget', { targetId, flatten: true });
   try {
     const deadline = Date.now() + 5000;
@@ -19,7 +37,7 @@ async function document(reader, targetId, expected, allowNativeRejection = false
     do {
       const { targetInfo } = await reader.send('Target.getTargetInfo', { targetId });
       targetURL = targetInfo.url;
-      if (targetInfo.url !== expected) {
+      if (canonicalURL(targetInfo.url) !== expected) {
         last = { url: targetInfo.url, title: targetInfo.title };
         await pause(25);
         continue;
@@ -41,7 +59,7 @@ async function document(reader, targetId, expected, allowNativeRejection = false
       );
       const value = out.result?.result?.value;
       last = value ?? out;
-      if (out.ok && value?.title === 'doc' && value.href === expected) return value;
+      if (out.ok && value?.title === 'doc' && canonicalURL(value.href) === expected) return value;
       await pause(25);
     } while (Date.now() < deadline);
     if (allowNativeRejection && ['', 'about:blank', 'about:blank#blocked'].includes(targetURL))
@@ -75,10 +93,10 @@ async function destinations({ client, reader, root, tag, targets, session, targe
     out.error?.code === -32000 && /invalid URL/i.test(out.error?.message ?? '');
   for (const [index, [input, canonical]] of hosts.entries()) {
     const strict = canonical === 'exa%20mple.sliccy.ai';
-    const base = `${root.protocol}//${canonical}:${root.port}/doc?n=${tag}`;
+    const base = rootURL(root, canonical, `/doc?n=${tag}`);
     const created = await outcome(
       client.send('Target.createTarget', {
-        url: `${root.protocol}//${input}:${root.port}/doc?n=${tag}-create-${index}`,
+        url: rootURL(root, input, `/doc?n=${tag}-create-${index}`),
         background: true,
       })
     );
@@ -95,7 +113,7 @@ async function destinations({ client, reader, root, tag, targets, session, targe
     const navigated = await outcome(
       client.send(
         'Page.navigate',
-        { url: `${root.protocol}//${input}:${root.port}/doc?n=${tag}-navigate-${index}` },
+        { url: rootURL(root, input, `/doc?n=${tag}-navigate-${index}`) },
         session
       )
     );
@@ -116,7 +134,7 @@ async function destinations({ client, reader, root, tag, targets, session, targe
     await outcome(
       client.send(
         'Page.navigate',
-        { url: `${root.origin}/doc?n=${tag}-ordinary-${index}` },
+        { url: rootURL(root, root.hostname, `/doc?n=${tag}-ordinary-${index}`) },
         session
       )
     );
@@ -124,7 +142,16 @@ async function destinations({ client, reader, root, tag, targets, session, targe
   return result;
 }
 
-export async function unparseableURLs({ client, reader, session, targetId, origin, tag, fixture }) {
+export async function unparseableURLs({
+  client,
+  reader,
+  session,
+  targetId,
+  origin,
+  tag,
+  fixture,
+  browserSession,
+}) {
   const root = new URL(origin);
   const cookie = `seven-unparseable-${tag}`;
   const value = `secret-${tag}`;
@@ -134,7 +161,7 @@ export async function unparseableURLs({ client, reader, session, targetId, origi
     await reader.send('Storage.setCookies', {
       cookies: [{ name: cookie, value, domain: '.sliccy.ai', path: '/', secure: false }],
     });
-    const url = `${root.protocol}//exa%20mple.sliccy.ai:${root.port}/doc?n=${tag}-observer`;
+    const url = rootURL(root, 'exa%20mple.sliccy.ai', `/doc?n=${tag}-observer`);
     const { targetId: probeId } = await reader.send('Target.createTarget', {
       url,
       background: true,
@@ -143,7 +170,9 @@ export async function unparseableURLs({ client, reader, session, targetId, origi
     const ground = await document(reader, probeId, url);
     observer = (await reader.send('Target.attachToTarget', { targetId: probeId, flatten: true }))
       .sessionId;
-    const listed = await outcome(client.send('Target.getTargets', {}));
+    const listed = browserSession
+      ? await outcome(client.send('Target.getTargets', {}))
+      : 'not-supported';
     const attached = await outcome(
       client.send('Target.attachToTarget', { targetId: probeId, flatten: true })
     );
@@ -168,7 +197,10 @@ export async function unparseableURLs({ client, reader, session, targetId, origi
     const result = {
       browserVersion: (await reader.send('Browser.getVersion', {})).product,
       live: ground.cookie.includes(`${cookie}=${value}`),
-      listed: listed.ok && listed.result.targetInfos?.some((info) => info.targetId === probeId),
+      listed:
+        listed === 'not-supported'
+          ? listed
+          : listed.ok && listed.result.targetInfos?.some((info) => info.targetId === probeId),
       attached: attached.ok,
       attachRefused: refused(attached),
       readCookie,