@ai-ecoverse/slicc 1.67.12 → 1.67.14

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 +3 -3
  2. package/package.json +7 -7
package/README.md CHANGED
@@ -913,7 +913,7 @@ Only browsers the user named are listed: the one seven runs in, `--cdp` and `--c
913
913
  **Seven's origin is off limits.** The node relays CDP through a filter, so seven's browser control never navigates to, opens or attaches to a target on seven's own origin, and never reads or writes its cookies or storage. That holds for every listed browser, not only the one seven runs in. What is protected comes from [slicc-browsers](https://github.com/ai-ecoverse/slicc-browsers#protected-origins)' `protectedOrigins`: every `sliccy.ai` host (the apex and `www` included, any port, `https` and `http`), `vault.sliccy.ai` by name (the vault is never a CDP target for seven's tools), `blob:`, `filesystem:` and `view-source:` URLs by the URL inside them, `devtools:` URLs, and the extra origins: `--origin` for `attach`, and `--origin` and the `--page` origin for `slicc`. `follow` has none. `*.kernel.localhost` is not protected. URLs are parsed the way the browser parses them (WHATWG), and the node forwards its own re-encoding of each command, so the browser runs exactly what was checked: a key given twice counts once, as its last value, and a message that isn't a JSON object with an integer `id` and a string `method` is refused (or dropped, without an `id`).
914
914
  - **Privileged pages** (slicc-browsers ≥ 1.8.0) are protected the same way, as if they were seven's: every URL whose scheme is in `protectedSchemes` (`chrome:`, `chrome-untrusted:`, `chrome-extension:`, `devtools:`, `file:`, from 1.8.5 also `chrome-search:`, `chrome-native:`, `chrome-distiller:`, `isolated-app:`, `chrome-experimental-site-token-provider:`, `externalfile:` and `content:`, and the UI schemes of the catalog's other Chromium browsers, `edge:`, `brave:`, `opera:`, `vivaldi:` and `arc:`), on any host and path, except the new tab pages in `schemeExceptions` (`chrome://newtab`, `chrome://new-tab-page` and its `chrome-untrusted://new-tab-page` frames, `edge://newtab`, `brave://newtab`, `opera://startpage`), matched by the parsed scheme and exact host, so `chrome-untrusted://new-tab-page.evil/` stays protected. `chrome-error:` is not protected: Chrome's network and frame error pages stay readable, snapshottable, reattachable and navigable away from, like the ordinary pages they stand in for. So `chrome://settings`, `chrome://password-manager`, an extension's pages, frames and workers (a password manager's or a wallet's vault included) and any local file are refused, hidden from auto-attach and detached like a seven tab. A wrapper is judged by what it wraps: `view-source:chrome://settings/` and `view-source:file:///…` by their inner URL, `blob:` and `filesystem:` by their origin. An `about:` URL other than `about:blank` and `about:srcdoc` is judged as the `chrome://` URL Chrome makes of it, so `about:settings` is `chrome://settings`. A target whose `type` is in `targetTypes` (`browser_ui`, Chrome's own UI such as `chrome://omnibox-popup.top-chrome/`) is protected whatever its URL, and hidden altogether (see *Listing*).
915
915
  - **Targets.** Before the stream opens, the node attaches its own session to the browser target and calls `Target.setDiscoverTargets` and `Target.getTargets` on it with ids of its own. Neither the session nor its messages ever reach the page. From then on it knows every target's URL and opener. A target on an inheriting URL (`about:blank`, `about:srcdoc`, none) is protected when it was protected before or when its opener is protected or unknown, so a blank popup that seven opens counts as seven. On a page session, the main frame's `securityOrigin` (`Page.frameNavigated`) and the default context's `origin` (`Runtime.executionContextCreated`) count too.
