@ai-ecoverse/slicc 1.59.1 → 1.60.1

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 +13 -6
  2. package/package.json +7 -7
package/README.md CHANGED
@@ -873,6 +873,8 @@ Only browsers the user named are listed: the one seven runs in, `--cdp` and `--c
873
873
  - **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*).
874
874
  - **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.
875
875
  - **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)).
876
+ - **Debugger (Stage 1).** One session per target 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, 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 are published with 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. 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.
877
+ - **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 the next document; commit and drop release its bytes.
876
878
  - **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.
877
879
  - **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*).
878
880
  - **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.
@@ -1861,12 +1863,12 @@ On a [§1.3](#13-local-setup-without-cdp-loopback-signalling) loopback link, `un
1861
1863
  - **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.
1862
1864
  - **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.
1863
1865
  - **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.
1864
- - **Hidden:** the node learns every context of a touched target on its own guard session, whatever the page enabled. It drops these events from the stream: the world's `Runtime.executionContextCreated` and `executionContextDestroyed`, its `consoleAPICalled`, `exceptionThrown` and `bindingCalled`, and `Debugger.scriptParsed`/`scriptFailedToParse` for scripts in it. It also drops `Debugger.breakpointResolved` in those scripts. A `Debugger.paused` whose top frame is in the world is dropped, and the node resumes the target. The world's frames lower in the stack are removed from the call frames.
1865
- - **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. 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.
1866
+ - **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.
1867
+ - **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.
1866
1868
  - **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.
