@ai-ecoverse/slicc-browsers 1.10.1 → 1.10.3

package/README.md

@@ -65,7 +65,7 @@ Every feature builds for `wasm32-wasip1`.
 
 `guard-driver.mjs` is described under [Guard vectors](#guard-vectors).
 
-`protected.mjs` is the reference matcher for [protected origins](#protected-origins): `import { protectedOrigins } from '@ai-ecoverse/slicc-browsers/protected.mjs'`, then `protectedOrigins(catalog.protectedOrigins, extraOrigins)` returns `{ url(text), target({ url, previous, opener }), cookieDomain(domain), storageKey(key), unparseable(text) }`, each a boolean. `url(text)` uses the load/loaded-URL fail-closed rule; `url(text, { readOnly: true })` preserves the old parse-failure result for read-only keys and value redaction, and `storageKey(key)` uses that mode internally. `unparseable(text)` identifies parse or unwrap failures without changing whether a parsed origin is protected. It needs only the WHATWG `URL`, so it runs in Node and in a browser.
+`protected.mjs` is the reference matcher for [protected origins](#protected-origins): `import { protectedOrigins } from '@ai-ecoverse/slicc-browsers/protected.mjs'`, then `protectedOrigins(catalog.protectedOrigins, extraOrigins)` returns `{ url(text), target({ url, previous, opener }), cookieDomain(domain), storageKey(key), unparseable(text) }`, each a boolean. `url(text)` uses the load/loaded-URL fail-closed rule; `url(text, { readOnly: true })` preserves the old parse-failure result for read-only keys and value redaction, and `storageKey(key)` uses that mode internally. `unparseable(text)` identifies parse or unwrap failures without changing whether a parsed origin is protected. It needs only the WHATWG `URL`, so it runs in Node and in a browser. `protected.mjs` and `seven.mjs` import nothing and re-export nothing, so an extension or service worker can ship either file alone; `npm run validate` (through `scripts/self-contained.mjs`) evaluates each as a module in a fresh `node:vm` context that has only `URL`, with no linker resolution allowed.
 
 ## `catalog.json`
 
@@ -283,6 +283,8 @@ It exports:
 - `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 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 and the fixture goes through it (`protected.mjs` keeps its own copy, since it imports nothing), so an unparseable entry never throws;
+- `owned(entries, tag)`: the fixture log entries whose raw URL contains `tag`, the row's attribution through its `n=`, `tag=` or `to=` query;
 - `summary({ guard, sha, set, results })`: `set` is the parsed `guard-vectors.json`. It returns `{ set, schemaVersion, guard, sha, variants, targets, transports, results, skipped, notRun, missing, 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:
@@ -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
@@ -589,10 +599,10 @@ for case in corpus().cases {
 
 Go 1.26, Rust stable with `wasm32-wasip1`, Node ≥ 24.
 - `npm run corpus` regenerates `corpus.json` from `corpus/`; the pre-commit hook and CI fail when it's stale.
-- `npm run validate` checks `catalog.json`, `corpus.json`, `protected.json` and `guard-vectors.json` against the schemas, runs the protected-origin vectors through `protected.mjs`, and checks what a schema can't say: unique ids, bundle ids and names, known Windows roots, rising tiers, compiling patterns, known tokens, tier order, `sevenOpen`, `tabs` (which holds no entry of `sevenTabs`), `six` and `auto` in each `expected.json`, and no port from 9222 to 9229.
+- `npm run validate` checks `catalog.json`, `corpus.json`, `protected.json` and `guard-vectors.json` against the schemas, runs the protected-origin vectors through `protected.mjs`, loads `protected.mjs` and `seven.mjs` with only `URL`, and checks what a schema can't say: unique ids, bundle ids and names, known Windows roots, rising tiers, compiling patterns, known tokens, tier order, `sevenOpen`, `tabs` (which holds no entry of `sevenTabs`), `six` and `auto` in each `expected.json`, and no port from 9222 to 9229.
 - Every gate prints one verdict line when it passes: `validate: PASS …`, `corpus: PASS <n> cases` (`node scripts/corpus.mjs --check`), `major-guard: PASS v<version> fits <module>`, and `guard-sweep: PASS 14 targets` (`npm run test:guard-sweep`). CI runs each through `scripts/gate.mjs --expect <regex> -- <command>`, which fails when the command exits non-zero or prints no matching line, so a silent or early exit never reads as a pass. `gate.mjs --expect <regex> --in <file>` checks a log instead; the release job uses it on semantic-release's log for the major-guard line. `npm run test:gates` tests the gates, including runs through a symlinked checkout and a symlinked script.
 - `npm run lint`: the slicc lint tools (Biome, no comments, no unit tests in git, `AGENTS.md`), `gofmt`, `go mod tidy -diff`, `go vet`, golangci-lint, `cargo fmt --check` and clippy.
-- `npm test`: `validate`, the Go tests in `test/integration/`, and `cargo test --all-features`.
+- `npm test`: `validate`, `test/integration/self-contained.test.mjs`, the Go tests in `test/integration/`, and `cargo test --all-features`.
 - `npm run build`: the Go module, the crate (also for `wasm32-wasip1`), and `npm pack --dry-run`.
 
 Changing a table in `slicc-cli/internal/browser` means changing `catalog.json` here, releasing, and bumping the dependency; slicc-cli has no tables of its own. A new behaviour gets a corpus case.

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

@@ -275,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'
       );
     });
   }
@@ -1035,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)
       );
     });
   }

