@ai-ecoverse/slicc 1.60.1 → 1.60.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 +8 -5
  2. package/package.json +7 -7
package/README.md CHANGED
@@ -615,7 +615,7 @@ slicc attach --cdp <url> [--cdp-extra <url>]... [--origin <origin>]... [--signal
615
615
 
616
616
  **Setup over CDP.**
617
617
  1. slicc picks the first page tab whose URL has an allowed origin. Until there is one it says `waiting for a seven tab` and watches for new tabs. After 15 s without one it says `still no seven tab` and what to do: a browser can hide seven's own tab from debugging clients, and then this setup can't work, so link through the tray ([Remote setup](#remote-setup-slicc-join-url-follow)). `SLICC_SEVEN_QUIET` (test-only, a Go duration) replaces the 15 s. A `Target.createTarget` refused by such a browser ends plain `slicc` with the same advice.
618
- 2. It attaches, grants the tab's origin `local-network-access`, `local-network` and `loopback-network` with `Browser.setPermission` (best effort), calls `Runtime.addBinding { name: "sliccLinkSend" }`, then `Runtime.enable`.
618
+ 2. It attaches, calls `Inspector.enable` (answered by the browser even when the tab's renderer is gone, so a crashed tab shows up as `Inspector.targetCrashed` before anything waits on the renderer), grants the tab's origin `local-network-access`, `local-network` and `loopback-network` with `Browser.setPermission` (best effort), calls `Runtime.addBinding { name: "sliccLinkSend" }`, then `Runtime.enable`, and says `found seven at <origin>`.
619
619
  3. For each new default execution context of the main frame whose origin is allowed, slicc mints a nonce (16 random bytes, base64url). It then calls `globalThis.sliccLinkReceive({ "t": "hello", "v": 1, "nonce", "node" })` in that context. `node` is a random id per `slicc` process (16 random bytes, base64url), the same in every hello and HELLO of that process, so seven can tell a second `slicc` on the same browser (a `slicc prompt --cdp …` next to the bridge) from a restart of the same one. The call is retried every 100 ms to 1 s until `sliccLinkReceive` is a function.
620
620
  4. seven answers through `sliccLinkSend(JSON.stringify(message))`:
621
621
  - `{ "t": "offer", "nonce", "sdp" }`;
@@ -631,6 +631,8 @@ slicc attach --cdp <url> [--cdp-extra <url>]... [--origin <origin>]... [--signal
631
631
  - A navigation or reload ends the link, and the next allowed context starts the setup again with a new nonce.
632
632
  - A closed tab ends the link, and slicc waits for another seven tab.
633
633
  - A tab that closes while slicc attaches to it doesn't stop slicc: each setup call has 10 s, and when the tab is gone slicc looks for another seven tab.
634
+ - A crashed tab (`Target.targetCrashed`, or `Inspector.targetCrashed` on slicc's session) isn't a closed one: slicc says `seven tab crashed`, ends the link with that reason, and doesn't set up again on the dead page, whose renderer would never answer. It reloads the tab with `Page.reload` (`reloading the seven tab`) and sets up again once the browser reports `Inspector.targetReloadedAfterCrash`, or after 30 s. A tab that is running again by the time slicc looks is set up without a reload. slicc reloads at most 3 times in 5 minutes; after that it says `the seven tab keeps crashing. Reload it and slicc links it again` and waits until someone reloads the tab, closes it, or opens another seven tab, which it then prefers.
635
+ - A setup that fails while the browser connection is up doesn't stop slicc either: a call that times out or fails on a tab that is still there is tried again from the start after 1 s, doubling to 30 s, with `couldn't link the seven tab (<error>), trying again in <wait>`. A setup that succeeds resets the wait. Only a lost browser connection, or slicc stopping, ends the setup; then `slicc` (the default) ends as when the browser closes, `attach` exits 1, and agent commands stop with the error.
634
636
 
635
637
  **Setup over stdio** (`--signal stdio`), for a test harness that owns CDP itself:
636
638
  - The same messages go as NDJSON: slicc writes `hello`, `answer`, `candidate` and `bye` lines to stdout, and reads `offer`, `candidate` and `bye` lines from stdin. Messages with another nonce are ignored.
@@ -873,8 +875,8 @@ Only browsers the user named are listed: the one seven runs in, `--cdp` and `--c
873
875
  - **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
876
  - **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
877
  - **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.
878
+ - **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 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.
879
+ - **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.
878
880
  - **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.
879
881
  - **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*).
880
882
  - **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.
@@ -1543,7 +1545,7 @@ The wire protocol between seven (the page) and `slicc` (the node), v1. seven's s
1543
1545
  Used when the node already holds a CDP connection to the browser that runs seven. No key in a URL, and nothing listening on loopback.
1544
1546
 
1545
1547
  1. The node finds the seven target. That's a page target whose main-frame origin is allowed, using the same origin rule as slicc-node's gate: `https://<label>.sliccy.ai` other than the service hosts in slicc-browsers' `seven.excludedLabels`, plus any `--origin`.
1546
- 2. It attaches (`flatten: true`), calls `Runtime.enable` and `Runtime.addBinding { name: "sliccLinkSend" }`.
1548
+ 2. It attaches (`flatten: true`), calls `Inspector.enable`, `Runtime.addBinding { name: "sliccLinkSend" }` and `Runtime.enable`.
1547
1549
  3. It sends `{ "t": "hello", "v": 1, "nonce": "<base64url 16 bytes>", "node": "<random per-process id>" }` (see [§5.11](#511-agent-page-cap-agent-node--page-remote-control) for how the page uses `node`) by calling `Runtime.evaluate` on `globalThis.sliccLinkReceive?.(<json>)`.
1548
1550
  4. The page answers through the binding, `sliccLinkSend(<json>)`, with:
1549
1551
  - `{ "t": "offer", "nonce", "sdp" }`
@@ -1558,6 +1560,7 @@ Rules:
1558
1560
  - **Hello delivery** is retried until both `globalThis.sliccLinkReceive` and the `sliccLinkSend` binding exist in the main frame's context. The node calls `addBinding` again when the binding is missing (seen on macOS around the about:blank → page swap). The page should also check that `sliccLinkSend` exists before calling it.
1559
1561
  - **On exit** the node sends `bye`.
1560
1562
  - **Navigating or reloading seven drops the link.** The node runs the setup again when a new allowed context appears.
1563
+ - **A crashed seven tab is reloaded.** On `Target.targetCrashed` or `Inspector.targetCrashed` the node drops the link and reloads the tab with `Page.reload`, at most 3 times in 5 minutes, then runs the setup again once the tab is back. The page gets a fresh `hello` as after any reload.
1561
1564
  - **ICE:** host candidates only. There's no STUN or TURN, since both peers are on the same machine.
1562
1565
  - Chrome hides host candidates behind mDNS (`<uuid>.local`), so the node resolves them (pion `MulticastDNSMode` query-only).
1563
1566
  - **Candidates:** a `candidate` message carries `RTCIceCandidateInit` JSON (`candidate.toJSON()`: `candidate`, `sdpMid`, `sdpMLineIndex`, `usernameFragment`), and `null` once gathering ends.
@@ -1868,7 +1871,7 @@ On a [§1.3](#13-local-setup-without-cdp-loopback-signalling) loopback link, `un
1868
1871
  - **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.
1869
1872
  - **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.
1870
1873
  - **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.
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.
1874
+ - **Debugger (Stage 1):** one session per target on each relay stream 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 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`: 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.
1872
1875
  - **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.
1873
1876
  - **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.
1874
1877
  - **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:
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@ai-ecoverse/slicc",
3
- "version": "1.60.1",
3
+ "version": "1.60.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.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",
21
+ "@ai-ecoverse/slicc-darwin-arm64": "1.60.3",
22
+ "@ai-ecoverse/slicc-darwin-amd64": "1.60.3",
23
+ "@ai-ecoverse/slicc-linux-arm64": "1.60.3",
24
+ "@ai-ecoverse/slicc-linux-amd64": "1.60.3",
25
+ "@ai-ecoverse/slicc-windows-arm64": "1.60.3",
26
+ "@ai-ecoverse/slicc-windows-amd64": "1.60.3",
27
27
  "@ai-ecoverse/slicc-jerk": "^1.4.0"
28
28
  }
29
29
  }