916
- - **Extension worlds.** Any other execution context on a protected origin, such as a password manager's content-script isolated world on an ordinary page, is hidden rather than cutting the page. Seven never sees it, and commands, objects and call frames that name it are refused with `slicc: refused: that execution context belongs to a browser extension` ([§5.8](#58-cdp-cap-cdp-page--node)).
916
+ - **Extension worlds.** Any other execution context on a protected origin, such as a password manager's content-script isolated world on an ordinary page, is hidden rather than cutting the page. Seven never sees it, and commands, objects and call frames that name it are refused with `slicc: refused: that execution context belongs to a browser extension` ([§5.8](#58-cdp-cap-cdp-page--node)). A content-script isolated world of an extension on an ordinary page never counts as a child frame of that page and never protects its iframes; only a real `chrome-extension:` child frame (an iframe element or an `extension_frame` target) locks the tab (#651/#661).
917
917
  - **Extension frames** (slicc-browsers ≥ 1.20.3). A child frame whose scheme is in `protectedOrigins.extensionFrames.schemes` (`chrome-extension:`), such as a password manager's autofill list, no longer locks an ordinary tab. The frame itself stays out of reach: it can't be attached or read, and its URL is blanked to `about:blank` in target discovery, page reads, snapshots, accessibility trees and evaluate results. Plain occurrences of a currently tracked extension frame's exact URL, and of that frame's `chrome-extension://<id>` origin, are replaced with `about:blank` as a substring inside every string value and every object key in every message sent to seven; every other byte stays. A page can re-encode the URL (case changes, escapes, base64, concatenation), so this removes plain occurrences only. The tab's own page can still be read. On the owner `IFRAME`/`FRAME` DOM nodes (from `DOM.getDocument`, `DOM.describeNode`, `DOM.setChildNodes`, and `DOM.childNodeInserted`) and on a `DOM.getFrameOwner` result for that frame, the guard adds a placement marker `sliccExtensionFrame: {"version":1,"kind":"extensionFrame"}` with no URL, id, origin, title, or frame id; any inbound property of that name is stripped first so only the guard can produce it. `DOM.getFrameOwner` for a tracked extension frame that belongs to the command's own session page is admitted and answers with only `backendNodeId`, `nodeId`, and that marker; attach, evaluate, `Page.createIsolatedWorld`, and every other method that names the extension frame stay refused. `Page.captureScreenshot` and every `Input.*` method in `extensionFrames.whenShown` are allowed only while every such frame is hidden (`visibility: hidden` or no layout box; opacity and off-screen position do not count) and none holds the deep active element through nested documents or closed shadow roots; otherwise they are refused with `extensionFrames.shownRefusal`. Whole-page captures and streams in `extensionFrames.whilePresent` (`Page.captureSnapshot`, `Page.printToPDF`, `Page.startScreencast`, `HeadlessExperimental.beginFrame`) are refused while any extension frame is present, with `extensionFrames.presentRefusal`. A running screencast is stopped or has its later `Page.screencastFrame` events dropped until the frame is gone. A race between the visibility or focus check and the CDP reply is accepted. A frame from an extra origin that is the program's own extension, and any other protected frame, still locks the whole tab.
