@ai-ecoverse/slicc-browsers 1.10.0 → 1.10.2

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,8 +281,10 @@ 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;
+- `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, the fixture and `protected.mjs` goes through it, 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, 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 …`.
 
 **`npm run validate`** checks that:
@@ -294,7 +296,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 +364,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
@@ -437,6 +439,14 @@ redirect chains it also requires the exact final destination request in the
 fixture log. A setup beacon on the same origin and tag cannot settle an unfinished
 redirect chain. This does not change the observations used to judge either leg.
 
+The fixture log is shared by every row in a run, and `C8.unparseable` leaves entries such
+as `http://exa%20mple.sliccy.ai:<port>/doc?n=<tag>-create-0` that `new URL` rejects. A
+row reads only the entries that carry its own tag; a tagged `liveCheck`, `served`,
+`on` or `beacon` check never sees another row's entries, and an entry that does not
+parse is matched only by its raw or canonical string, never parsed into a throw.
+`hops` checks compare exact URLs. `"tagged": false` reads every entry and skips the ones
+that don't parse.
+
 The separately exported Node module `@ai-ecoverse/slicc-browsers/fixture` exposes
 `fixtureServer({ host, port, tls, latency })`, defaulting to a random loopback port. `latency(url)` returns milliseconds to hold that response, for timing tests.
 Pass `tls: { key, cert }` to serve HTTPS using Node TLS key and certificate

package/fixture-server.mjs

@@ -1,5 +1,6 @@
 import { createServer } from 'node:http';
 import { createServer as createSecureServer } from 'node:https';
+import { parseURL } from './guard-driver.mjs';
 
 const tall = Buffer.from(
   'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
@@ -78,19 +79,18 @@ function route(req, url, send, html) {
 
 function requestURL(req, scheme) {
   const origin = `${scheme}://${req.headers.host}`;
-  try {
-    return new URL(req.url, origin);
-  } catch {
-    const path = new URL(req.url, `${scheme}://fixture.invalid`);
-    return {
-      pathname: path.pathname,
-      searchParams: path.searchParams,
-      href: `${origin}${path.pathname}${path.search}${path.hash}`,
-      origin,
-      host: req.headers.host,
-      hostname: req.headers.host.replace(/:\d+$/, ''),
-    };
-  }
+  const parsed = parseURL(req.url, origin);
+  if (parsed) return parsed;
+  const path =
+    parseURL(req.url, `${scheme}://fixture.invalid`) ?? new URL(`${scheme}://fixture.invalid/`);
+  return {
+    pathname: path.pathname,
+    searchParams: path.searchParams,
+    href: `${origin}${path.pathname}${path.search}${path.hash}`,
+    origin,
+    host: req.headers.host,
+    hostname: String(req.headers.host ?? '').replace(/:\d+$/, ''),
+  };
 }
 
 export async function fixtureServer({ host = '127.0.0.1', port = 0, tls, latency } = {}) {

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('; ') } : {}),
   };
 }
@@ -266,3 +275,15 @@ export function summary({ guard, sha, set, results }) {
     line: `${pass ? 'GUARD-PASS' : 'GUARD-FAIL'} ${guard}@${sha} (vectors ${name})`,
   };
 }
+
+export function parseURL(value, base) {
+  if (typeof value !== 'string') return null;
+  try {
+    return new URL(value, base);
+  } catch {
+    return null;
+  }
+}
+
+export const owned = (entries, tag) =>
+  (entries ?? []).filter((entry) => typeof entry?.url === 'string' && entry.url.includes(tag));

package/guard-runner.mjs

@@ -7,11 +7,13 @@ import {
   isRefusal,
   loadedAfter,
   outcome,
+  owned,
+  parseURL,
   summary as report,
   result,
   steps,
 } from './guard-driver.mjs';
-import { unparseableURLs } from './unparseable-url.mjs';
+import { canonicalURL, unparseableURLs } from './unparseable-url.mjs';
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const namedResultMs = 10000;
@@ -233,13 +235,13 @@ class Execution {
   }
 
   async attemptCheck(c) {
-    const logs = (await this.options.fixture.log()).slice(this.requestStart);
+    const logs = owned((await this.options.fixture.log()).slice(this.requestStart), this.vars.tag);
     if (c.pre) {
       const url = address(c.pre);
       return logs.some((entry) => {
-        const request = new URL(entry.url);
+        const request = parseURL(entry.url);
         return (
-          request.pathname === '/live' &&
+          request?.pathname === '/live' &&
           request.searchParams.get('tag') === this.vars.tag &&
           request.searchParams.get('step') === 'pre' &&
           request.searchParams.get('to') === url
@@ -247,15 +249,16 @@ class Execution {
       });
     }
     const url = address(c.loaded);
+    const origin = parseURL(url)?.origin;
     return logs.some((entry) => {
-      const request = new URL(entry.url);
+      if (entry.url === url || canonicalURL(entry.url) === canonicalURL(url)) return true;
+      const request = parseURL(entry.url);
       return (
-        entry.url === url ||
-        (request.pathname === '/live' &&
-          request.origin === new URL(url).origin &&
-          request.searchParams.get('tag') === this.vars.tag &&
-          request.searchParams.get('to') === url &&
-          request.searchParams.get('step') !== 'pre')
+        request?.pathname === '/live' &&
+        request.origin === origin &&
+        request.searchParams.get('tag') === this.vars.tag &&
+        request.searchParams.get('to') === url &&
+        request.searchParams.get('step') !== 'pre'
       );
     });
   }
@@ -664,6 +667,7 @@ class Execution {
           origin: this.vars.ordinary,
           tag: this.vars.tag,
           fixture: this.options.fixture,
+          browserSession: supported(['browserSession'], this.options.capabilities),
         })
       );
     if (step.extensionWorld)