package/guard-vectors.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "setVersion": "1.10.1",
+  "setVersion": "1.10.3",
   "sources": [
     {
       "repo": "ai-ecoverse/slicc-cli",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-browsers",
-  "version": "1.10.1",
+  "version": "1.10.3",
   "description": "SLICC's shared browser catalog, JSON schemas and discovery conformance corpus",
   "type": "module",
   "license": "Apache-2.0",
@@ -60,21 +60,21 @@
     "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 && go test -race -count=1 ./test/integration/... && cargo test --all-features",
+    "test": "npm run validate && node --test test/integration/self-contained.test.mjs && go test -race -count=1 ./test/integration/... && cargo test --all-features",
     "test:unit": "go test -race -cover ./...",
     "build": "go build ./... && cargo build --all-features && cargo build --target wasm32-wasip1 --all-features && npm pack --dry-run",
     "trust": "npx fledgling sync -y --skip-publish",
     "trust:dry": "npx fledgling sync --dry-run -y --skip-publish",
     "release": "semantic-release",
     "test:guard": "npm run test:guard-integration && npm run test:guard-sweep",
-    "test:guard-integration": "node --test --test-concurrency=2 test/integration/guard-lifecycle.test.mjs test/integration/guard-fit.test.mjs test/integration/guard-chain.test.mjs test/integration/guard-validation.test.mjs test/integration/guard-liveness.test.mjs test/integration/guard-observations.test.mjs test/integration/guard-child-latency.test.mjs test/integration/guard-adoption.test.mjs test/integration/guard-scoping.test.mjs test/integration/guard-late-pause.test.mjs test/integration/guard-legs.test.mjs test/integration/guard-fetch-enable.test.mjs test/integration/guard-diagnostics.test.mjs test/integration/guard-chrome.test.mjs test/integration/guard-worlds.test.mjs test/integration/guard-world-discovery.test.mjs test/integration/guard-world-guesses.test.mjs test/integration/guard-unparseable.test.mjs test/integration/guard-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/integration/self-contained.test.mjs",
     "test:guard-sweep": "node scripts/test-guards.mjs",
     "test:gates": "node --test test/integration/gates.test.mjs",
     "test:guard-target": "node --test test/integration/guard-runner.test.mjs",
     "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,4 +1,5 @@
 const parse = (text) => {
+  if (typeof text !== 'string') return null;
   try {
     return new URL(text);
   } catch {

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 ?? '');
@@ -14,17 +14,17 @@ 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}`);
-  }
+  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) {
@@ -212,7 +212,7 @@ export async function unparseableURLs({
     };
     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