@ai-ecoverse/slicc-browsers 1.10.3 → 1.11.0

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` 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.
+`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, type, documentURL, unreachableURL, navigating }), 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`
 
@@ -94,7 +94,7 @@ Every feature builds for `wasm32-wasip1`.
   - `discardExceptions`: where the site pattern and the extra origins' hosts go, as a `list` of strings or as a `chrome-time-map`, a map from site to the time it was added (microseconds since 1601-01-01 UTC, as a decimal string);
   - `cleanExit`: values that mark the last exit clean;
   - `form` says where a key comes from: `six` (SLICC six's keys) or `chrome-154` (what Chrome 154 reads).
-- `protectedOrigins`: what browser control must never reach, see [Protected origins](#protected-origins). `domains` (`sliccy.ai`), `hosts` (`vault.sliccy.ai`), `schemes` (`https`, `http`), `innerSchemes` (`blob`, `filesystem`, `view-source`), `anySchemes` (`devtools`), `protectedSchemes` (`chrome`, `chrome-untrusted`, `chrome-search`, `chrome-native`, `chrome-distiller`, `chrome-experimental-site-token-provider`, `isolated-app`, `externalfile`, `content`, `chrome-extension`, `devtools`, `edge`, `brave`, `opera`, `vivaldi`, `arc`, `file`) with `schemeExceptions` (`chrome://newtab`, `chrome://new-tab-page`, `chrome-untrusted://new-tab-page`, `edge://newtab`, `brave://newtab`, `opera://startpage`), `aboutScheme` (`chrome`), `targetTypes` (`browser_ui`), `inheriting` (`about:blank`, `about:srcdoc`), `unparseable` (`protected`) with `unparseableRefusal`, and `refusal`, the text of a parsed protected-origin refusal.
+- `protectedOrigins`: what browser control must never reach, see [Protected origins](#protected-origins). `domains` (`sliccy.ai`), `hosts` (`vault.sliccy.ai`), `schemes` (`https`, `http`), `innerSchemes` (`blob`, `filesystem`, `view-source`), `anySchemes` (`devtools`), `protectedSchemes` (`chrome`, `chrome-untrusted`, `chrome-search`, `chrome-native`, `chrome-distiller`, `chrome-experimental-site-token-provider`, `isolated-app`, `externalfile`, `content`, `chrome-extension`, `devtools`, `edge`, `brave`, `opera`, `vivaldi`, `arc`, `file`) with `schemeExceptions` (`chrome://newtab`, `chrome://new-tab-page`, `chrome-untrusted://new-tab-page`, `edge://newtab`, `brave://newtab`, `opera://startpage`), `aboutScheme` (`chrome`), `targetTypes` (`browser_ui`), `inheriting` (`about:blank`, `about:srcdoc`), `errorPage` (`url: "chrome-error://chromewebdata/"`, `target: "previous"`, `redact: "origin"`), `unparseable` (`protected`) with `unparseableRefusal`, and `refusal`, the text of a parsed protected-origin refusal.
 - `profiles`: SLICC profiles live in `<config dir>/<root>/<name>`, and a snap's in `~/snap/<snap>/common/<snapRoot>/<name>`. `legacyRoot` is the old root, never scanned; on macOS's case-insensitive volume it is SLICC six's root too. `sixProfilePattern` matches six's profile names, case-insensitively. `namePattern` is a valid profile name. `six` describes SLICC six's Chrome profiles (see [SLICC six's profiles](#slicc-sixs-profiles)):
   - `roots`: six's profile root per OS (`macos`, `linux`, `windows`), a `base` location followed by the `path` segments. The base is its `env` when that is set and not empty (any value, as six takes it), else `home` under the home dir.
   - `defaultName` (`browser-coding-agent-chrome`), `defaultPort` (5710) and `portSuffix` (`-{port}`): six's profile for its serve port `<port>` is `<root>/<defaultName>`, with `portSuffix` added for any port other than `defaultPort`.
@@ -147,6 +147,10 @@ A guard must refuse navigation, creation and attach on protected schemes, includ
 
 **New-tab checks (1.8.2).** In fresh default profiles on macOS, Chrome for Testing 156.0.8078.4 (Playwright build 1248) and Chrome 155.0.8059.82 commit `chrome://newtab/` to `chrome://new-tab-page/` and embed `chrome-untrusted://new-tab-page/one-google-bar?paramsencoded=` as an out-of-process frame. Direct `chrome://new-tab-page/` also commits as itself. Edge 155.0.4283.60 commits `edge://newtab/` to `https://ntp.msn.com/edge/ntp` with an `about:blank` child and no internal-scheme child observed; directly opening `edge://ntp/` returns `ERR_INVALID_URL`. These observations are for fresh default profiles, not every browser configuration. Brave, Opera and Vivaldi were not installed locally, and this repository's CI installs only Chromium, so their redirects and internal frames were not verified and no additional exceptions are inferred. Incognito Chrome and Edge new tabs omit the ordinary new tab's frame tree; the reachability vector therefore uses the default context.
 
+**Protected-URL error pages.** `errorPage` in both the catalog and `protected.json` retains the previous target decision; it never locks an allowed target or unlocks an already-protected target. The exemption requires the last main-frame different-document commit to be `chrome-error://chromewebdata/`, with opaque `securityOrigin` (`://`), and `unreachableUrl` exactly equal to the reported `TargetInfo.url`, with no main-frame navigation in flight. A URL mismatch, unavailable commit evidence or an in-flight navigation does not qualify; guards fail closed while their state is unknown. `protected.mjs.target` takes validated `documentURL`, `unreachableURL` and `navigating` evidence in addition to `previous`; callers must track commits and readiness, rather than trust `TargetInfo.url` alone. Browser UI target types remain protected. Read-only discovery still redacts the URL **and title** to the protected origin in `getTargets`, `getTargetInfo`, `targetCreated`, `targetInfoChanged` and `attachedToTarget`, including held sessions released later. Path, query and fragment secrets must never survive in those fields. Navigation destinations remain protected: the exception permits recovery, not a protected `Page.navigate` destination.
+
+Main-frame loaders start at `Page.frameStartedNavigating`, excluding `sameDocument` and `historySameDocument`, and end on the corresponding commit, `Network.loadingFailed` with matching requestId, or main-frame `Page.frameStoppedLoading`. A different-document commit clears older loaders; `BackForwardCacheRestore` clears the entire set, even though it reuses the restored document’s old loaderId. A guard that is not ready, cannot parse parameters, or has more than 64 loaders in flight must fail closed. BFCache can report the protected TargetInfo before its restore commit, so waiting for `frameNavigated` alone is not sufficient.
+
 **Privileged-scheme follow-up checks.** With the expanded catalog, fresh default-profile Chrome for Testing 156.0.8078.4 on macOS again committed both NTP entry points to `chrome://new-tab-page/`, with an `about:blank` background child and only `chrome-untrusted://new-tab-page/one-google-bar?paramsencoded=` as its internal-scheme OOPIF. `C8.newtab` passed both attach and ordinary-navigation legs; no `chrome-search` exceptions are added or inferred for other profile/search-provider configurations. Direct `Page.navigate` to `chrome-search://most-visited/` returned `net::ERR_INVALID_URL` and committed `chrome-error://chromewebdata/` with that exact `unreachableUrl`, confirming why `C8.chrome-search` distinguishes a browser response from a guard refusal rather than requiring a successful search-document commit. The catalog-adopting emulator passed every C8 protection row; plain clients failed them, and removing only `chrome-search` from the adopted catalog failed the new row. C1.href, C2.302, C3.popup-self-nav, all tested C4 iframe process layouts and C5.document passed their guarded and control legs with the expanded schemes; plain clients passed controls and failed protection expectations. Those HTTP fixtures deliberately protect only the seven host, leaving their same-site control host ordinary, while adopting every internal-scheme rule unchanged.
 
 **Unparseable URL boundaries.** Fail closed on command destinations: navigation and target creation, the URL and `userTypedURL` of a selected history entry, `Fetch.continueRequest` and legacy interception overrides, `Network.loadNetworkResource`, PWA install/launch, and cookie-command URLs when no domain is supplied. Also fail closed on security-relevant Chrome-reported URLs: targets, main-frame `securityOrigin`, execution-context origins, requests/redirect responses, web sockets and web transports, and service-worker scopes/scripts. A protected default execution context still cuts its session; a protected foreign isolated world stays hidden. This is not a rule to reject arbitrary strings a guard merely reads: storage-command origin keys, storage keys/cache ids, script/stack URLs, generic value redaction and storage events retain the old not-protected result for a parse failure. Cookie domains remain suffix matches, so `exa%20mple.sliccy.ai` is already covered.
@@ -167,7 +171,7 @@ A same-site frame shares its parent's process and has no target of its own. Ever
 
 **Refusals** carry the text in `refusal`, `slicc: refused: target is on seven's origin`.
 
-**`protected.json`** (schema `schema/protected.schema.json`): `unparseable` (`protected`) and `unparseableRefusal`, in step with the catalog; `origins`, the extra origins every vector runs with; `urls` (`url`, `protected`); `targets` (`url`, `type?`, the target's `TargetInfo.type`; `previous?`, whether the target was protected before; `opener?`, `protected`, `unprotected` or `unknown`, and no `opener` for a target without one; `protected`); `cookieDomains` (`domain`, `protected`); `storageKeys` (`key`, `protected`). `npm run validate` runs every vector through `protected.mjs`, and no vector uses a port from 9222 to 9229.
+**`protected.json`** (schema `schema/protected.schema.json`): `errorPage` (the committed-error previous-decision and origin-redaction rule), `unparseable` (`protected`) and `unparseableRefusal`, in step with the catalog; `origins`, the extra origins every vector runs with; `urls` (`url`, `protected`); `targets` (`url`, `documentURL?` and `unreachableURL?` for validated main-frame error-commit evidence, `navigating?` for a main-frame navigation in flight; `type?`, the target's `TargetInfo.type`; `previous?`, whether the target was protected before; `opener?`, `protected`, `unprotected` or `unknown`, and no `opener` for a target without one; `protected`); `cookieDomains` (`domain`, `protected`); `storageKeys` (`key`, `protected`). `npm run validate` runs every vector through `protected.mjs`, and no vector uses a port from 9222 to 9229.
 
 ## Guard vectors
 
@@ -188,6 +192,8 @@ The integration launcher loads shared-web 1.25.2’s harness extension exactly o
 
 The `C8.newtab` reachability control attaches through the guard to a settled ordinary new tab, including its internal frames, then navigates that same tab to an ordinary document. Both legs must succeed, including without a guard. It requires `chromeUrlsAttach`, so an extension transport reports it as `skip` with `not-supported:chromeUrlsAttach`. The C8 protection rows expect a refusal on the guarded leg and run their controls unguarded, so they don't require it and still run on extension transports. It uses the default browser context, since an incognito new tab omits the ordinary new tab's internal frames. It covers `chrome://newtab/` and directly opened `chrome://new-tab-page/`.
 
+`C8.protected-error-page` touches an allowed tab, scripts a protected navigation, and requires the guard to fail its Document request. The independent observer verifies the committed error document and the exact unreachable/reported URL pair. The session stays attached; reload, navigation to `about:blank` and close succeed, while discovery and target events redact URL and title to the origin. The unguarded control uses independent Fetch failure injection and keeps raw discovery values. `C8.protected-document-restore` seeds a real protected document before attachment, navigates away, then restores it from BFCache in the same tab after the error/recovery sequence; evaluate, attach and close must be refused. A real `BackForwardCacheRestore` commit is required, so a second failed network request cannot masquerade as this control. `C8.protected-error-page-sticky` additionally fails a request after that real protected restore and requires the already-protected tab to remain locked. All three require `browserSession`, have unguarded controls and clean up their own targets. The regression tests include URL-only locking, unconditional error-page unlocking, and a plain client with only request-failure injection.
+
 `C8.network-error` and `C8.iframe-error` are ordinary-error reachability controls: request the configured `network-error` URL (default `http://nonexistent.invalid/`) directly or in an ordinary iframe, observe a failed Document request, reattach to the settled tab, evaluate and snapshot its document, then navigate the same tab to an ordinary document. Both control and guarded legs must pass. The failing URL is unchanged on the control, rather than replaced with a healthy origin, and the rows require `browserSession` but not `chromeUrlsAttach`. With Chrome for Testing 156.0.8078.4, scheme-wide `chrome-error` protection made the direct-error row fail both legs because reattachment was refused; removing it passed both rows, with readable DOM and successful recovery. The old emulator still allowed the cross-process iframe parent because the iframe TargetInfo kept the failing HTTP URL, but that layout-specific behavior is not grounds for protecting the error scheme. Plain-client controls and reachability legs also passed both rows.
 
 A client may register `Fetch.enable` patterns naming a protected origin in either of two conformant ways: the guard allows registration but never pauses or forwards protected requests to the client and refuses continue, fulfil or fail calls for request ids it did not hand out; or the guard refuses registration with its declared refusal text. Setup calls explicitly naming a protected placeholder are refusable with `refusal.onlyProtected: true`, and interception-dependent observations depend on that refusal. Wildcard and ordinary-only patterns do not receive this exemption. The ordinary-origin control still runs through the guard and must succeed.
@@ -247,6 +253,8 @@ 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.
 
+`{ "errorPage": "recover", "as": "errorPage", "requires": ["browserSession"] }` (also modes `restore` and `sticky`) runs the protected-error-page compound probe with independent commit evidence, discovery redaction and recovery or sticky-lock checks. The runner leaves this probe’s independent Fetch sessions to the probe rather than answering their pauses itself.
+
 `{ "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`.

package/catalog.json

@@ -738,6 +738,11 @@
     "aboutScheme": "chrome",
     "targetTypes": ["browser_ui"],
     "inheriting": ["about:blank", "about:srcdoc"],
+    "errorPage": {
+      "url": "chrome-error://chromewebdata/",
+      "target": "previous",
+      "redact": "origin"
+    },
     "unparseable": "protected",
     "unparseableRefusal": "slicc: refused: slicc can't parse this URL, so it could be a protected page",
     "refusal": "slicc: refused: target is on seven's origin"

package/guard-runner.mjs

@@ -13,6 +13,7 @@ import {
   result,
   steps,
 } from './guard-driver.mjs';
+import { protectedErrorPage } from './protected-error-page.mjs';
 import { canonicalURL, unparseableURLs } from './unparseable-url.mjs';
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -115,6 +116,7 @@ class Execution {
     this.errors = [];
     this.notes = [];
     this.answers = [];
+    this.internalSessions = new Set();
     this.attachSettings = new Map();
     this.childSteps = [];
     this.deferred = [];
@@ -450,7 +452,10 @@ class Execution {
       for (const event of this.client.events.slice(this.eventStart)) {
         if (this.processed.has(event)) continue;
         this.processed.add(event);
-        if (event.method === 'Fetch.requestPaused' || event.method === 'Fetch.authRequired') {
+        if (
+          (event.method === 'Fetch.requestPaused' || event.method === 'Fetch.authRequired') &&
+          !this.internalSessions.has(event.sessionId)
+        ) {
           this.pending.push(
             this.answer(event).catch((error) => this.errors.push(String(error.message ?? error)))
           );
@@ -604,9 +609,9 @@ class Execution {
       this.errors.push(
         `${step.refusal.name} failed without a refusal: ${String(out.error?.message ?? out.error)}`
       );
-    if ((step.extensionWorld || step.unparseable) && !out.ok)
+    if ((step.extensionWorld || step.unparseable || step.errorPage) && !out.ok)
       this.errors.push(
-        `${step.unparseable ? 'unparseable' : 'extensionWorld'}: ${out.error?.message ?? 'probe failed'}`
+        `${step.unparseable ? 'unparseable' : step.errorPage ? 'errorPage' : 'extensionWorld'}: ${out.error?.message ?? 'probe failed'}`
       );
     if (step.as && !out.result?.pending) this.calls[step.as] = out;
     if (step.cdp) (this.calls.$cdp ??= []).push({ method: step.cdp, ...out });
@@ -657,6 +662,21 @@ class Execution {
       await this.settle(step.settle);
       return;
     }
+    if (step.errorPage)
+      return outcome(
+        protectedErrorPage({
+          client: this.client,
+          reader: this.reader,
+          session,
+          targetId: this.pageTarget,
+          ordinary: this.vars.ordinary,
+          protectedOrigin: this.vars.seven,
+          tag: this.vars.tag,
+          internalSessions: this.internalSessions,
+          mode: step.errorPage,
+          side: this.side,
+        })
+      );
     if (step.unparseable)
       return outcome(
         unparseableURLs({

package/guard-vectors.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "setVersion": "1.10.3",
+  "setVersion": "1.11.0",
   "sources": [
     {
       "repo": "ai-ecoverse/slicc-cli",
@@ -118,6 +118,464 @@
     "browserUi": "the id of one of Chrome's own browser_ui targets, which the runner looks up with its own CDP"
   },
   "vectors": [
+    {
+      "id": "C8.protected-error-page",
+      "family": "C",
+      "kind": "cdp",
+      "scope": "any",
+      "defaultContext": true,
+      "setup": [
+        {
+          "page": "tab",
+          "url": "{ordinary}/blank"
+        }
+      ],
+      "trigger": [
+        {
+          "errorPage": "recover",
+          "requires": ["browserSession"],
+          "as": "errorPage"
+        }
+      ],
+      "targets": ["seven"],
+      "requires": ["browserSession"],
+      "observe": {
+        "live": {
+          "means": "protected error-page recover: live",
+          "check": {
+            "result": "errorPage",
+            "path": "result.live",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "attached": {
+          "means": "protected error-page recover: attached",
+          "check": {
+            "result": "errorPage",
+            "path": "result.attached",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "infoRedacted": {
+          "means": "protected error-page recover: infoRedacted",
+          "check": {
+            "result": "errorPage",
+            "path": "result.infoRedacted",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "listRedacted": {
+          "means": "protected error-page recover: listRedacted",
+          "check": {
+            "result": "errorPage",
+            "path": "result.listRedacted",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "eventsRedacted": {
+          "means": "protected error-page recover: eventsRedacted",
+          "check": {
+            "result": "errorPage",
+            "path": "result.eventsRedacted",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "reload": {
+          "means": "protected error-page recover: reload",
+          "check": {
+            "result": "errorPage",
+            "path": "result.reload",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "blank": {
+          "means": "protected error-page recover: blank",
+          "check": {
+            "result": "errorPage",
+            "path": "result.blank",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "close": {
+          "means": "protected error-page recover: close",
+          "check": {
+            "result": "errorPage",
+            "path": "result.close",
+            "equals": true,
+            "observer": "client"
+          }
+        }
+      },
+      "live": "the independent observer sees chrome-error://chromewebdata/ with unreachableUrl exactly matching targetInfo.url; real-document controls require a BackForwardCacheRestore commit",
+      "liveCheck": {
+        "result": "errorPage",
+        "path": "result.live",
+        "equals": true,
+        "observer": "client"
+      },
+      "control": {
+        "origin": "ordinary",
+        "via": "unguarded",
+        "expected": {
+          "live": true,
+          "attached": true,
+          "infoRedacted": false,
+          "listRedacted": false,
+          "eventsRedacted": false,
+          "reload": true,
+          "blank": true,
+          "close": true
+        }
+      },
+      "expected": {
+        "live": true,
+        "attached": true,
+        "infoRedacted": true,
+        "listRedacted": true,
+        "eventsRedacted": true,
+        "reload": true,
+        "blank": true,
+        "close": true
+      }
+    },
+    {
+      "id": "C8.protected-document-restore",
+      "family": "C",
+      "kind": "cdp",
+      "scope": "any",
+      "defaultContext": true,
+      "setup": [
+        {
+          "page": "tab",
+          "url": "{ordinary}/blank"
+        }
+      ],
+      "trigger": [
+        {
+          "errorPage": "restore",
+          "requires": ["browserSession"],
+          "as": "errorPage"
+        }
+      ],
+      "targets": ["seven"],
+      "requires": ["browserSession"],
+      "observe": {
+        "live": {
+          "means": "protected error-page restore: live",
+          "check": {
+            "result": "errorPage",
+            "path": "result.live",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "attached": {
+          "means": "protected error-page restore: attached",
+          "check": {
+            "result": "errorPage",
+            "path": "result.attached",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "infoRedacted": {
+          "means": "protected error-page restore: infoRedacted",
+          "check": {
+            "result": "errorPage",
+            "path": "result.infoRedacted",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "listRedacted": {
+          "means": "protected error-page restore: listRedacted",
+          "check": {
+            "result": "errorPage",
+            "path": "result.listRedacted",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "eventsRedacted": {
+          "means": "protected error-page restore: eventsRedacted",
+          "check": {
+            "result": "errorPage",
+            "path": "result.eventsRedacted",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "reload": {
+          "means": "protected error-page restore: reload",
+          "check": {
+            "result": "errorPage",
+            "path": "result.reload",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "blank": {
+          "means": "protected error-page restore: blank",
+          "check": {
+            "result": "errorPage",
+            "path": "result.blank",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "restored": {
+          "means": "protected error-page restore: restored",
+          "check": {
+            "result": "errorPage",
+            "path": "result.restored",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "evaluateRefused": {
+          "means": "protected error-page restore: evaluateRefused",
+          "check": {
+            "result": "errorPage",
+            "path": "result.evaluateRefused",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "attachRefused": {
+          "means": "protected error-page restore: attachRefused",
+          "check": {
+            "result": "errorPage",
+            "path": "result.attachRefused",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "closeRefused": {
+          "means": "protected error-page restore: closeRefused",
+          "check": {
+            "result": "errorPage",
+            "path": "result.closeRefused",
+            "equals": true,
+            "observer": "client"
+          }
+        }
+      },
+      "live": "the independent observer sees chrome-error://chromewebdata/ with unreachableUrl exactly matching targetInfo.url; real-document controls require a BackForwardCacheRestore commit",
+      "liveCheck": {
+        "result": "errorPage",
+        "path": "result.live",
+        "equals": true,
+        "observer": "client"
+      },
+      "control": {
+        "origin": "ordinary",
+        "via": "unguarded",
+        "expected": {
+          "live": true,
+          "attached": true,
+          "infoRedacted": false,
+          "listRedacted": false,
+          "eventsRedacted": false,
+          "reload": true,
+          "blank": true,
+          "restored": true,
+          "evaluateRefused": false,
+          "attachRefused": false,
+          "closeRefused": false
+        }
+      },
+      "expected": {
+        "live": true,
+        "attached": true,
+        "infoRedacted": true,
+        "listRedacted": true,
+        "eventsRedacted": true,
+        "reload": true,
+        "blank": true,
+        "restored": true,
+        "evaluateRefused": true,
+        "attachRefused": true,
+        "closeRefused": true
+      }
+    },
+    {
+      "id": "C8.protected-error-page-sticky",
+      "family": "C",
+      "kind": "cdp",
+      "scope": "any",
+      "defaultContext": true,
+      "setup": [
+        {
+          "page": "tab",
+          "url": "{ordinary}/blank"
+        }
+      ],
+      "trigger": [
+        {
+          "errorPage": "sticky",
+          "requires": ["browserSession"],
+          "as": "errorPage"
+        }
+      ],
+      "targets": ["seven"],
+      "requires": ["browserSession"],
+      "observe": {
+        "live": {
+          "means": "protected error-page sticky: live",
+          "check": {
+            "result": "errorPage",
+            "path": "result.live",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "attached": {
+          "means": "protected error-page sticky: attached",
+          "check": {
+            "result": "errorPage",
+            "path": "result.attached",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "infoRedacted": {
+          "means": "protected error-page sticky: infoRedacted",
+          "check": {
+            "result": "errorPage",
+            "path": "result.infoRedacted",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "listRedacted": {
+          "means": "protected error-page sticky: listRedacted",
+          "check": {
+            "result": "errorPage",
+            "path": "result.listRedacted",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "eventsRedacted": {
+          "means": "protected error-page sticky: eventsRedacted",
+          "check": {
+            "result": "errorPage",
+            "path": "result.eventsRedacted",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "reload": {
+          "means": "protected error-page sticky: reload",
+          "check": {
+            "result": "errorPage",
+            "path": "result.reload",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "blank": {
+          "means": "protected error-page sticky: blank",
+          "check": {
+            "result": "errorPage",
+            "path": "result.blank",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "restored": {
+          "means": "protected error-page sticky: restored",
+          "check": {
+            "result": "errorPage",
+            "path": "result.restored",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "evaluateRefused": {
+          "means": "protected error-page sticky: evaluateRefused",
+          "check": {
+            "result": "errorPage",
+            "path": "result.evaluateRefused",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "attachRefused": {
+          "means": "protected error-page sticky: attachRefused",
+          "check": {
+            "result": "errorPage",
+            "path": "result.attachRefused",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "closeRefused": {
+          "means": "protected error-page sticky: closeRefused",
+          "check": {
+            "result": "errorPage",
+            "path": "result.closeRefused",
+            "equals": true,
+            "observer": "client"
+          }
+        },
+        "stickyError": {
+          "means": "protected error-page sticky: stickyError",
+          "check": {
+            "result": "errorPage",
+            "path": "result.stickyError",
+            "equals": true,
+            "observer": "client"
+          }
+        }
+      },
+      "live": "the independent observer sees chrome-error://chromewebdata/ with unreachableUrl exactly matching targetInfo.url; real-document controls require a BackForwardCacheRestore commit",
+      "liveCheck": {
+        "result": "errorPage",
+        "path": "result.live",
+        "equals": true,
+        "observer": "client"
+      },
+      "control": {
+        "origin": "ordinary",
+        "via": "unguarded",
+        "expected": {
+          "live": true,
+          "attached": true,
+          "infoRedacted": false,
+          "listRedacted": false,
+          "eventsRedacted": false,
+          "reload": true,
+          "blank": true,
+          "restored": true,
+          "evaluateRefused": false,
+          "attachRefused": false,
+          "closeRefused": false,
+          "stickyError": true
+        }
+      },
+      "expected": {
+        "live": true,
+        "attached": true,
+        "infoRedacted": true,
+        "listRedacted": true,
+        "eventsRedacted": true,
+        "reload": true,
+        "blank": true,
+        "restored": true,
+        "evaluateRefused": true,
+        "attachRefused": true,
+        "closeRefused": true,
+        "stickyError": true
+      }
+    },
     {
       "id": "C8.unparseable",
       "family": "C",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-browsers",
-  "version": "1.10.3",
+  "version": "1.11.0",
   "description": "SLICC's shared browser catalog, JSON schemas and discovery conformance corpus",
   "type": "module",
   "license": "Apache-2.0",
@@ -52,7 +52,8 @@
     "guard-runner.mjs",
     "fixture-server.mjs",
     "extension-world.mjs",
-    "unparseable-url.mjs"
+    "unparseable-url.mjs",
+    "protected-error-page.mjs"
   ],
   "scripts": {
     "prepare": "lefthook install",
@@ -67,14 +68,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/integration/guard-shared-log.test.mjs test/integration/self-contained.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-error-page.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.27.0",
+    "@ai-ecoverse/slicc-shared-web": "1.28.0",
     "@biomejs/biome": "2.5.15",
     "ajv": "8.20.0",
     "ajv-formats": "3.0.1",

package/protected-error-page.mjs

@@ -0,0 +1,243 @@
+import { outcome } from './guard-driver.mjs';
+
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const refused = (out) => !out.ok && /^slicc: refused:/.test(out.error?.message ?? '');
+
+async function until(check) {
+  const deadline = Date.now() + 5000;
+  do {
+    if (await check()) return true;
+    await pause(25);
+  } while (Date.now() < deadline);
+  return false;
+}
+
+async function loadedDocument(reader, observer, url) {
+  return until(async () => {
+    const { frameTree } = await reader.send('Page.getFrameTree', {}, observer);
+    if (frameTree.frame.url !== url || frameTree.frame.unreachableUrl) return false;
+    const ready = await outcome(
+      reader.send(
+        'Runtime.evaluate',
+        { expression: 'document.readyState', returnByValue: true },
+        observer
+      )
+    );
+    return ready.result?.result?.value === 'complete';
+  });
+}
+
+async function lockChecks({ client, session, targetId, result }) {
+  result.evaluateRefused = refused(
+    await outcome(
+      client.send(
+        'Runtime.evaluate',
+        { expression: 'document.title', returnByValue: true },
+        session
+      )
+    )
+  );
+  result.attachRefused = refused(
+    await outcome(client.send('Target.attachToTarget', { targetId, flatten: true }))
+  );
+  result.closeRefused = refused(await outcome(client.send('Target.closeTarget', { targetId })));
+}
+
+async function redaction({ client, targetId, failedURL, protectedOrigin, start, result }) {
+  const info = await outcome(client.send('Target.getTargetInfo', { targetId }));
+  const list = await outcome(client.send('Target.getTargets'));
+  const origin = new URL(failedURL).origin;
+  result.infoRedacted =
+    info.ok && info.result.targetInfo.url === origin && info.result.targetInfo.title === origin;
+  result.listRedacted =
+    list.ok &&
+    list.result.targetInfos.some(
+      (i) => i.targetId === targetId && i.url === origin && i.title === origin
+    );
+  await pause(100);
+  const targetEvents = client.events
+    .slice(start)
+    .filter(
+      (e) =>
+        e.params?.targetInfo?.targetId === targetId &&
+        e.params.targetInfo.url.includes(new URL(protectedOrigin).host)
+    );
+  result.eventsRedacted =
+    targetEvents.length > 0 &&
+    targetEvents.every(
+      (e) => e.params.targetInfo.url === origin && e.params.targetInfo.title === origin
+    );
+}
+
+export async function protectedErrorPage({
+  client,
+  reader,
+  ordinary,
+  protectedOrigin,
+  tag,
+  mode,
+  side,
+  internalSessions = new Set(),
+}) {
+  const initial = `${protectedOrigin}/doc?n=${tag}-history`;
+  const failedURL = `${protectedOrigin}/doc/path-secret-${tag}?query-secret=${tag}#fragment-secret-${tag}`;
+  const result = {};
+  const start = client.events.length;
+  const { targetId } = await reader.send('Target.createTarget', { url: initial, background: true });
+  let session;
+  let observer;
+  let failing = false;
+  let cursor = reader.events.length;
+  const { sessionId } = await reader.send('Target.attachToTarget', { targetId, flatten: true });
+  observer = sessionId;
+  internalSessions.add(observer);
+  const frame = async () => (await reader.send('Page.getFrameTree', {}, observer)).frameTree.frame;
+  const loaded = (url) => loadedDocument(reader, observer, url);
+  let stopped = false;
+  const fail = (async () => {
+    while (!stopped) {
+      for (const event of reader.events.slice(cursor)) {
+        cursor++;
+        if (event.method === 'Fetch.requestPaused' && event.sessionId === observer)
+          await outcome(
+            reader.send(
+              failing ? 'Fetch.failRequest' : 'Fetch.continueRequest',
+              failing
+                ? { requestId: event.params.requestId, errorReason: 'BlockedByClient' }
+                : { requestId: event.params.requestId },
+              observer
+            )
+          );
+      }
+      await pause(5);
+    }
+  })();
+  try {
+    await reader.send('Page.enable', {}, observer);
+    if (!(await loaded(initial)))
+      throw new Error('protected-error-page: history seed did not commit');
+    await reader.send('Page.navigate', { url: `${ordinary}/blank` }, observer);
+    if (!(await loaded(`${ordinary}/blank`)))
+      throw new Error('protected-error-page: allowed document did not commit');
+    const attached = await outcome(
+      client.send('Target.attachToTarget', { targetId, flatten: true })
+    );
+    session = attached.result?.sessionId;
+    if (!session) return { live: false, attached: false };
+    await client.send('Page.enable', {}, session);
+    await client.send('Runtime.enable', {}, session);
+    await client.send('Target.setDiscoverTargets', { discover: true });
+    if (side === 'control') {
+      failing = true;
+      await reader.send(
+        'Fetch.enable',
+        { patterns: [{ resourceType: 'Document', requestStage: 'Request' }] },
+        observer
+      );
+    }
+    await client.send(
+      'Runtime.evaluate',
+      { expression: `setTimeout(()=>location.href=${JSON.stringify(failedURL)},0)` },
+      session
+    );
+    result.live = await until(async () => {
+      const f = await frame();
+      const { targetInfo } = await reader.send('Target.getTargetInfo', { targetId });
+      result.evidence = { frame: f, targetInfo };
+      return (
+        f.url === 'chrome-error://chromewebdata/' &&
+        f.securityOrigin === '://' &&
+        f.unreachableUrl === failedURL &&
+        targetInfo.url === failedURL
+      );
+    });
+    if (!result.live && side !== 'control') return result;
+    if (!result.live)
+      throw new Error(
+        `protected-error-page: missing error commit ${JSON.stringify(result.evidence)}`
+      );
+    await redaction({ client, targetId, failedURL, protectedOrigin, start, result });
+    const beforeReload = (await frame()).loaderId;
+    result.reload = (await outcome(client.send('Page.reload', {}, session))).ok;
+    if (result.reload) {
+      result.reloadedError = await until(async () => {
+        const f = await frame();
+        return f.loaderId !== beforeReload && f.unreachableUrl === failedURL;
+      });
+      result.reload = result.reloadedError;
+    }
+    result.blank = (
+      await outcome(client.send('Page.navigate', { url: 'about:blank' }, session))
+    ).ok;
+    if (result.blank) result.blank = await loaded('about:blank');
+    result.attached = !client.events
+      .slice(start)
+      .some((e) => e.method === 'Target.detachedFromTarget' && e.params.sessionId === session);
+    if (mode === 'recover') {
+      if (result.blank) {
+        await client.send(
+          'Runtime.evaluate',
+          { expression: `setTimeout(()=>location.href=${JSON.stringify(failedURL)},0)` },
+          session
+        );
+        result.closeError = await until(async () => (await frame()).unreachableUrl === failedURL);
+      }
+      result.attached &&= !client.events
+        .slice(start)
+        .some((e) => e.method === 'Target.detachedFromTarget' && e.params.sessionId === session);
+      const close = await outcome(client.send('Target.closeTarget', { targetId }));
+      result.close = result.closeError === true && close.result?.success === true;
+      return result;
+    }
+    if (side === 'control') await reader.send('Fetch.disable', {}, observer);
+    failing = false;
+    const { entries, currentIndex } = await reader.send('Page.getNavigationHistory', {}, observer);
+    const index = entries.findIndex((e) => e.url === initial);
+    if (index < 0) throw new Error('protected-error-page: missing protected history');
+    const beforeRestore = reader.events.length;
+    await reader.send(
+      'Runtime.evaluate',
+      { expression: `history.go(${index - currentIndex})` },
+      observer
+    );
+    result.restored = await until(() =>
+      reader.events
+        .slice(beforeRestore)
+        .some(
+          (e) =>
+            e.sessionId === observer &&
+            e.method === 'Page.frameNavigated' &&
+            e.params.type === 'BackForwardCacheRestore' &&
+            e.params.frame.url === initial
+        )
+    );
+    if (!result.restored)
+      throw new Error('protected-error-page: real protected BFCache restore required');
+    await pause(100);
+    if (mode === 'sticky') {
+      await reader.send('Target.detachFromTarget', { sessionId: observer });
+      observer = (await reader.send('Target.attachToTarget', { targetId, flatten: true }))
+        .sessionId;
+      internalSessions.add(observer);
+      failing = true;
+      await reader.send(
+        'Fetch.enable',
+        { patterns: [{ resourceType: 'Document', requestStage: 'Request' }] },
+        observer
+      );
+      await reader.send('Page.navigate', { url: failedURL }, observer);
+      result.stickyError = await until(async () => (await frame()).unreachableUrl === failedURL);
+      if (!result.stickyError)
+        throw new Error(
+          `protected-error-page: missing sticky error ${JSON.stringify(await frame())}`
+        );
+      await pause(100);
+    }
+    await lockChecks({ client, session, targetId, result });
+    return result;
+  } finally {
+    stopped = true;
+    await fail;
+    await outcome(reader.send('Target.closeTarget', { targetId }));
+  }
+}

package/protected.json

@@ -1,5 +1,6 @@
 {
   "schema": 1,
+  "errorPage": { "url": "chrome-error://chromewebdata/", "target": "previous", "redact": "origin" },
   "unparseable": "protected",
   "unparseableRefusal": "slicc: refused: slicc can't parse this URL, so it could be a protected page",
   "origins": ["http://127.0.0.1:5710", "https://seven.example.test"],
@@ -738,6 +739,42 @@
     }
   ],
   "targets": [
+    {
+      "url": "https://seven.sliccy.ai/path?secret=query#fragment",
+      "documentURL": "chrome-error://chromewebdata/",
+      "unreachableURL": "https://seven.sliccy.ai/other",
+      "protected": true
+    },
+    {
+      "url": "https://seven.sliccy.ai/path?secret=query#fragment",
+      "documentURL": "chrome-error://chromewebdata/",
+      "unreachableURL": "https://seven.sliccy.ai/path?secret=query#fragment",
+      "navigating": true,
+      "protected": true
+    },
+    {
+      "url": "https://seven.sliccy.ai/path?secret=query#fragment",
+      "documentURL": "chrome-error://chromewebdata/",
+      "protected": true
+    },
+    {
+      "url": "https://seven.sliccy.ai/path?secret=query#fragment",
+      "documentURL": "chrome-error://chromewebdata/",
+      "unreachableURL": "https://seven.sliccy.ai/path?secret=query#fragment",
+      "protected": false
+    },
+    {
+      "url": "https://seven.sliccy.ai/path?secret=query#fragment",
+      "documentURL": "chrome-error://chromewebdata/",
+      "unreachableURL": "https://seven.sliccy.ai/path?secret=query#fragment",
+      "previous": true,
+      "protected": true
+    },
+    {
+      "url": "https://seven.sliccy.ai/path?secret=query#fragment",
+      "documentURL": "https://seven.sliccy.ai/path?secret=query#fragment",
+      "protected": true
+    },
     {
       "url": "http://exa mple.sliccy.ai/",
       "protected": true

package/protected.mjs

@@ -68,8 +68,23 @@ export function protectedOrigins(rules, extraOrigins = []) {
     );
   };
 
-  const target = ({ url: text, previous = false, opener, type }) => {
+  const target = ({
+    url: text,
+    previous = false,
+    opener,
+    type,
+    documentURL,
+    unreachableURL,
+    navigating = false,
+  }) => {
     if (type && (rules.targetTypes ?? []).includes(type)) return true;
+    if (
+      rules.errorPage &&
+      documentURL === rules.errorPage.url &&
+      unreachableURL === text &&
+      !navigating
+    )
+      return previous;
     if (inheriting(text)) return previous || opener === 'protected' || opener === 'unknown';
     return url(text);
   };

package/schema/catalog.schema.json

@@ -227,6 +227,16 @@
           "uniqueItems": true,
           "items": { "type": "string", "pattern": "^about:[a-z]+$" }
         },
+        "errorPage": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["url", "target", "redact"],
+          "properties": {
+            "url": { "const": "chrome-error://chromewebdata/" },
+            "target": { "const": "previous" },
+            "redact": { "const": "origin" }
+          }
+        },
         "unparseable": { "const": "protected" },
         "unparseableRefusal": {
           "const": "slicc: refused: slicc can't parse this URL, so it could be a protected page"

package/schema/guard-vectors.schema.json

@@ -427,6 +427,16 @@
     },
     "step": {
       "oneOf": [
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["errorPage", "as"],
+          "properties": {
+            "errorPage": { "enum": ["recover", "restore", "sticky"] },
+            "requires": { "$ref": "#/$defs/requires" },
+            "as": { "$ref": "#/$defs/name" }
+          }
+        },
         {
           "type": "object",
           "additionalProperties": false,

package/schema/protected.schema.json

@@ -16,6 +16,16 @@
   ],
   "properties": {
     "schema": { "const": 1 },
+    "errorPage": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["url", "target", "redact"],
+      "properties": {
+        "url": { "const": "chrome-error://chromewebdata/" },
+        "target": { "const": "previous" },
+        "redact": { "const": "origin" }
+      }
+    },
     "unparseable": { "const": "protected" },
     "unparseableRefusal": {
       "const": "slicc: refused: slicc can't parse this URL, so it could be a protected page"
@@ -43,6 +53,9 @@
           "url": { "type": "string" },
           "type": { "type": "string" },
           "previous": { "type": "boolean" },
+          "documentURL": { "type": "string" },
+          "unreachableURL": { "type": "string" },
+          "navigating": { "type": "boolean" },
           "opener": { "enum": ["protected", "unprotected", "unknown"] },
           "protected": { "type": "boolean" }
         }