@@ -1034,22 +1038,27 @@ class Execution {
   async requestCheck(c, start = this.requestStart) {
     const logs = (await this.options.fixture.log()).slice(start);
     if (c.hops)
-      return c.hops.every((_, i) => logs.some((entry) => entry.url === hop(c.hops.slice(i), c.to)));
-    return logs.some((entry) => {
-      const url = new URL(entry.url);
+      return c.hops.every((_, i) =>
+        logs.some((entry) => entry?.url === hop(c.hops.slice(i), c.to))
+      );
+    const mine =
+      c.tagged === false
+        ? logs.filter((entry) => typeof entry?.url === 'string')
+        : owned(logs, this.vars.tag);
+    return mine.some((entry) => {
+      const url = parseURL(entry.url);
       if (c.beacon)
         return (
-          url.pathname === '/beacon' &&
+          url?.pathname === '/beacon' &&
           url.searchParams.get('tag') === this.vars.tag &&
           url.searchParams.get('origin') === c.beacon
         );
-      if (c.tagged !== false && !entry.url.includes(this.vars.tag)) return false;
-      if (c.origin && url.origin !== c.origin) return false;
+      if (c.origin && url?.origin !== c.origin) return false;
       if (c.served)
-        return c.served.startsWith('http') ? entry.url === c.served : url.pathname === c.served;
+        return c.served.startsWith('http') ? entry.url === c.served : url?.pathname === c.served;
       return (
-        (c.on.startsWith('http') ? entry.url === c.on : url.pathname === c.on) &&
-        entry.headers[c.header.toLowerCase()] === (c.value ?? this.vars.tag)
+        (c.on.startsWith('http') ? entry.url === c.on : url?.pathname === c.on) &&
+        entry.headers?.[c.header.toLowerCase()] === (c.value ?? this.vars.tag)
       );
     });
   }
@@ -1086,7 +1095,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.2",
   "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.2",
   "description": "SLICC's shared browser catalog, JSON schemas and discovery conformance corpus",
   "type": "module",
   "license": "Apache-2.0",
@@ -67,14 +67,14 @@
     "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-scales.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-scales.test.mjs test/integration/guard-shared-log.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",
     "test:unit:guard": "node --experimental-test-coverage --test --test-coverage-include=guard-runner.mjs --test-coverage-include=fixture-server.mjs --test-coverage-lines=100 test/unit/guard-*.test.mjs"
   },
   "devDependencies": {
-    "@ai-ecoverse/slicc-shared-web": "1.25.2",
+    "@ai-ecoverse/slicc-shared-web": "1.27.0",
     "@biomejs/biome": "2.5.15",
     "ajv": "8.20.0",
     "ajv-formats": "3.0.1",

package/protected.mjs

@@ -1,10 +1,4 @@
-const parse = (text) => {
-  try {
-    return new URL(text);
-  } catch {
-    return null;
-  }
-};
+import { parseURL as parse } from './guard-driver.mjs';
 
 const scheme = (u) => u.protocol.slice(0, -1);
 

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

@@ -1,4 +1,4 @@
-import { outcome } from './guard-driver.mjs';
+import { outcome, owned, parseURL } from './guard-driver.mjs';
 
 const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const refused = (out) => !out.ok && /^slicc: refused:/.test(out.error?.message ?? '');
@@ -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) {
+  if (typeof value !== 'string') return value;
+  const direct = parseURL(value);
+  if (direct) return direct.href;
+  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 = parseURL(`${protocol}//example.test${port ? `:${port}` : ''}${path}`);
+  if (!parsed) return value;
+  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,
@@ -180,7 +212,7 @@ export async function unparseableURLs({ client, reader, session, targetId, origi
     };
     await pause(100);
     const requests = await fixture.log();
-    result.cookieRequest = requests.some((entry) =>
+    result.cookieRequest = owned(requests, tag).some((entry) =>
       entry.url.includes(`${tag}-create-`) || entry.url.includes(`${tag}-navigate-`)
         ? entry.headers.cookie?.includes(`${cookie}=${value}`)
         : false