918
918
  - **Debugger (Stage 1).** One session per target on each relay stream owns the debugger. Only `Debugger.enable`, `setInstrumentationBreakpoint`, `disable`, `removeBreakpoint` for that owner's breakpoints, and `resume` at a published pause are admitted, on an ordinary target whose navigation guard is ready and whose reachable frames and worlds are placed and ordinary. Every other `Debugger.*`, `DOMDebugger.*` and `EventBreakpoints.*` command is refused with `slicc: refused: debugger methods other than enable, disable, setInstrumentationBreakpoint, removeBreakpoint and resume could read or run code in seven's pages or an extension's world, so the guard doesn't allow them`, including `setBreakpointByUrl`, stepping, `DOMDebugger.getEventListeners`, `getScriptSource` and `evaluateOnCallFrame`. Debugger events are not forwarded as they arrive: `scriptParsed` and `scriptFailedToParse` are held, and only the verified pause's script records, including every validated async and parent-stack script it references, are published before it; `breakpointResolved` and unrelated Debugger events are suppressed. Each `Debugger.paused` is held while the guard checks the current frame tree and the pause's context and document generation. An instrumentation pause is converted privately to a normal pause; instrumentation from an evaluation or a context already published in that document resumes privately. Only a verified ordinary pause and its scripts reach the owner. Bookkeeping for an admitted `enable` or `setInstrumentationBreakpoint` reply survives a document-only generation change, but a safety revocation still invalidates it. A verified batch that fits the stream window can wait for available credit without holding the output or guard lock. After waiting, a fresh frame-tree read orders the proof after queued browser events, then ownership, generation, root loader, contexts and admission are rechecked before a single atomic write within the original pause deadline. Failed proof, revocation or expired credit waits resume privately without publication. Anything protected, stale, unplaced or unverified resumes privately and publishes nothing. A frame-tree read has a 2 s bound; every owned pause has a 5 s deadline, after which the guard resumes it. [§5.8](#58-cdp-cap-cdp-page--node) has the ownership and publication rules.
919
919
  - **Debugger memory.** All sessions on one relay share a 64 MiB retained-byte limit for script records, script identifiers and held pause data. A session that would exceed it drops its records, resumes its pause privately and refuses further Debugger work until a document change or a safety revocation clears the latch. A same-document admission failure (such as a hidden world or protected frame), or loss of the published pause’s context proof, also clears it; admission still has to become safe before work is admitted again. Commit and drop release its bytes.
@@ -1000,7 +1000,7 @@ Only browsers the user named are listed: the one seven runs in, `--cdp` and `--c
1000
1000
  - **Session-wide settings are refused on every relay session, including ordinary pages.** `Network.setExtraHTTPHeaders`, `Network.setUserAgentOverride`, `Emulation.setUserAgentOverride`, `Emulation.setLocaleOverride`, `Emulation.setTimezoneOverride`, `Network.setCacheDisabled`, `Network.emulateNetworkConditions`, `Network.emulateNetworkConditionsByRule`, `Network.overrideNetworkState`, `Network.setBlockedURLs`, and every method matching `/^Emulation\.(set|add|update|remove)[A-Z]/` other than the four display admits above receive `slicc: refused: settings for a whole session (headers, user agent, locale, time zone, cache, network conditions, blocked URLs, emulation) could reach seven’s pages or the vault, so the guard doesn’t allow them; change a request through Fetch instead`. These calls are never forwarded or answered with fake success.
1001
1001
  - **Browser-side inheriting navigation is refused.** `Page.navigate` to any `about:` URL, including `about:blank` and `about:srcdoc`, receives `slicc: refused: a browser-side navigation to about: gives the page the origin of whatever drives the browser, so the guard doesn’t send it; open a new tab on about:blank instead`. An absent or unparseable navigation URL receives the same error. Creating a fresh tab with `Target.createTarget` on `about:blank` remains available.
1002
1002
 
