@ai-ecoverse/slicc 1.68.4 → 1.69.0
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.
- package/README.md +6 -4
- package/package.json +7 -7
package/README.md
CHANGED
|
@@ -925,6 +925,7 @@ Only browsers the user named are listed: the one seven runs in, `--cdp` and `--c
|
|
|
925
925
|
- **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`, `autoAttachRelated`, `Browser.getWindowForTarget` and any other command whose `targetId` or `frameId` is a protected target (except `Target.closeTarget` on a protected `page` or `tab` that this stream created, touched, or opened after the touch — a popup or tab whose `Target.targetCreated` saw an opener or openerFrame this stream had already touched (`navTargets`) or already marked stream-opened; that decision is made once at creation and never walks the opener chain at close time, so a vault or seven tab the user opened from a page before this stream attached to that page stays refused even after the attach; for example attaching and navigating or restoring onto a protected origin, including a sticky error page: that close is forwarded so seven can dismiss a leftover it itself produced, except a live seven-UI page (a catalog seven origin or a guard extra origin under `/os/`, other than `/os/callback.html`) or a vault page (`vault.sliccy.ai` and `vault-*` previews, every path), in any spelling the protect package already judges (view-source wrapping, a `blob:` minted by such an origin, userinfo, and an inheriting URL such as `about:blank` whose security origin or kept latch is such a page), and except while a navigation's in-flight destination is unknown or such a URL, or while the committed document is still such a URL (unknown in-flight destination refuses close even when the committed document is ordinary; before that refusal the close path fetches a fresh frame tree, and a snapshot that shows Chrome's error page for a protected URL with no later navigation request is treated as a recorded error page and stays closable); closing a protected tab this stream never touched or opened, a live vault or seven-UI tab even when this stream touched it, the link's own seven page when slicc itself set up the link over CDP in that browser (the tab `slicc attach` / default mode signalled through — `attach --signal stdio`, loopback, and tray/`follow --cdp` have no host page the guard tracks, even when `--cdp` points at a browser that hosts seven), the browser target, workers and every other non-page/tab type stay refused); 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*). An ordinary iframe whose ancestry is unknown, pending, cyclic or deeper than the ancestor limit is hidden and refused with `slicc: refused: unresolved ancestry`.
|
|
926
926
|
- **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.
|
|
927
927
|
- **Cookies.** `Network.getCookies`, `Network.getAllCookies`, `Storage.getCookies` and `Page.getCookies` answer without the cookies whose domain is protected (`sliccy.ai` and every subdomain, and each extra origin's host and its parents: cookies ignore ports), and, when the browser supplies partition data, without partitioned cookies whose `partitionKey.topLevelSite` is such a site (see "Where those promises stop" below). `Network.setCookie`, `setCookies`, `deleteCookies`, `Storage.setCookies` and `Page.deleteCookie` for such a domain, a URL on such a host, or a partition key under such a site, are refused with `slicc: refused: cookies on seven's origin`. So are `Network.clearBrowserCookies` and `Storage.clearCookies`, except in a browser context this stream created with `Target.createBrowserContext`.
|
|
928
|
+
- **Sign-in origins.** The identity-provider origins seven signs in with are protected for export only. The CLI keeps a hardcoded floor of `https://ims-na1.adobelogin.com` and `https://ims-na1-stg1.adobelogin.com` (same floor as bios / slicc-cdp), unioned with slicc-browsers' `catalog.credentialOrigins.origins` so the catalog can only add hosts — a later catalog edit that drops a host cannot reopen its export. An empty or unreadable catalog list still yields the floor. The refusal text comes from `catalog.credentialOrigins.refusal` (today `slicc: refused: this origin holds sign-in credentials`); if that text is empty or missing the `slicc: refused: ` prefix, the fallback is `slicc: refused: this origin holds sign-in credentials`. The guard withholds their cookies and web storage and refuses writes to them, on every route, failing closed. A URL, `origin` or `securityOrigin` counts when its host is one of those hosts (`http` or `https`, any port; a subdomain of one does not count), a cookie `domain` when it covers one of them (`.adobelogin.com` does, `.adobe.com` does not), a `partitionKey.topLevelSite` when its host covers one, and a storage key when its origin counts or its top-level site (after `^0`) covers one. Cookie answers leave those cookies out; cookie writes and deletes naming them are refused with that refusal text, and `clearBrowserCookies` and `Storage.clearCookies` keep the rule above. `Network.*` and `Fetch.*` events lose `Cookie` and `Set-Cookie` (header maps, raw header texts and cookie lists) for requests and WebSockets to those origins, for a `Set-Cookie` whose `Domain` covers one, and `associatedCookies`, `blockedCookies` and `exemptedCookies` lose those cookies on any request, judged by an entry's `cookie` and by every `Domain` attribute of its `cookieLine` (any covering one counts; an entry whose line has a control character or a `Domain` that isn't an ASCII host is dropped too). `Storage.*`, `IndexedDB.*`, `CacheStorage.*`, `DOMStorage.*` and `FileSystem.*` commands naming such an origin, storage key or `cacheId` (`getUsageAndQuota`, `getSharedStorageEntries`, `getSharedStorageMetadata` and `getInterestGroupDetails` included) are refused with the same text; `Storage.getTrustTokens` and `getAffectedUrlsForThirdPartyCookieMetadata` answer without them, `getStorageKeyForFrame` is answered, and storage events naming them are dropped. `Audits.issueAdded` is dropped when its `rawCookieLine`, `cookieUrl`, cookie `domain`, request or any URL, origin or site in it names a protected or sign-in origin, or when a cookie issue names none of cookie `domain`, `cookieUrl` and request URL. Refusals and debug lines name no origin, URL or value. `Fetch.fulfillRequest` and `Fetch.continueResponse` that plant a `Set-Cookie` or `Set-Cookie2` (including via `binaryResponseHeaders`; a non-string value, a NUL part with a control other than tab, a part that starts with a space or tab (an obsolete fold), a first part that is neither an HTTP status line nor a header, or a later part without a colon, fails closed) are refused with the same text when the paused request's URL is a sign-in origin (any such header, host-only included) or when a `Domain` attribute covers a sign-in host (including on a sub-host of an entry); `Fetch.continueRequest` with a `Cookie` request header is request-side injection, not a jar write, and is not refused by this rule. Pages on those origins stay fully drivable (listing, attach, navigate, `Runtime.*`, `DOM.*`, `Input.*`, `Page.*`), because stock clients sign in by driving the IdP page with script. So in-page script (`Runtime.evaluate`, Playwright locators) can still read their non-`HttpOnly` cookies, `localStorage`, `sessionStorage` and IndexedDB; response bodies, OAuth codes in URLs and `Authorization` headers on a drivable sign-in page are not withheld. Not covered (their pages drivable, their cookies and storage exportable): Adobe's login UI hosts such as `auth.services.adobe.com` and `adobeid-na1.services.adobe.com`, because a `Domain=.adobe.com` cookie would then cover an entry and every `.adobe.com` cookie would be withheld, and federated corporate SSO, MFA and consent hosts, which can't be listed.
|
|
928
929
|
- **Requests a page makes to seven.** For a request whose URL is protected, `Network.*` and `Fetch.*` events lose their `Cookie`, `Set-Cookie`, `Authorization` and `Proxy-Authorization` headers (in the header maps and as lines of the raw header texts, which otherwise stay, their URLs cut as everywhere) and their cookie lists, and `requestWillBeSentExtraInfo` drops seven's cookies from `associatedCookies` for any request. Chrome can send `requestWillBeSentExtraInfo` and `responseReceivedExtraInfo` before the event that names the request's URL, so the node holds them until the request is found to be protected, gets its response, finishes or fails (a WebSocket or WebTransport once it is created); one still held after 2 seconds is passed on stripped, as for a protected request. For a WebSocket, WebTransport or EventSource on a protected origin (`ws:` and `wss:` count as `http:` and `https:`), `webSocketWillSendHandshakeRequest`, `webSocketHandshakeResponseReceived`, `webSocketFrameError`, `eventSourceMessageReceived` and `dataReceived` are dropped. Reading such a request's body (`Network.getResponseBody`, `Fetch.getResponseBody`, `takeResponseBody…AsStream`, `Audits.getEncodedResponse` and the like) is refused. A request paused at the response stage whose response headers name a protected URL (an ordinary redirect into seven, say) counts as such a request too. `Fetch.continueRequest` and `Network.continueInterceptedRequest` with a `url` that the node has seen redirect into a protected origin on that target are refused with `slicc: refused: that URL redirects to seven's origin`. So is reading a stylesheet or script that came from a protected URL, directly or through a redirect: `Page.getResourceContent` and `Page.searchInResource` for its URL, and any command naming its `styleSheetId` or `scriptId`. CSS rules and styles from it reach the page with only their `styleSheetId` and `origin`. In a dedicated, shared or service worker, the node keeps its own guard session (Network only), and the worker's commands, `Runtime.runIfWaitingForDebugger` included, wait until that session's `Network.enable` answers, within the same bounds as a page's guard. A worker script other than the worker's own is readable only if that guard saw its whole redirect chain and none of it was protected; an import from before the guard attached, such as in a worker that was already running, is refused. In a page, a stylesheet or script loaded before the node attached to the tab has no redirect chain the node saw, so it stays readable even if it came through a redirect from a protected origin (a known residual). The node also checks the answer, because the page may ask before the node has seen the request. When `Network.getResponseBody`, `searchInResponseBody`, `streamResourceContent`, `getResponseBodyForInterception`, `takeResponseBodyForInterceptionAsStream`, `getRequestPostData`, `Fetch.getResponseBody`, `Fetch.takeResponseBodyAsStream` or `Audits.getEncodedResponse` answers, the node holds the answer until the request has a response (for `getRequestPostData`, until it is sent; for an intercepted request, until it is paused). If the request is protected by then, the answer is refused, and a stream it handed out is closed. If the node still hasn't seen the request after 2 seconds, the answer is refused with `slicc: refused: slicc hasn't seen this request, so it could be seven's`. `Network.replayXHR` is never forwarded: for a protected or unknown request it keeps the body-getter refusal; for a known ordinary request it is refused with `slicc: refused: Network.replayXHR follows redirects inside the browser, so it could send a request to seven's pages or the vault`. Chrome's native replay cannot classify each redirect before sending it. This does not block page-initiated fetches, XHR or subresources, including their redirects into protected origins; C5 allows those requests while the content and credential protections still apply. A URL override through `Fetch.continueRequest`, a redirect supplied through `Fetch.fulfillRequest` or `Fetch.continueResponse`, and `Fetch.continueWithAuth` make the request client-issued. The guard correlates its network ID on that target and fails a protected hop before sending it; an unmodified page continuation does not establish client ownership. Missing correlation, an unguarded worker or exhausted ownership tracking refuses the client mutation. `Network.continueInterceptedRequest` with `url` or `rawResponse` is always refused, whatever the destination; use Fetch instead. Chrome 156 removed `Network.setRequestInterception`, so its compatibility refusal has committed wire coverage rather than a native control. `IO.read` is refused, with `slicc: refused: slicc didn't hand out this stream, so it could be seven's`, unless the node passed that handle to the page in an allowed answer (`take…AsStream`, `Page.printToPDF`, or `IO.resolveBlob` as `blob:<uuid>`). - **Paused requests to seven.** A page session's own interception never gets to touch a request whose URL is protected, whatever its kind (a document, `fetch()`, XHR, an image or any other subresource), at either stage. The node keeps `Fetch.requestPaused`, `Fetch.authRequired` and the deprecated `Network.requestIntercepted` for such a request from the page and settles it itself:
|
|
929
930
|
- a document request is failed (`Fetch.failRequest` with `BlockedByClient`, or `Network.continueInterceptedRequest` with `errorReason: BlockedByClient`);
|
|
930
931
|
- any other request continues untouched (`Fetch.continueRequest`, or `Network.continueInterceptedRequest` with only its `interceptionId`);
|
|
@@ -979,8 +980,9 @@ Only browsers the user named are listed: the one seven runs in, `--cdp` and `--c
|
|
|
979
980
|
- **Refusals:** When a setup call fails, the node's session is lost or the target closes, both the navigation guard and any pending document confirmation fail immediately; the waiting commands, and any after them, are refused at once with `slicc: refused: slicc can't keep seven's origin out of this target`. An inherited document whose opener or parent was never confirmed stays refused with `…: inherited document has an unknown opener or parent; slicc never confirmed it`; if that opener or parent closed, the reason is `…: inherited document has a gone opener or parent`. An in-process opener frame must map to its owning target through the node's frame or execution-context bookkeeping, and that target's guard must have finished successfully without protected history. The owning target must also have no protected frames or exhausted world tracking, and must still expose a live ordinary default execution context for that opener frame when confirmation decides. A protected or ordinary opener whose context has disappeared stays refused; unknown frame ownership stays refused. When a bound fires, the message names it: `…: its guard made no progress in 30s` or `…: its guard wasn't ready in 5m0s`.
|
|
980
981
|
- **Caps:** more than 4096 waiting commands, or 64 MiB of them, on one stream reset it with `ENOBUFS`.
|
|
981
982
|
- **Sessions the node doesn't know.** A page command with a `sessionId` the node hasn't seen on this stream is never forwarded as it stands. The node knows a session from a `Target.attachedToTarget` it relayed or held, from the answer to the page's `Target.attachToTarget` (for a target it knows) or `Target.attachToBrowserTarget`, and from its own sessions. Commands on an unknown session wait, in order, until the session appears, then any guard setup on its target, and are then decided as usual. So a browser that answers an attach before it announces the session can't open a gap.
|
|
982
|
-
- **Progress** for an unknown session is only a message from the browser on that session id. The browser answering other commands doesn't count, because it says nothing about this session. The
|
|
983
|
-
- **
|
|
983
|
+
- **Progress** for an unknown session is only a message from the browser on that session id. The browser answering other commands doesn't count, because it says nothing about this session. The idle bound is 3 s, or a target's setup idle bound if that's shorter; the outer bound (5 min) and the caps are a target's setup ones. Each unknown session has its own deadline, set when its first command arrives, so a silent session's commands are answered 3 s after it; a session that registers before its deadline is decided as usual. When the deadline comes and progress or a stop in reading moved the idle clock, the node sets it again for the time left.
|
|
984
|
+
- **Answers:** commands on a session that never appears, on one the node saw detach (`Target.detachedFromTarget`; it remembers the last 4096) or removed because a session above it detached (below), and on one it still holds (see *Auto-attach of targets without a URL*) never reach the browser. They get Chrome's own answer for a session it doesn't have, `{"code":-32001,"message":"Session with given id not found."}`, with their `id` and `sessionId`: at once for a detached, removed or held session, and when a bound fires for one that never appears. Another stream's session is unknown on this one, so its commands get that answer only when a bound fires.
|
|
985
|
+
- **Sessions under a detached one:** when the browser detaches a session, the node also removes every session it knows under it (attached on it, or on a session under it), deepest first. Each removed session the page was shown gets its own `Target.detachedFromTarget` (its `sessionId` and `targetId`), sent on that session's parent session, children before their parent and all before the browser's event for the detached session, if the page gets that; a held or hidden one gets none. Commands the browser hasn't answered yet on the detached session and on every removed one get the `-32001` answer above at once, and their later answers are dropped. A later `Target.detachedFromTarget` from the browser for a session the node already removed is dropped, so the page sees each detach once.
|
|
984
986
|
- Commands without a `sessionId` don't wait.
|
|
985
987
|
- In touched targets, service workers are bypassed for every request, not only for protected ones.
|
|
986
988
|
- The guard covers every frame that shares the touched target's process. A cross-site iframe's navigation pauses in its parent's target, before the iframe becomes a target of its own, with the frame's id as `frameId` (the id the iframe target gets later). A popup's request pauses in the popup's target, with its `targetId` as `frameId`. A redirect into a protected origin pauses again at the request stage, with `redirectedRequestId`, even when the first URL didn't match.
|
|
@@ -996,7 +998,7 @@ Only browsers the user named are listed: the one seven runs in, `--cdp` and `--c
|
|
|
996
998
|
|
|
997
999
|
Anything else (`Runtime.evaluate`, `DOM.*`, snapshots, screenshots and so on) is refused with `slicc: refused: the target shows Chrome's error page for a protected URL, which names it; slicc only lets a page navigate, reload or close it`. Events on its sessions are filtered too: only `Target.*`, `Inspector.*`, `Network.*`, `Fetch.*`, the `Runtime` execution-context events and the `Page` navigation, loading, frame, lifecycle, window, download and interstitial events reach the page. So console messages, exceptions, `Log` entries, `DOM`, `CSS`, `Overlay` and `Debugger` events, and `Page.screencastFrame` (a screencast the page started before the tab failed would show the error page) are dropped. The node also remembers the last 16 protected URLs a target's error pages failed to load, and replaces each of them, as is and in its percent-encoded and decoded forms, with its origin in every string of every message on that target's sessions, opaque values (`value`, `preview`, `arguments`, `returnValue`) included. A command the page sent on the target's sessions before such a commit, other than the allowed ones above, can't answer from the error page either: if its answer, an error included, arrives after the commit, the page gets `slicc: refused: the target committed Chrome's error page for a protected URL while this command ran, so slicc dropped its answer` instead (a screenshot, PDF or evaluation in flight would otherwise show the error page). Its URL and title are still redacted to the origin in listings and target events. Chrome's error pages for other URLs stay fully readable. The node tracks each touched target's main frame on its guard session (`Page.enable`): the last different-document commit (`Page.frameNavigated`) was an error page when its document is `chrome-error://chromewebdata/` (slicc-browsers' `errorPage.url`, whose `target` is `previous`) and it has an `unreachableUrl`, and that holds only while the target reports exactly that URL and no navigation is under way (`Page.frameStartedNavigating`, other than same-document, until its `Page.frameNavigated`, its document request's `Network.loadingFailed`, or the frame's `Page.frameStoppedLoading`, which also ends any doubt from an event the node couldn't read or from more than 64 navigations in flight, since nothing is in flight once the frame stops loading). Otherwise, or before the guard is ready, a protected URL locks the target as above. An error page neither locks nor unlocks: a target that was already protected stays so. An error page for a URL slicc can't parse is never exempt: it locks, as the unparseable rule says. That's stricter than slicc-browsers' `errorPage` rule, which exempts any URL's error page (nothing loaded there, so the unparseable case opens no hole the parseable one doesn't). slicc-browsers accepts it as over-protection, and no shared vector forces either answer.
|
|
998
1000
|
- **Auto-attach of targets without a URL.** A cross-site iframe can attach before its URL is known (`url: ""`, which stays empty while it waits for the debugger), and so can a `window.open` popup. So when an auto-attached session (one that doesn't answer the page's own `Target.attachToTarget`) is to a page or iframe target with an empty URL, the node holds it:
|
|
999
|
-
- The page doesn't get its `attachedToTarget` yet, its events are dropped, and page commands on it
|
|
1001
|
+
- The page doesn't get its `attachedToTarget` yet, its events are dropped, and page commands on it get the `-32001` answer at once (see *Sessions the node doesn't know*).
|
|
1000
1002
|
- If the page asked for `waitForDebuggerOnStart`, the node runs `Runtime.runIfWaitingForDebugger` on it itself.
|
|
1001
1003
|
- Once the target has a URL (`Target.targetInfoChanged`), a protected target's session is detached without the page seeing it. Otherwise the page gets `attachedToTarget` with the current `targetInfo` and `waitingForDebugger: false`. The target has already started, so a script the page adds for new documents in such a frame or popup misses its first one.
|
|
1002
1004
|
- A target that has no URL after 10 s is treated as protected. A session that the node does forward makes the target touched (see above).
|
|
@@ -2011,7 +2013,7 @@ On a [§1.3](#13-local-setup-without-cdp-loopback-signalling) loopback link, `un
|
|
|
2011
2013
|
- **Workers:** a touched dedicated, shared or service worker gets a guard session too (Network only, to see its imports' redirect chains), and its commands wait for it the same way, except `Runtime.runIfWaitingForDebugger` on a shared or service worker, which goes ahead so the worker can't stall on its own guard; its imports from before the guard was ready then count as unseen and can't be read. A worker script other than the worker's own whose chain that guard didn't see, or which touched a protected URL, can't be read. In pages, scripts and stylesheets loaded before the node attached are a known residual.
|
|
2012
2014
|
- **CDP command ids:** ids at or above `0x70000000` (1879048192) belong to the CLI and are refused from clients. `0x40000000` (2^30) through `0x6FFFFFFF` is reserved for seven's (bios) guard; other clients use ids below 2^30.
|
|
2013
2015
|
- **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`.
|
|
2014
|
-
- **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
|
|
2016
|
+
- **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 idle bound is 3 s (or the setup's, if shorter), on the session's own deadline; the outer bound and the caps are the setup's. A command on a session that never appears, that detached, or that the node still holds is never forwarded and gets Chrome's own `{"code":-32001,"message":"Session with given id not found."}`, at once unless the session never appeared. When the browser detaches a session, the node also removes every session under it, sends the page one `Target.detachedFromTarget` per removed session it was shown (children first, each on its parent session), answers their unanswered commands with the same error, and drops the browser's own later detach for them. Commands without a `sessionId` are unaffected.
|
|
2015
2017
|
- **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.
|
|
2016
2018
|
- **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.
|
|
2017
2019
|
- **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.
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@ai-ecoverse/slicc",
|
|
3
|
-
"version": "1.
|
|
3
|
+
"version": "1.69.0",
|
|
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.
|
|
22
|
-
"@ai-ecoverse/slicc-darwin-amd64": "1.
|
|
23
|
-
"@ai-ecoverse/slicc-linux-arm64": "1.
|
|
24
|
-
"@ai-ecoverse/slicc-linux-amd64": "1.
|
|
25
|
-
"@ai-ecoverse/slicc-windows-arm64": "1.
|
|
26
|
-
"@ai-ecoverse/slicc-windows-amd64": "1.
|
|
21
|
+
"@ai-ecoverse/slicc-darwin-arm64": "1.69.0",
|
|
22
|
+
"@ai-ecoverse/slicc-darwin-amd64": "1.69.0",
|
|
23
|
+
"@ai-ecoverse/slicc-linux-arm64": "1.69.0",
|
|
24
|
+
"@ai-ecoverse/slicc-linux-amd64": "1.69.0",
|
|
25
|
+
"@ai-ecoverse/slicc-windows-arm64": "1.69.0",
|
|
26
|
+
"@ai-ecoverse/slicc-windows-amd64": "1.69.0",
|
|
27
27
|
"@ai-ecoverse/slicc-jerk": "^1.9.1"
|
|
28
28
|
}
|
|
29
29
|
}
|