@ai-ecoverse/slicc-browsers 1.10.1 → 1.10.2

package/README.md

@@ -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, 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:
@@ -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

@@ -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.2",
   "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.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/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