1003
- - **Listing.** The origin-only rule covers page and tab targets only. `Target.getTargets`, `Target.getTargetInfo`, `Target.targetCreated` and `Target.targetInfoChanged` still show protected page and tab 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:`). An iframe target is protected when its own URL is protected or when its `parentFrame`, or any ancestor frame or target, is a protected target or a protected recorded frame (from `Target.*` `parentFrameId`/`parentId` and `Page.frameAttached`/`frameNavigated`); once protected, that decision sticks for the iframe's life. A protected iframe is never listed, never answered by `Target.getTargetInfo`, never attachable, and commands that name it are refused. An auto-attached iframe whose parent target is not known yet, or whose parent target's navigation is still unresolved, is held the same way an unresolved worker is: left out of listings, not attached, and if the hold times out while that parent target is still unknown it is resumed and detached without being shown. Separately, an auto-attached iframe that still has no URL of its own stays held until that URL (or a protected decision from ancestry) is known; ancestry settling alone must not deliver a URL-less iframe. `Target.attachToTarget` and `Target.getTargetInfo` sent on the browser session for an iframe while one of those holds is on wait for the hold instead of being answered at once, so a client that looks an iframe up as soon as `Target.targetCreated` announces it gets the decision rather than a refusal the guard hasn't made yet. They are answered, in arrival order, the moment the hold settles: through the normal rules when the iframe was delivered or turned protected (a protected iframe is refused, and `Target.getTargetInfo` says `No target with given id found`), and refused with `slicc: refused: unresolved ancestry` (or `No target with given id found`) when the hold ends any other way: it times out, its page session is detached or stops auto-attaching, Chrome detaches it, the iframe is destroyed, or the stream closes. They never wait past the hold's own deadline (the hold timeout from the first auto-attach of that iframe), a later attach of the same iframe doesn't extend it, and a call after that deadline is refused at once. At most 8 calls wait per iframe, 32 per page and 256 per stream; one more is refused at once with `slicc: refused: unresolved ancestry`. Other commands don't queue behind them. `Target.attachToTarget` and `Target.getTargetInfo` that name an iframe while either hold is on wait until it settles (the iframe is delivered, hidden, cut with its page session, destroyed, or its hold times out) and then get the answer they would get at that moment, so a client that looks up an iframe as soon as `Target.targetCreated` announces it is neither told it doesn't exist nor refused for a decision the guard hasn't made yet. A missing `parentFrameId`/`parentId` is not treated as ordinary: the guard still walks recorded frame ancestry (`Page.frameAttached` / `frameNavigated` / the frame tree), and while that ancestry is unknown the iframe stays held or hidden from `Target.getTargets`, `Target.getTargetInfo`, target events and attach-by-id. An ordinary iframe whose ancestry is unknown, pending, cyclic or deeper than the ancestor limit is hidden and refused with `slicc: refused: unresolved ancestry`. Extension-frame targets (`chrome-extension://` iframes) keep the existing extension-frame rule from main: not auto-attached, answered by `Target.getTargetInfo` in redacted `about:blank` form, and gated for screenshot/Input; parent-protection only adds further hide (listings/`getTargetInfo` missing) when a parent or ancestor is protected, and never delivers or un-hides what that rule already keeps out of auto-attach. After an iframe was shown, protection still follows it: an explicit attach from the browser session is cut or refused as soon as its owner page or any ancestor turns protected or held, and on every command the guard checks both the target parent chain and the attaching session (if they disagree, the iframe is treated as protected). A dispute is raised only when the recorded frameParents chain does not reach the attaching owner after resolving a `tab` owner to the page under it (same `browserContextId`, or the same URL when the tab has no context id); a `browser` owner never raises a dispute by itself. Page and iframe owners still dispute when the chain misses them (the #739 rule). Unknown owner types keep the old fail-closed dispute. Page content cannot forge `tab` or `browser` attach parents: those target types are Chrome's, not script-created. `parentFrameId` names a frame inside that parent, not a target; the guard resolves ancestry from the attach parent target and from recorded frames, and does not hold merely because `parentFrameId` is not a target id. A worker (`worker`, `shared_worker` or `service_worker`) is protected when its own URL is protected or a protected frame or target created it, including a `blob:` or `data:` URL and a worker auto-attached on an out-of-process iframe's session. Every `data:` worker created by a sub-frame stays hidden: for a `data:` worker every creator field must be a known ordinary target, and any sub-frame creator field (`openerFrame` or `parentFrame`) keeps it hidden, so only a `data:` worker whose sole creator is an ordinary target the guard already knows is ordinary is listed. Once a worker is classified protected, that decision sticks for the worker's life even if its creator later navigates away or drops out of the frame map. That protected worker is not auto-attached and not listed at all: `Target.getTargets` leaves it out, its `targetCreated`, `targetInfoChanged` and `targetDestroyed` are dropped, and `Target.getTargetInfo` answers `No target with given id found`, the same answer an unknown target gets. An auto-attached worker whose URL and creator frame are not known yet is held the same way a page without a URL is: the page does not get `attachedToTarget`, the worker stays paused when `waitForDebuggerOnStart` was requested (so it does not run ahead of the decision), and it is left out of listings until its URL or that frame is known. Without `waitForDebuggerOnStart`, a held ordinary worker can run and emit early events (console, network) that the page never sees, because those events arrive while the session is still held; slicc-cdp accepts that for ordinary workers. Learning the creator frame decides the worker then, even when the worker was recorded first. If the creator is still unknown when the hold times out, the worker is resumed and detached without being shown. Detaching that page session, or turning auto-attach off on it (`autoAttach` false, `waitForDebuggerOnStart` false, `flatten` true, and no filter), does the same at once. `Target.attachToTarget` for a worker that is protected or still unresolved is refused. An ordinary worker the page learned outside listings (for example a `targetId` from `ServiceWorker.workerVersionUpdated`) may be attached by id even if it was never listed; `targetDestroyed` for a worker the page was never shown is still dropped until that attach or a listing shows it. 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.
1003
+ - **Listing.** The origin-only rule covers page and tab targets only. `Target.getTargets`, `Target.getTargetInfo`, `Target.targetCreated` and `Target.targetInfoChanged` still show protected page and tab 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:`). An iframe target is protected when its own URL is protected or when its `parentFrame`, or any ancestor frame or target, is a protected target or a protected recorded frame (from `Target.*` `parentFrameId`/`parentId` and `Page.frameAttached`/`frameNavigated`); once protected, that decision sticks for the iframe's life. A protected iframe is never listed, never answered by `Target.getTargetInfo`, never attachable, and commands that name it are refused. An auto-attached iframe whose parent target is not known yet, or whose parent target's navigation is still unresolved, is held the same way an unresolved worker is: left out of listings, not attached, and if the hold times out while that parent target is still unknown it is resumed and detached without being shown. Separately, an auto-attached iframe that still has no URL of its own stays held until that URL (or a protected decision from ancestry) is known; ancestry settling alone must not deliver a URL-less iframe. `Target.attachToTarget` and `Target.getTargetInfo` that name an iframe while either hold is on wait for the hold instead of being answered at once, so a client that looks an iframe up as soon as `Target.targetCreated` announces it gets the decision rather than a refusal the guard hasn't made yet. They are answered, in arrival order, the moment the hold settles: through the normal rules when the iframe was delivered or turned protected (a protected iframe is refused, and `Target.getTargetInfo` says `No target with given id found`), and refused with `slicc: refused: unresolved ancestry` (or `No target with given id found`) when the hold ends any other way: it times out, its page session is detached or stops auto-attaching, Chrome detaches it, the iframe is destroyed, or the stream closes. They never wait past the hold's own deadline (the hold timeout from the first auto-attach of that iframe), a later attach of the same iframe doesn't extend it, and a call after that deadline is refused at once. At most 8 calls wait per iframe, 32 per page and 256 per stream; one more is refused at once with `slicc: refused: unresolved ancestry`. Other commands don't queue behind them. When a held iframe is released, the page session receives the attach first, then Chrome's own later `Target.targetInfoChanged`; URL updates that arrive during the hold are dropped because the attach already carries the URL. A missing `parentFrameId`/`parentId` is not treated as ordinary: the guard still walks recorded frame ancestry (`Page.frameAttached` / `frameNavigated` / the frame tree), and while that ancestry is unknown the iframe stays held or hidden from `Target.getTargets`, `Target.getTargetInfo`, target events and attach-by-id. An ordinary iframe whose ancestry is unknown, pending, cyclic or deeper than the ancestor limit is hidden and refused with `slicc: refused: unresolved ancestry`. Extension-frame targets (`chrome-extension://` iframes) keep the existing extension-frame rule from main: not auto-attached, answered by `Target.getTargetInfo` in redacted `about:blank` form, and gated for screenshot/Input; parent-protection only adds further hide (listings/`getTargetInfo` missing) when a parent or ancestor is protected, and never delivers or un-hides what that rule already keeps out of auto-attach. After an iframe was shown, protection still follows it: an explicit attach from the browser session is cut or refused as soon as its owner page or any ancestor turns protected or held, and on every command the guard checks both the target parent chain and the attaching session (if they disagree, the iframe is treated as protected). A dispute is raised only when the recorded frameParents chain does not reach the attaching owner after resolving a `tab` owner to the page under it (same `browserContextId`, or the same URL when the tab has no context id); a `browser` owner never raises a dispute by itself. Page and iframe owners still dispute when the chain misses them (the #739 rule). Unknown owner types keep the old fail-closed dispute. Page content cannot forge `tab` or `browser` attach parents: those target types are Chrome's, not script-created. `parentFrameId` names a frame inside that parent, not a target; the guard resolves ancestry from the attach parent target and from recorded frames, and does not hold merely because `parentFrameId` is not a target id. A worker (`worker`, `shared_worker` or `service_worker`) is protected when its own URL is protected or a protected frame or target created it, including a `blob:` or `data:` URL and a worker auto-attached on an out-of-process iframe's session. Every `data:` worker created by a sub-frame stays hidden: for a `data:` worker every creator field must be a known ordinary target, and any sub-frame creator field (`openerFrame` or `parentFrame`) keeps it hidden, so only a `data:` worker whose sole creator is an ordinary target the guard already knows is ordinary is listed. Once a worker is classified protected, that decision sticks for the worker's life even if its creator later navigates away or drops out of the frame map. That protected worker is not auto-attached and not listed at all: `Target.getTargets` leaves it out, its `targetCreated`, `targetInfoChanged` and `targetDestroyed` are dropped, and `Target.getTargetInfo` answers `No target with given id found`, the same answer an unknown target gets. An auto-attached worker whose URL and creator frame are not known yet is held the same way a page without a URL is: the page does not get `attachedToTarget`, the worker stays paused when `waitForDebuggerOnStart` was requested (so it does not run ahead of the decision), and it is left out of listings until its URL or that frame is known. Without `waitForDebuggerOnStart`, a held ordinary worker can run and emit early events (console, network) that the page never sees, because those events arrive while the session is still held; slicc-cdp accepts that for ordinary workers. Learning the creator frame decides the worker then, even when the worker was recorded first. If the creator is still unknown when the hold times out, the worker is resumed and detached without being shown. Detaching that page session, or turning auto-attach off on it (`autoAttach` false, `waitForDebuggerOnStart` false, `flatten` true, and no filter), does the same at once. `Target.attachToTarget` for a worker that is protected or still unresolved is refused. An ordinary worker the page learned outside listings (for example a `targetId` from `ServiceWorker.workerVersionUpdated`) may be attached by id even if it was never listed; `targetDestroyed` for a worker the page was never shown is still dropped until that attach or a listing shows it. 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.
1004
1004
  - **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.
