@ai-ecoverse/slicc 1.50.1 → 1.50.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/README.md +14 -9
  2. package/package.json +7 -7
package/README.md CHANGED
@@ -355,7 +355,7 @@ Without `--browser`, the first row of the ranking that can host seven is chosen,
355
355
 
356
356
  **What the link offers:** `net` (tcp, resolve), `http`, `ws`, `udp`, and `cdp` with the browser that hosts seven (`seven: true`) and every extra, under the local policy with all of their debugging ports protected, and this machine's other debugging ports too (see [Network policy](#network-policy)); and kernel services on `--kernel-port` (default 80, or a spare port when this user can't have 80; `--no-kernel` turns them off) when seven offers `kernel-in` (see [Kernel services](#kernel-services)); and `ssh` only with `--runner` (see [SSH server](#ssh-server)); and `fs` with each `--mount` folder (see [Host folders](#host-folders)). seven gets full control of every listed browser, the one it runs in too. The `cdp` list (HELLO `browsers`) has only the browser that hosts seven and the extras picked with `--browser` or in the picker; the other browsers discovery found are never offered.
357
357
 
358
- The cdp list follows the browsers: an extra that stops answering is taken off the list (`browser-gone`), and listed again with the same id when it answers on the same endpoint again (`browser-back`). An extra that never made the list, because it has no browser session (see [What a browser must offer](#cdp-browser-control)), gets one `browser-gone` right after the link starts.
358
+ The cdp list follows the browsers: an extra that stops answering is taken off the list (`browser-gone`), and listed again with the same id when it answers on the same endpoint again (`browser-back`). An extra that never made the list, because it has no browser session (see [What a browser must offer](#cdp-browser-control)), gets one `browser-gone` with `reason` `no-browser-session` right after the link starts. Plain mode says `seven can't drive <name> through slicc: it has no browser session, so slicc can't watch its tabs or keep seven's origin out of them. It isn't listed for cdp; the rest of the link works` for it, and the dashboard `<name> isn't listed for cdp: it has no browser session`, where an extra that stops answering gets `<name> quit; it is no longer listed for cdp` and `<name> quit`.
359
359
 
360
360
  **Flags.**
361
361
  - `--browser <id>`: an id from `slicc browsers` (an installed id such as `chrome`, or `cdp:<host>:<port>`), or a name, case-insensitively. Repeatable: the first hosts seven, the others are extras. Without it, the best match that can host seven. An endpoint in SLICC six's profile is refused (`<id> is SLICC six's Chrome; only --profile six uses it`).
@@ -381,7 +381,7 @@ The cdp list follows the browsers: an extra that stops answering is taken off th
381
381
  | Esc | back, in the profile chooser |
382
382
  | `q`, Ctrl-C | quit; in the dashboard, close down as described above |
383
383
 
384
- **The dashboard** follows, in sections: BROWSERS (launched or attached, their CDP port, hosts seven or extra, and `gone` while one doesn't answer); SEVEN (the tab, the link state (`waiting for seven`, `connecting`, `linked` with its uptime, `reconnecting` after a link is lost, while slicc waits for seven to offer again, or `relinking` while new capabilities are applied), the policy summary, and stream counts per kind, open and total, never contents); CAPABILITIES (the network capabilities always offered, then `jerk`, `shell` with `ssh via <runner>`, `kernel` with its URL, or why it is off, and the shared folders); RECENT (the last status lines, links in green, losses in yellow, errors in red); and the update notice, which then isn't printed on stderr. Keys: `c` capabilities, `m` share a folder, `q` quit. `NO_COLOR` turns colors off.
384
+ **The dashboard** follows, in sections: BROWSERS (launched or attached, their CDP port, hosts seven or extra, `gone` while one doesn't answer, and `unlisted` for an extra left off the cdp list because it has no browser session); SEVEN (the tab, the link state (`waiting for seven`, `connecting`, `linked` with its uptime, `reconnecting` after a link is lost, while slicc waits for seven to offer again, or `relinking` while new capabilities are applied), the policy summary, and stream counts per kind, open and total, never contents); CAPABILITIES (the network capabilities always offered, then `jerk`, `shell` with `ssh via <runner>`, `kernel` with its URL, or why it is off, and the shared folders); RECENT (the last status lines, links in green, losses in yellow, errors in red); and the update notice, which then isn't printed on stderr. Keys: `c` capabilities, `m` share a folder, `q` quit. `NO_COLOR` turns colors off.
385
385
 
386
386
  **The dashboard after `Default browser`** links seven over loopback, as `slicc open` does, and opens the pairing URL in the default browser. In place of BROWSERS it shows `Default browser paired over loopback · no cdp hosts seven`; SEVEN starts with the pairing URL (a link where the terminal supports it, wrapped to the terminal's width, good once, for 10 minutes) until seven links, then `↵ for a URL to pair another seven`. The other sections are as above. Its capabilities are those of the command line: the capabilities screen and `m` aren't offered, so changing them means restarting slicc. Keys: `↵` a new pairing URL, `y` copies the URL to the clipboard (OSC 52), `q` quit.
387
387
 
@@ -396,7 +396,7 @@ The cdp list follows the browsers: an extra that stops answering is taken off th
396
396
  - `foreign-browser`: `browser`, `name`, `profile?`, `cdp`, `openedTab` (`true` when slicc opened the seven tab, `false` when one was open). It follows `attached` when the browser hosting seven is an endpoint slicc didn't launch and the user didn't choose it (see above), and always when it is SLICC six's Chrome, with `profile` `six` or `six:<port>`. The same line goes to stderr.
397
397
  - `linked`: `peer?` (the name in seven's HELLO), `tab?` (the seven tab's origin, never its path or fragment), `caps`, `policy` (the summary).
398
398
  - `link-lost`: `reason?` when slicc or seven closed the link (`slicc is exiting`, `slicc is relinking`, seven's `bye` reason, `replaced by a new offer`), or `message?` for a failure. seven sets the link up again after a reload, and a new `linked` follows.
399
- - `browser-gone`, `browser-back`: `browser`, `name`, `role`. A browser stopped answering and left the cdp list, or answers again and is back on it.
399
+ - `browser-gone`, `browser-back`: `browser`, `name`, `role`. A browser stopped answering and left the cdp list, or answers again and is back on it. A `browser-gone` with `reason` `no-browser-session` is for an extra that was never listed, because it has no browser session.
400
400
  - `browser-slow`: `browser`, `name`, `role`, `elapsed` (seconds). A browser slicc launched hasn't written its `DevToolsActivePort` yet, every 10 s from 10 s on (see [`slicc launch`](#slicc-launch---browser-id---profile-name---url-url---headless---no-seven-flags---json)). The dashboard and plain mode show it as `<name> is still starting (slow disk?), <n> s so far`.
401
401
  - `closed`: `browsers`, the ids slicc closed (always a list). It is the last event of every run that got past choosing its browsers.
402
402
  - `error`: `message`, and `browser?` when closing that browser failed. A setup error ends the run with exit 1.
@@ -780,7 +780,7 @@ A page RESET or a closed link kills the jerk it started.
780
780
 
781
781
  Only browsers the user named are listed: the one seven runs in, `--cdp` and `--cdp-extra` for `attach`, the extras picked with `--browser` or in the picker for `slicc`, and `--cdp` for `follow`. A browser discovery found but nobody picked is not.
782
782
 
783
- **What a browser must offer.** The filter below needs the browser to pause requests and to report targets on a session of the node's own, so a `cdp` stream needs `Target.attachToBrowserTarget`, and every page it touches needs `Fetch.enable` to take the node's URL patterns and really pause what matches. When `attach`, `follow` or plain `slicc` adds a browser, the node opens one socket and calls `Target.attachToBrowserTarget`. A `wsOnly` browser is skipped, since that is Chrome's opt-in debugging of a running browser, where a socket can raise a consent dialog for a connection that's already gone, so it opens no socket until a stream does. A browser that answers `-32601` isn't listed: slicc says `seven can't drive this browser through slicc`, or logs it in plain `slicc`, and the link goes on without it, without the `cdp` cap when it was the only one. A socket that fails or doesn't answer within 2 s doesn't count, and the stream decides. A browser that has the session but refuses `Fetch.enable` on a page gets `slicc can't keep seven's origin out of this target` on that page. An acknowledgment has to mean a real pause: measured against a browser that acknowledged `Fetch.enable` without pausing, a script's `location = …` into a protected origin loaded it, and a `Runtime.evaluate` racing the commit read the protected page before the node saw it move.
783
+ **What a browser must offer.** The filter below needs the browser to pause requests and to report targets on a session of the node's own, so a `cdp` stream needs `Target.attachToBrowserTarget`, and every page it touches needs `Fetch.enable` to take the node's URL patterns and really pause what matches. When `attach`, `follow` or plain `slicc` adds a browser, the node opens one socket and calls `Target.attachToBrowserTarget`. A `wsOnly` browser is skipped, since that is Chrome's opt-in debugging of a running browser, where a socket can raise a consent dialog for a connection that's already gone, so it opens no socket until a stream does. A browser that answers `-32601` isn't listed: slicc says `seven can't drive this browser through slicc` (plain `slicc` names the browser, and the dashboard says `<name> isn't listed for cdp`; see [The default](#the-default-slicc)), and the link goes on without it, without the `cdp` cap when it was the only one. A socket that fails or doesn't answer within 2 s doesn't count, and the stream decides. A browser that has the session but refuses `Fetch.enable` on a page gets `slicc can't keep seven's origin out of this target` on that page. An acknowledgment has to mean a real pause: measured against a browser that acknowledged `Fetch.enable` without pausing, a script's `location = …` into a protected origin loaded it, and a `Runtime.evaluate` racing the commit read the protected page before the node saw it move.
784
784
 
785
785
  **HELLO** lists the browsers: `"browsers": [{ "id": "chrome", "name": "Chrome (headless)", "version": "154.0.8037.98", "seven": true }]`. Every entry has all four fields.
786
786
  - `id` is the browser kind, then `-2`, `-3`… for a second or third of the same kind. The kind comes from `/json/version`: `electron` for an Electron user agent, else by product `chrome` (also `HeadlessChrome`, and browsers such as Brave that report `Chrome`), `edge` (`Edg`), `opera` (`OPR`), else the product lower-cased up to a `/` or `(`, else `chromium`. So `Crest (WebKit)` is `crest`.
@@ -807,7 +807,7 @@ Only browsers the user named are listed: the one seven runs in, `--cdp` and `--c
807
807
  - **URLs slicc can't parse** count as protected wherever the node judges a URL the browser will load or has loaded. Chrome's parser and the node's (WHATWG) disagree at the edges: Chrome loads `http://exa mple.sliccy.ai/` as `http://exa%20mple.sliccy.ai/`, a `sliccy.ai` host that gets seven's cookies, and, in some versions, `http://<U+200D>.sliccy.ai/` as `http://xn--1ug.sliccy.ai/`, and the node's parser rejects all of those forms. So a command whose destination doesn't parse (`url` of `Target.createTarget`, `Page.navigate`, `Fetch.continueRequest`, `Network.continueInterceptedRequest`, `Network.loadNetworkResource` and `PWA.launch`, `installUrlOrOrigin` of `PWA.install`, the `url` of a cookie command or any of the `urls` of `Network.getCookies` and `Page.getCookies`, and a history entry's `url` or `userTypedURL`) is refused with `slicc: refused: slicc can't parse this URL, so it could be a protected page`. An empty URL is fine (`Target.createTarget` with `url: ""` opens `about:blank`). On the browser's side, a target, a main frame's `securityOrigin`, an execution context's `origin`, a request or WebSocket, and a service worker whose URL doesn't parse are protected like seven's: left out of listings (see Listing), not attachable, detached, hidden, their document loads failed and their requests stripped. The opaque origins `null` and `://` are not affected. A `blob:null/…` URL (a blob made on an opaque origin, such as a `data:` page or a sandboxed frame) is: its inner `null/…` doesn't parse, and slicc can't name the blob's creator, so it is protected too. URLs the node only reads, such as storage keys and script URLs, are unaffected. In what the page gets, a URL that doesn't parse is cut whole (to an empty string), because it has no origin to keep. The cost: a page on a host that Chrome accepts and WHATWG doesn't (an invalid `xn--` label, a joiner such as U+200D, a space or another forbidden code point), and Chrome's error page for one, is cut too, and navigating to it is refused. URLs Chrome rejects as well (`http://[::1`, `http://a:99999/`, `http://1.2.3.4.5/`) lose nothing: Chrome answers `Page.navigate` with `Cannot navigate to invalid URL`, and `Target.createTarget` with a tab that never loads a document.
808
808
  - **Refused**, with `{"id":…,"sessionId"?:…,"error":{"code":-32000,"message":"slicc: refused: target is on seven's origin"}}`, never forwarded: `Target.createTarget`, `Page.navigate` and anything else whose `url` is protected (one that doesn't parse is refused with `slicc: refused: slicc can't parse this URL, so it could be a protected page`, see above); `Page.navigateToHistoryEntry` to an entry whose URL is protected (the node looks it up with `Page.getNavigationHistory`); `Target.attachToTarget`, `activateTarget`, `closeTarget`, `autoAttachRelated`, `Browser.getWindowForTarget` and any other command whose `targetId` or `frameId` is a protected target; and every command on a session whose target is protected, or became so. `Target.getTargetInfo` and `Target.detachFromTarget` stay allowed, except `Target.getTargetInfo` on a hidden target (see *Listing*).
809
809
  - **Origins and storage.** A command whose `origin`, `securityOrigin`, `ownerOrigin`, `issuerOrigin`, `topLevelOrigin`, `topLevelSite`, `embeddedOrigin`, `requestingOrigin`, `scopeURL` or `manifestId` is protected, or whose `storageKey` or `cacheId` names seven's storage, is refused the same way. This covers `Storage.*`, `IndexedDB.*`, `CacheStorage.*`, `DOMStorage.*`, `FileSystem.*`, `ServiceWorker.*`, `PWA.*`, `Browser.setPermission` and `Browser.grantPermissions`. Free-form values (`expression`, `arguments`, `value`, `headers`, `postData` and the like) aren't searched.
810
- - **Cookies.** `Network.getCookies`, `Network.getAllCookies`, `Storage.getCookies` and `Page.getCookies` answer without the cookies whose domain is protected (`sliccy.ai` and every subdomain, and each extra origin's host and its parents: cookies ignore ports), and without partitioned cookies whose `partitionKey.topLevelSite` is such a site. `Network.setCookie`, `setCookies`, `deleteCookies`, `Storage.setCookies` and `Page.deleteCookie` for such a domain, a URL on such a host, or a partition key under such a site, are refused with `slicc: refused: cookies on seven's origin`. So are `Network.clearBrowserCookies` and `Storage.clearCookies`, except in a browser context this stream created with `Target.createBrowserContext`.
810
+ - **Cookies.** `Network.getCookies`, `Network.getAllCookies`, `Storage.getCookies` and `Page.getCookies` answer without the cookies whose domain is protected (`sliccy.ai` and every subdomain, and each extra origin's host and its parents: cookies ignore ports), and, when the browser supplies partition data, without partitioned cookies whose `partitionKey.topLevelSite` is such a site (see "Where those promises stop" below). `Network.setCookie`, `setCookies`, `deleteCookies`, `Storage.setCookies` and `Page.deleteCookie` for such a domain, a URL on such a host, or a partition key under such a site, are refused with `slicc: refused: cookies on seven's origin`. So are `Network.clearBrowserCookies` and `Storage.clearCookies`, except in a browser context this stream created with `Target.createBrowserContext`.
811
811
  - **Requests a page makes to seven.** For a request whose URL is protected, `Network.*` and `Fetch.*` events lose their `Cookie`, `Set-Cookie`, `Authorization` and `Proxy-Authorization` headers (in the header maps and as lines of the raw header texts, which otherwise stay, their URLs cut as everywhere) and their cookie lists, and `requestWillBeSentExtraInfo` drops seven's cookies from `associatedCookies` for any request. Chrome can send `requestWillBeSentExtraInfo` and `responseReceivedExtraInfo` before the event that names the request's URL, so the node holds them until the request is found to be protected, gets its response, finishes or fails (a WebSocket or WebTransport once it is created); one still held after 2 seconds is passed on stripped, as for a protected request. For a WebSocket, WebTransport or EventSource on a protected origin (`ws:` and `wss:` count as `http:` and `https:`), `webSocketWillSendHandshakeRequest`, `webSocketHandshakeResponseReceived`, `webSocketFrameError`, `eventSourceMessageReceived` and `dataReceived` are dropped. Reading such a request's body (`Network.getResponseBody`, `Fetch.getResponseBody`, `takeResponseBody…AsStream`, `Audits.getEncodedResponse` and the like) is refused. A request paused at the response stage whose response headers name a protected URL (an ordinary redirect into seven, say) counts as such a request too. `Fetch.continueRequest` and `Network.continueInterceptedRequest` with a `url` that the node has seen redirect into a protected origin on that target are refused with `slicc: refused: that URL redirects to seven's origin`. So is reading a stylesheet or script that came from a protected URL, directly or through a redirect: `Page.getResourceContent` and `Page.searchInResource` for its URL, and any command naming its `styleSheetId` or `scriptId`. CSS rules and styles from it reach the page with only their `styleSheetId` and `origin`. In a dedicated, shared or service worker, the node keeps its own guard session (Network only), and the worker's commands, `Runtime.runIfWaitingForDebugger` included, wait until that session's `Network.enable` answers, within the same bounds as a page's guard. A worker script other than the worker's own is readable only if that guard saw its whole redirect chain and none of it was protected; an import from before the guard attached, such as in a worker that was already running, is refused. In a page, a stylesheet or script loaded before the node attached to the tab has no redirect chain the node saw, so it stays readable even if it came through a redirect from a protected origin (a known residual). The node also checks the answer, because the page may ask before the node has seen the request. When `Network.getResponseBody`, `searchInResponseBody`, `streamResourceContent`, `getResponseBodyForInterception`, `takeResponseBodyForInterceptionAsStream`, `getRequestPostData`, `Fetch.getResponseBody`, `Fetch.takeResponseBodyAsStream` or `Audits.getEncodedResponse` answers, the node holds the answer until the request has a response (for `getRequestPostData`, until it is sent; for an intercepted request, until it is paused). If the request is protected by then, the answer is refused, and a stream it handed out is closed. If the node still hasn't seen the request after 2 seconds, the answer is refused with `slicc: refused: slicc hasn't seen this request, so it could be seven's`. `Network.replayXHR` is never forwarded: for a protected or unknown request it keeps the body-getter refusal; for a known ordinary request it is refused with `slicc: refused: Network.replayXHR follows redirects inside the browser, so it could send a request to seven's pages or the vault`. Chrome's native replay cannot classify each redirect before sending it. This does not block page-initiated fetches, XHR or subresources, including their redirects into protected origins; C5 allows those requests while the content and credential protections still apply. A URL override through `Fetch.continueRequest`, a redirect supplied through `Fetch.fulfillRequest` or `Fetch.continueResponse`, and `Fetch.continueWithAuth` make the request client-issued. The guard correlates its network ID on that target and fails a protected hop before sending it; an unmodified page continuation does not establish client ownership. Missing correlation, an unguarded worker or exhausted ownership tracking refuses the client mutation. `Network.continueInterceptedRequest` with `url` or `rawResponse` is always refused, whatever the destination; use Fetch instead. Chrome 156 removed `Network.setRequestInterception`, so its compatibility refusal has committed wire coverage rather than a native control. `IO.read` is refused, with `slicc: refused: slicc didn't hand out this stream, so it could be seven's`, unless the node passed that handle to the page in an allowed answer (`take…AsStream`, `Page.printToPDF`, or `IO.resolveBlob` as `blob:<uuid>`). - **Paused requests to seven.** A page session's own interception never gets to touch a request whose URL is protected, whatever its kind (a document, `fetch()`, XHR, an image or any other subresource), at either stage. The node keeps `Fetch.requestPaused`, `Fetch.authRequired` and the deprecated `Network.requestIntercepted` for such a request from the page and settles it itself:
812
812
  - a document request is failed (`Fetch.failRequest` with `BlockedByClient`, or `Network.continueInterceptedRequest` with `errorReason: BlockedByClient`);
813
813
  - any other request continues untouched (`Fetch.continueRequest`, or `Network.continueInterceptedRequest` with only its `interceptionId`);
@@ -827,11 +827,16 @@ Only browsers the user named are listed: the one seven runs in, `--cdp` and `--c
827
827
  - the hold stays in place whatever any other session does, its interception, bypass and observation included, sessionless `Fetch` and `Network` commands too;
828
828
  - `Input` stays in the main document and never reaches a child frame;
829
829
  - `Page.getFrameTree` and `DOM.getDocument` list child frames by address, and never return a child frame's content;
830
- - that frame evidence is complete and unambiguous: every frame in the tree, nested ones included, has its `url` and `securityOrigin`, and an `unreachableUrl` when it shows an error for one;
830
+ - every frame the browser lists, nested ones included, has its `url` and `securityOrigin`, and the node checks an `unreachableUrl` only when one is sent;
831
831
  - `Runtime.callFunctionOn` and `Runtime.getProperties`, on any object including one for a frame's window, `Accessibility` and the other allowed `DOM` helpers stay in the main document and never cross into a child frame;
832
832
  - `Runtime.evaluate` without a selector keeps the page's same-origin rules, and every evaluation world the browser admits keeps the origin boundary;
833
- - cookie answers carry truthful `domain` and partition data, cookie writes go to their explicit destination and not the active tab, and `Network.getCookies` has its standard scope and request and body correlation;
833
+ - cookie answers carry a truthful `domain`, cookie writes go to their explicit destination and not the active tab, and `Network.getCookies` has its standard scope;
834
834
  - target and history evidence is truthful, and `Target.createTarget` makes a fresh target with the given URL.
835
+ - **Where those promises stop.** The node can't close these:
836
+ - The address a browser reports isn't always what's loaded. A frame loaded before the browser's port opened isn't listed as protected and doesn't lock the target if it's nested in a cross-origin frame, or if it's a direct child that redirected into a protected origin. A direct blank child sent cross-origin stays listed as `about:blank` with `securityOrigin: "null"`, which passes as clean unless the browser also lists the protected address. Only the allowlist below covers these.
837
+ - `securityOrigin` is no separate check on such a browser, which may derive it from the frame's `url`, or from the page for a blank or `srcdoc` frame the page can reach. A frame that redirected shows the address it asked for.
838
+ - A browser with no partition API shows a third party's cookie partitioned under a protected site as an ordinary cookie.
839
+ - A default `Network.getCookies` can include an unlisted protected frame's cookies only if their `domain` isn't protected, since the `domain` filter removes the rest.
835
840
  - Such a target is *documents-only*. The node reads its frame tree during setup, once the hold is in place, and again after every `Page.frameNavigated`, restores included. Commands on the target wait for that answer, checked again as they're admitted, a `Page.navigateToHistoryEntry` after its history lookup too. A tree that lists a protected `url`, `securityOrigin` or `unreachableUrl` at any depth, that leaves out a `frame`, `url` or `securityOrigin`, or that doesn't arrive, within 10 s after a commit or the setup bounds during setup, locks the target as if it had protected history. What the browser lists is filtered like any other URL, so a protected frame's address reaches the page cut to its origin. A later protected frame is held and failed, which locks the target too. A command already running in the moment between a commit and the node hearing of it can still answer from the new main document, within the allowlist; an answer or error that arrives after the lock is dropped.
836
841
  - An error from such a browser reaches the page with only its `code` and scrubbed `message`, so nothing the browser adds as `data` passes.
837
842
  - **The one exception to "a protected frame's address never reaches the stream":** a value the page itself puts in a console argument or returns from a script, such as an iframe's `src`. The page already knows it, and Chrome behaves the same.
@@ -880,9 +885,9 @@ Only browsers the user named are listed: the one seven runs in, `--cdp` and `--c
880
885
  - **Listing.** `Target.getTargets`, `Target.getTargetInfo`, `Target.targetCreated` and `Target.targetInfoChanged` still show protected targets, so seven knows its tab exists, but their `url` and `title` are only the origin (`https://seven.sliccy.ai`, `chrome://settings`, `chrome-extension://<id>`, or `about:blank`), or only the scheme for a URL without a host (`file:`). A target whose URL slicc can't parse isn't listed at all, since it has no origin to show: `Target.getTargets` leaves it out, and its `targetCreated` and `targetInfoChanged` are dropped. A target of a `targetTypes` type (`browser_ui`) is never shown: `Target.getTargets` leaves it out, its `targetCreated`, `targetInfoChanged`, `targetDestroyed` and `targetCrashed` are dropped, and `Target.getTargetInfo` on its id is refused like any other command that names it. Service worker registrations and versions on a protected origin are left out of `ServiceWorker` events, and `Storage`, `DOMStorage` and `BackgroundService` events that name a protected origin are dropped.
881
886
  - **Protected URLs in what the page gets.** In every event and result the page gets, a URL field that holds a protected URL is cut to its origin, at any depth: every key ending in `url`, `urls`, `origin` or `origins` (any case, so `documentURL`, `unreachableUrl` and `securityOrigin` too), `referrer`, `location`, `href` and `src`, and every header value in `headers`, `requestHeaders` and `responseHeaders`. That covers `Page.frameRequestedNavigation`, `Page.frameNavigated`, `Network.requestWillBeSent`, `Page.windowOpen`, `Page.getFrameTree` and the rest. Every other string (header values such as `Link` and `Refresh`, `headersText` and `requestHeadersText`, cookie and storage values, DOM attributes) keeps its text, but each protected URL inside it (a `scheme://` run up to whitespace, a quote, `<` or `>`, a URL that doesn't parse included, a percent-encoded run decoded repeatedly to a fixed point through at most five layers, and an unschemed protected `host[:port]/path` run) is cut to its origin (or host for an unschemed run); if percent-decoding still changes a string after five layers, the whole string is blanked, and next to a protected URL field every field ending in `Fragment` (`urlFragment` of a request or frame) is blanked to `""`, while ordinary URLs keep theirs, so a redirect from an ordinary page to seven's `/auth/callback?code=…` shows the page only seven's origin, wherever it names that URL. Unprotected URLs stay intact. Everything inside a `value`, `preview`, `customPreview`, `arguments` or `returnValue` (evaluation results and their previews) is left alone.
882
887
  - **Limits.**
883
- - The filter relies on Chrome's site isolation. A seven frame inside a page of another site is a target of its own (`iframe`), which the node protects. Frame reads, DOM, paint and input on its page ancestor are locked too, including compound frames whose protected child shares an ordinary iframe's renderer. An iframe's lock belongs to its parent root document: a different root loader stops a cached document's frames from locking the new page, and restoring that loader locks again before content commands are answered. Without generation evidence the page stays locked, unless `DOM.getFrameOwner` on the node's private page session explicitly says a directly parented iframe is absent from the current document. Missing replies, ambiguous parents and other errors keep the lock; root commits, restores and frame attachments invalidate negative ownership evidence. A same-site frame shares its parent's process and isn't a target. Every `sliccy.ai` host is protected, so this only matters for an extra origin, such as one port of `127.0.0.1` framed by a page on another.
888
+ - On Chromium, the filter relies on site isolation. A seven frame inside a page of another site is a target of its own (`iframe`), which the node protects. Frame reads, DOM, paint and input on its page ancestor are locked too, including compound frames whose protected child shares an ordinary iframe's renderer. An iframe's lock belongs to its parent root document: a different root loader stops a cached document's frames from locking the new page, and restoring that loader locks again before content commands are answered. Without generation evidence the page stays locked, unless `DOM.getFrameOwner` on the node's private page session explicitly says a directly parented iframe is absent from the current document. Missing replies, ambiguous parents and other errors keep the lock; root commits, restores and frame attachments invalidate negative ownership evidence. A same-site frame shares its parent's process and isn't a target. Every `sliccy.ai` host is protected, so this only matters for an extra origin, such as one port of `127.0.0.1` framed by a page on another.
884
889
  - A document that arrives without a request isn't failed: a page restored from the back/forward cache, and a `blob:` or `filesystem:` URL of a protected origin (which only that origin can make). Targets with protected history are content-locked before commands can race a restore, regardless of delayed commit events. The node still detaches after a protected commit. Navigation initiated outside the stream after fresh evidence, including loads already in flight before the guard was installed, remains a limit; this does not authorize content commands on a quarantined target.
885
- - **A browser that pauses documents through its navigation delegate** only pauses in a tab the stream touched, so a `window.open` onto a protected URL loads in the new tab before anyone can attach. The stream still can't reach it, since attaching to it is refused, and the page that opened it can't read across origins, but the request goes out with the user's cookies. Measured on Crest, which also reaches main frames only.
890
+ - **A browser that pauses documents through its navigation delegate** only pauses in a tab the stream touched, so a `window.open` onto a protected URL loads in the new tab before anyone can attach. The stream still can't reach it, since attaching to it is refused, and the page that opened it can't read across origins, but the request goes out with the user's cookies. Measured on Crest, where what the allowlist can inspect is the main document, while document holds cover child frames too.
886
891
  - The network guard fails only `http` and `https` documents. Chrome itself keeps a web page from navigating to `chrome:`, `chrome-untrusted:`, `devtools:` and `file:` URLs, but not to an extension's web-accessible pages. A touched page that sends itself to one with a script or a link is detached after the commit, as above.
887
892
  - If the node loses its own session (`ECONNRESET: slicc lost track of the browser's targets`), it refuses every command and resets the stream unless the browser closes within 2 s.
888
893
  - The node's own setup connection (see [Local setup](#local-setup-slicc-attach)) is not a `cdp` stream and isn't filtered.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@ai-ecoverse/slicc",
3
- "version": "1.50.1",
3
+ "version": "1.50.3",
4
4
  "description": "SLICC's command line for seven: links a machine's network, compute and browsers to seven over WebRTC",
5
5
  "license": "Apache-2.0",
6
6
  "repository": {
@@ -18,12 +18,12 @@
18
18
  "node": ">=18"
19
19
  },
20
20
  "optionalDependencies": {
21
- "@ai-ecoverse/slicc-darwin-arm64": "1.50.1",
22
- "@ai-ecoverse/slicc-darwin-amd64": "1.50.1",
23
- "@ai-ecoverse/slicc-linux-arm64": "1.50.1",
24
- "@ai-ecoverse/slicc-linux-amd64": "1.50.1",
25
- "@ai-ecoverse/slicc-windows-arm64": "1.50.1",
26
- "@ai-ecoverse/slicc-windows-amd64": "1.50.1",
21
+ "@ai-ecoverse/slicc-darwin-arm64": "1.50.3",
22
+ "@ai-ecoverse/slicc-darwin-amd64": "1.50.3",
23
+ "@ai-ecoverse/slicc-linux-arm64": "1.50.3",
24
+ "@ai-ecoverse/slicc-linux-amd64": "1.50.3",
25
+ "@ai-ecoverse/slicc-windows-arm64": "1.50.3",
26
+ "@ai-ecoverse/slicc-windows-amd64": "1.50.3",
27
27
  "@ai-ecoverse/slicc-jerk": "^1.3.9"
28
28
  }
29
29
  }