1867
1869
  - **Protected frames in the page's own process:** a default execution context on a protected origin whose frame isn't the target's main frame, such as an `about:blank` or `srcdoc` child that inherits seven's origin, marks the whole target as holding a protected frame. So does a target past the 4096-hidden-world bound, or a hidden default context reported without a `frameId`. While that holds, the node refuses with `slicc: refused: target is on seven's origin` every command that names that frame's `frameId`; every `DOM`, `DOMSnapshot`, `Accessibility` and `Input` command except `enable` and `disable`; `Page.getFrameTree`, `getResourceTree`, `getResourceContent`, `captureSnapshot`, `printToPDF`, `captureScreenshot` and `startScreencast`; the `LayerTree` snapshot commands (`makeSnapshot`, `loadSnapshot`, `replaySnapshot`, `profileSnapshot`, `snapshotCommandLog`); `HeadlessExperimental.beginFrame`; and `Cast.startTabMirroring`. A screencast already running when that state begins is stopped (`Page.stopScreencast` on the page's session), and its `Page.screencastFrame` events are dropped until the page starts a new cast, which works again only once the state has ended. A screenshot, layer replay, profile, command log or begin-frame answer that arrives after the state began is replaced with the same refusal. The state ends when Chrome reports the frame's context gone or the contexts cleared. Meanwhile a document that inherits its origin from one of the target's in-process child frames is refused; [`cdp` (browser control)](#cdp-browser-control) has the rules for inherited documents and their openers. A protected iframe target in another process also puts its page ancestor in this state, including an ordinary-origin iframe target whose renderer holds a protected local frame. The node resolves its `parentFrameId` from main-frame target ids, observed frame ids and execution-context frame ids; for preloaded frames it also reads frame trees through private sessions. Those internal answers and session attach/detach events are not forwarded to the client. An unresolved or missing parent locks every page target in the same browser context until ownership is resolved. The parent lock belongs to the root document the iframe is in: a new root document releases the old one's frames, which may stay frozen in the back/forward cache, and restoring that document locks the page again at once. When the node didn't see which document a protected iframe directly under the page belongs to, it asks Chrome privately which element owns the frame. Only Chrome's explicit answer that the frame isn't there releases the lock, until the root document changes or the frame attaches again; any other answer, or none, keeps it. The lock also ends when the iframe target goes away or ceases to be protected, including when its protected local-frame state ends. The rest of the page stays drivable, with the event filtering above: navigation, `Runtime` in the default world, `Network`, `Fetch` and the other domains.
1868
1870
  - **Heap profiling:** a page's heap snapshot covers its whole renderer, other worlds included. So on page, iframe, background page and webview sessions every `HeapProfiler` command except `enable`, `disable`, `collectGarbage` and `getHeapObjectId` is refused with `slicc: refused: HeapProfiler reads the page's whole renderer, browser extensions' worlds included`, whether or not an extension is there.
1869
- - **Breakpoint conditions** run in whatever world the script belongs to, and a breakpoint by URL outlives reloads. So on those sessions a `Debugger.setBreakpointByUrl` with a `condition` needs a non-empty `url`, which can't name a protected script (see above). One by `urlRegex` or `scriptHash` or with an empty `url` is refused with `slicc: refused: a breakpoint condition that could run in a browser extension's world needs a url naming the page's own script`. Breakpoints without a condition are allowed; a pause they cause in a hidden world is resumed out of sight.
1871
+ - **Debugger (Stage 1):** one session per target owns the debugger. Only `Debugger.enable`, `setInstrumentationBreakpoint`, `disable`, `removeBreakpoint` for the owner's breakpoints, and `resume` at that owner's published pause are admitted. Admission requires an ordinary target, a ready navigation guard, no hidden world and the whole-target check used by `Page.getFrameTree`. Every other command in `Debugger`, `DOMDebugger` and `EventBreakpoints` is refused: URL breakpoints (`setBreakpointByUrl`), stepping, `DOMDebugger.getEventListeners`, `getScriptSource` and `evaluateOnCallFrame` included. No client can send `Debugger.pause`. `scriptParsed` and `scriptFailedToParse` are held, not forwarded on arrival: only the verified pause's script records are published with it; `breakpointResolved` and unrelated Debugger events are suppressed. Each `Debugger.paused` is held behind a live frame-tree read, bounded to 2 s, that verifies the owner's document generation and the placed ordinary main-world contexts of every call frame. An instrumentation pause is converted privately to a normal pause with the same owner, generation and deadline; evaluations and contexts already published in that document resume privately without conversion. An unplaced child may settle within the pause's deadline. Anything protected, stale or unverified resumes privately with nothing published. An owned pause has a 5 s deadline and guard-owned resume on expiry; a commit, hidden world or protected frame revokes its publication. A `Debugger.resumed` reaches the owner only for its published pause while that proof still holds.
1870
1872
  - **Profiles, coverage, stacks and initiators** can name any script in the isolate. So the node scrubs every message it sends the page, events and command results alike, outside opaque values (`value`, `preview`, `customPreview`, `arguments`, `returnValue`). Any `callFrames` list loses the frames on a protected URL or in a hidden world's script. That covers console, exception, pause, async, node-creation and initiator stacks, whatever the method. A coverage or type-profile list (entries with `scriptId` and `functions` or `entries`) also loses its entries for scripts without a URL. A profile node's `callFrame` in such a script becomes `(program)` and loses its `positionTicks`. An `initiator` on a protected `url` loses that `url` and its position.
1871
1873
  - **Messages without a context:** on page-like sessions, the node drops `Console.messageAdded` whose `url` is empty or protected. It drops `Log.entryAdded` on a protected `url` or with a stack through such a frame. It drops `Profiler.consoleProfileStarted` and `consoleProfileFinished` altogether: they name no context, so the node can't tell whose `console.profile` they are.
1872
1874
  - **Requests and sockets a hidden world starts:** a `Network.requestWillBeSent`, `webSocketCreated` or `webTransportCreated` whose initiator stack runs through a frame on a protected URL or in a hidden script, or whose initiator `url` is protected, marks the request as the hidden world's (a WebTransport by its `transportId`). The node learns this on its own guard session as well as on the stream's sessions. Every later message to the page that names that request anywhere in its params or result, by `requestId`, `networkId`, `transportId` or any `…RequestId` (such as `Log`'s `networkRequestId`), is cut as a whole, and a `Log.entryAdded` about it is dropped. That includes extra-info events and nested references such as an `Audits` issue's affected request:
@@ -2334,7 +2336,7 @@ App holds at most one frame encoding and one latest pending safe frame; slicc on
2334
2336
 
2335
2337
  **Association-wide admission.** Native screen has tight sublimits: one active image stream/channel, one outstanding state and one stop request; screen OPEN attempts <=10/s burst 10; state <=5/s burst 1; one bounded partial image record plus one latest unsent frame; all image/safety lengths/rates/deadlines above apply. Bulk screen DATA always uses its own channel. Separate SCTP channels still share resources and provide no scheduler isolation.
2336
2338
 
2337
- All peer-initiated kinds additionally have association-wide admission limits before expensive parser/allocation/logging work: live channels, streams, outstanding OPENs, OPEN/s, CREDIT/s and other control/s. These count and rate limits do not introduce a shared allocation budget for existing capabilities. Quotas are set to at least 4x measured CI per-session peaks, with more headroom where measurements require it; no invented small limits may break existing exit/CDP/fs traffic. CREDIT has its own bounded CPU bucket, sized above measured valid credit traffic, including screen at 8 MiB/s; byte-accounting validation alone does not bound tiny-credit CPU cost. Frame-window/length validation remains mandatory. Per-peer buckets include all channels, not a separate allowance for every new channel.
2339
+ All peer-initiated kinds additionally have association-wide admission limits before expensive parser/allocation/logging work: live channels, streams, outstanding OPENs, OPEN/s, CREDIT/s and other control/s. HTTP/CDP allocation reservations below are independent of these count and rate limits. Quotas are set to at least 4x measured CI per-session peaks, with more headroom where measurements require it; no invented small limits may break existing exit/CDP/fs traffic. CREDIT has its own bounded CPU bucket, sized above measured valid credit traffic, including screen at 8 MiB/s; byte-accounting validation alone does not bound tiny-credit CPU cost. Frame-window/length validation remains mandatory. Per-peer buckets include all channels, not a separate allowance for every new channel.
2338
2340
 
2339
2341
  Admission measurements used 138 association records across four CI runs. Ordinary link/remote/CDP and 64 simultaneous exit fetches plus a small pnpm install gave maxima: page/node channels 65/2, streams 64/1, pending OPENs 8/1, OPEN/s 66/4, CREDIT/s 1524 in the busier direction, other control/s 128. Mounts/fs-notice opened no links. These workload maxima are not guarantees of all possible workloads.
2340
2342
 
@@ -2349,9 +2351,14 @@ Admission measurements used 138 association records across four CI runs. Ordinar
2349
2351
  | Stream-window floor | (256+16) × 256 KiB = 68 MiB; not a total memory ceiling |
2350
2352
  | CLI SCTP receive storage | 4 MiB; separate from application buffers |
2351
2353
  | Existing HTTP header limit | 1 MiB per stream |
2352
- | Existing CDP buffers | 64 MiB per relay buffer; separate from stream windows and other allocations |
2354
+ | Existing CDP buffers | 64 MiB per message and parked-command queue; separate from stream windows |
2355
+ | Shared HTTP/CDP raw-buffer reservations | 512 MiB per CLI process across links; includes HTTP request-head buffers, CDP browser/message buffers, parked commands, guarded holds and outgoing framing |
2353
2356
 
2354
- Both initiator groups can coexist, so the window floor sums both quotas. A receiver must accept bytes inside credit already granted. Existing HTTP and CDP handlers allocate their own bounded per-stream/per-relay buffers; these allocations, runtime overhead and transport storage are additional. There is no node-wide memory total or shared allocation reservation across the old capabilities. Shared allocation reservations are tracked separately in [#606](https://github.com/ai-ecoverse/slicc-cli/issues/606). Screen retains its own tight slots, and safety/stop uses an independent local lane and invalidates authority without acquiring an HTTP/CDP buffer lock or waiting for their queues, remote credit, audit I/O or acknowledgements. Regression coverage holds a nearly full 1 MiB HTTP header and 64 MiB CDP message open while revoking screen and preserving both streams. This checks scheduling independence under synthetic buffer load, not a hard real-time guarantee under system-wide memory exhaustion.
2357
+ Both initiator groups can coexist, so the window floor sums both quotas. A receiver must accept bytes inside credit already granted. The separate 512 MiB shared reservation covers raw HTTP request-head and CDP relay buffers before allocation or growth. HTTP reserves 1 MiB before OPENED, releasing after parsing. Each CDP browser reader initially reserves 4 KiB before dialing/OPENED and reserves its next capacity without waiting before every growth allocation. Growth copies while both reservations remain held, then releases the old one. Its capacity doubles up to 64 MiB + 1 byte, shrinking back to the 4 KiB step for the next message. Exhaustion resets only that relay with `ENOBUFS`, including during bootstrap/version reads; idle relays do not reserve their maximum possible message size. Page messages reserve their declared length before reading the body and returning CREDIT. Parked commands, browser messages retained by guard holds and outgoing length-prefixed copies reserve their retained capacity separately. Stage 1 debugger script copies, retained script IDs and held pause data also reserve before retention, while `SLICC_CDP_DEBUGGER_BYTES` keeps its existing per-guard ceiling of 64 MiB as an inner limit. Replacements, debugger disable, document invalidation and relay termination release those reservations. Debugger publication pins its retained input through forwarding and reserves the complete batch before allocating the outgoing frame buffer; any shared-budget failure resets the relay immediately without publishing unchecked content. The default budget is shared across every link in this CLI process; an embedded caller may supply a smaller budget, capped at the same maximum.
2358
+
2359
+ New HTTP/CDP streams that cannot reserve are reset with existing `ENOBUFS`. An existing CDP page parser waits only in its handler worker before consuming further bytes, so the peer eventually exhausts its unchanged 256 KiB window. Reset/link loss cancels that wait. Guard holds never wait: reservation exhaustion resets that relay, without forwarding unchecked content or pretending delivery. Parked-command and outgoing-frame exhaustion also resets the relay with `ENOBUFS`. Reservations follow held messages through release/forwarding and are returned on completion, reset, bootstrap/dial failure and other errors. No allocation wait runs in the link read loop or control-channel dispatcher, and granted credit is never reduced.
2360
+
2361
+ This is a raw-buffer bound, not a node-wide memory ceiling: transport windows/SCTP storage, HTTP body prebuffers, HTTP transport/TLS/decompression, decoded JSON and guard metadata/serialization working memory, Go runtime overhead and garbage awaiting collection are additional. Screen retains its own tight slots and does not acquire or consume this reservation; its 68 MiB stream-window floor above is unchanged and is not counted again in the HTTP/CDP budget. Safety/stop uses an independent local lane and invalidates authority without waiting for their queues, remote credit, audit I/O or acknowledgements. Regression coverage holds a nearly full 1 MiB HTTP header and 64 MiB CDP message open while revoking screen and preserving both streams, and concurrent HTTP/CDP tests admit 32 idle CDP relays across two links plus a large browser reply, exhaust a shared budget, check refusal/backpressure and verify zero reservations after completion/reset/error/link loss. These checks establish scheduling independence under synthetic buffer load, not a hard real-time guarantee under system-wide memory exhaustion.
2355
2362
 
2356
2363
  Quota breach sheds screen first and refuses a new OPEN once with `EBUSY` if an OPEN is being admitted. It never resets an existing exit, CDP or other stream and never closes the association merely for quota exhaustion. Rate-limit admission/refusal work, coalesce one first-violation audit entry and drop further screen work rather than log every rejected frame. Existing outer-v1 malformed protocol rules remain distinct from quota policy. Refusals are fixed-string, constant-time EBUSY responses; audit only the first quota event until connection end. More than 32 refused OPENs/s sustained over a 2 s window (not one isolated burst) is the sole quota-based exception: close the link so every opener gets a reply or link close. Status line and JSON link-lost reason are exactly `seven opened streams faster than slicc allows; closed the link`. Below that sustained-abuse threshold, screen is shed and existing streams remain intact. Account/refuse excess OPENs without expensive JSON/signature/logging or retaining a refusal queue; the 32/s value is the sustained-abuse threshold, not a rule allowing unanswered OPENs. CREDIT arithmetic remains checked for every admitted frame; exceeding its rate bucket suppresses screen and defers new admissions, never discards valid existing credit or resets an existing stream. The bounded constant-time framing/accounting path keeps reading; no expensive JSON/signature/audit work is scheduled above admission budgets.
2357
2364
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@ai-ecoverse/slicc",
3
- "version": "1.59.1",
3
+ "version": "1.60.1",
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.59.1",
22
- "@ai-ecoverse/slicc-darwin-amd64": "1.59.1",
23
- "@ai-ecoverse/slicc-linux-arm64": "1.59.1",
24
- "@ai-ecoverse/slicc-linux-amd64": "1.59.1",
25
- "@ai-ecoverse/slicc-windows-arm64": "1.59.1",
26
- "@ai-ecoverse/slicc-windows-amd64": "1.59.1",
21
+ "@ai-ecoverse/slicc-darwin-arm64": "1.60.1",
22
+ "@ai-ecoverse/slicc-darwin-amd64": "1.60.1",
23
+ "@ai-ecoverse/slicc-linux-arm64": "1.60.1",
24
+ "@ai-ecoverse/slicc-linux-amd64": "1.60.1",
25
+ "@ai-ecoverse/slicc-windows-arm64": "1.60.1",
26
+ "@ai-ecoverse/slicc-windows-amd64": "1.60.1",
27
27
  "@ai-ecoverse/slicc-jerk": "^1.4.0"
28
28
  }
29
29
  }