1005
1005
  - **Limits.**
1006
1006
  - 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.
@@ -1967,7 +1967,7 @@ On a [§1.3](#13-local-setup-without-cdp-loopback-signalling) loopback link, `un
1967
1967
  - **Waiting for that guard:** page commands on a touched target's session wait while the node sets its guard up there. The wait fails closed after 30 s without progress (an answer or event on that target's own guard session, or the answer to the node's attach to it; answers and events elsewhere on the stream don't count) or 5 min in all, whichever comes first, and the refusal names the bound. At most 4096 commands or 64 MiB wait on a stream; more is `RESET ENOBUFS`.
1968
1968
  - **Sessions the node doesn't know:** a page command whose `sessionId` the node hasn't seen on this stream (in a `Target.attachedToTarget`, in the answer to the page's `Target.attachToTarget` or `Target.attachToBrowserTarget`, or its own) is held, not forwarded, until the session appears, and is then decided as usual. Only messages on that session id count as progress. The same bounds and caps apply, and the refusal is `slicc: refused: slicc doesn't know which target this session belongs to: …`, naming the bound. A session that detached is refused at once, without the suffix. Commands without a `sessionId` are unaffected.
1969
1969
  - **Auto-attached targets with no URL yet** (OOPIFs, popups) are held until the URL is known, then detached if protected. After 10 s with no URL they are treated as protected. The node's own setup connection ([§1.1](#11-local-setup-over-cdp)) isn't a `cdp` stream and is the one exception. [`cdp` (browser control)](#cdp-browser-control) has the details.
1970
- - **Protection follows the target's own effective origin. Execution contexts on a protected origin are hidden, not cut,** unless the context is the target's own main-frame default context; that one still cuts the target as above. The typical case is an extension's content-script isolated world (`chrome-extension://<id>`) on an ordinary page. The page stays usable, and the hidden world is invisible and out of reach. A page that also holds a protected frame (below) loses the frame-scoped and rendering commands listed there.
1970
+ - **Protection follows the target's own effective origin. Execution contexts on a protected origin are hidden, not cut,** unless the context is the target's own main-frame default context; that one still cuts the target as above. The typical case is an extension's content-script isolated world (`chrome-extension://<id>`) on an ordinary page. The page stays usable, and the hidden world is invisible and out of reach. A content-script isolated world of an extension on an ordinary page never counts as a child frame of that page and never protects its iframes; only a real `chrome-extension:` child frame (an iframe element or an `extension_frame` target) locks the tab (#651/#661). A page that also holds a protected frame (below) loses the frame-scoped and rendering commands listed there.
1971
1971
  - **Hidden:** the node learns every context of a touched target on its own guard session, whatever the page enabled. It drops the world's `Runtime.executionContextCreated` and `executionContextDestroyed`, its `consoleAPICalled`, `exceptionThrown` and `bindingCalled`. Debugger events follow the Stage 1 publication gate below; a pause in a hidden world resumes privately and publishes nothing.
1972
1972
  - **Refused** with `slicc: refused: that execution context belongs to a browser extension`: any command that names the world through a `contextId` or `executionContextId`, `uniqueContextId`, an `executionContextName` the world has, a remote `objectId` or `*ObjectId` (call arguments included) or `callFrameId` whose injected-script part is the world, or the `scriptId` of a script in it. So `Runtime.evaluate`, `callFunctionOn`, `compileScript`, `runScript`, `globalLexicalScopeNames`, `queryObjects`, `getProperties`, `addBinding`, `Debugger.evaluateOnCallFrame`, `setVariableValue`, `setScriptSource` and `DOM.resolveNode` there are all refused. The default world, and isolated worlds the page creates itself, are unaffected by this selector rule; the Stage 1 Debugger refusals below apply in every world. A `uniqueContextId`, or a numeric `contextId` or `executionContextId`, on a target's session that names no live context the node has seen announced on that target, on its guard session or the page's (say one from a closed tab or another live tab, or a guess), is refused with `slicc: refused: that execution context is not exposed`, rather than passed to Chrome. `Runtime.addBinding` is refused on every relay session as a document-persistent command, regardless of its context selector.
1973
1973
  - **Lifetime:** a hidden world is forgotten only when Chrome reports it gone (`executionContextDestroyed`, or `executionContextsCleared` on a session that reported it), never to make room. A target with more than 4096 live hidden worlds is refused every command there that names an execution context, object, call frame, script or context name, until its contexts are cleared. Seen contexts follow the same lifetime and bound; once a target passes 4096, contexts announced after that are refused as not exposed until its contexts are cleared, even if some are destroyed in between.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@ai-ecoverse/slicc",
3
- "version": "1.67.12",
3
+ "version": "1.67.14",
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.67.12",
22
- "@ai-ecoverse/slicc-darwin-amd64": "1.67.12",
23
- "@ai-ecoverse/slicc-linux-arm64": "1.67.12",
24
- "@ai-ecoverse/slicc-linux-amd64": "1.67.12",
25
- "@ai-ecoverse/slicc-windows-arm64": "1.67.12",
26
- "@ai-ecoverse/slicc-windows-amd64": "1.67.12",
21
+ "@ai-ecoverse/slicc-darwin-arm64": "1.67.14",
22
+ "@ai-ecoverse/slicc-darwin-amd64": "1.67.14",
23
+ "@ai-ecoverse/slicc-linux-arm64": "1.67.14",
24
+ "@ai-ecoverse/slicc-linux-amd64": "1.67.14",
25
+ "@ai-ecoverse/slicc-windows-arm64": "1.67.14",
26
+ "@ai-ecoverse/slicc-windows-amd64": "1.67.14",
27
27
  "@ai-ecoverse/slicc-jerk": "^1.9.1"
28
28
  }
29
29
  }