@ai-ecoverse/slicc 1.57.1 → 1.58.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 +148 -4
  2. package/package.json +7 -7
package/README.md CHANGED
@@ -193,8 +193,8 @@ Six's `--version`, `version`, `--profile` and `--mount` are seven flags too, and
193
193
  A profile that doesn't exist is an error (`SLICC six's Chrome profile doesn't exist; start SLICC six once, or pick another --profile`); slicc never creates it. A path is six's when it is one of these dirs, compared case-insensitively and after resolving symlinks, so a symlink to six's profile, or a symlinked root, counts too.
194
194
 
195
195
  **The lock comes first.** Chrome's lock is `SingletonLock` on macOS and Linux (a symlink to `<host>-<pid>`; live when that process is), and `lockfile` on Windows (live when it can't be opened exclusively; slicc opens it for reading and closes it at once).
196
- - **Live and debuggable**, when the profile's `DevToolsActivePort` answers `/json/version` with its websocket path (usually six's 9222): slicc attaches to the running Chrome. `slicc` opens a seven tab in it (or uses one that is open) and links it, while six's node-server stays attached alongside. `slicc launch` prints its CDP URL, opens `--url` in a new tab when given, and waits.
197
- - **Live and not debuggable:** slicc stops with exit 1: `six's Chrome is using this profile; close it, or use --browser/--profile to pick another`.
196
+ - **Live and debuggable**, when the profile's `DevToolsActivePort` answers `/json/version` with its websocket path (usually six's 9222), or, when that file is missing or stale, a `--remote-debugging-port` on the command line of a process running on that profile answers `/json/version`: slicc attaches to the running Chrome. `slicc` opens a seven tab in it (or uses one that is open) and links it, while six's node-server stays attached alongside. `slicc launch` prints its CDP URL, opens `--url` in a new tab when given, and waits.
197
+ - **Live and not debuggable:** slicc stops with exit 1: `six's Chrome is using this profile, and slicc can't reach its debugging port; close it, or use --browser/--profile to pick another`.
198
198
  - **Free** (no lock, or a stale one): slicc launches the browser six used. That is the installed Chromium browser whose version is the profile's `Last Version` (or, without one, the version in `Local State`'s `user_experience_metrics.stability.stats_version`), the first in `slicc browsers`' id order when several match; otherwise Chrome stable. `--browser <id>` overrides it (for `slicc`, the first `--browser`; the others are extras as usual).
199
199
 
200
200
  **Nothing is written to six's profile.** No seven prefs, no clean-exit marking, no removal of `DevToolsActivePort`, `Singleton*`, the session snapshot or any other file, no extensions added or removed, and no migration. The launch passes only runtime flags, which don't persist: `--remote-debugging-port=0 --user-data-dir=<six's profile> --no-first-run --no-default-browser-check --enable-features=ForceForegroundPriorityForAllTabs`, the throwaway flags only when six's profile is in the temp dir (see [`slicc launch`](#slicc-launch---browser-id---profile-name---url-url---headless---no-seven-flags---json)), the seven flags (left out with `slicc launch --no-seven-flags`), `--headless=new` with `--headless`, and the start page. A `DevToolsActivePort` that was there before the launch is ignored until Chrome writes a new one.
@@ -835,7 +835,7 @@ Link spec §5.14 (J1). slicc-jerk (`jerk`, [Companion tools](#companion-tools))
835
835
 
836
836
  A page RESET or a closed link kills the jerk it started.
837
837
 
838
- **The host's say over leases.** A process that offers `jerk-seal` keeps, in memory, the leases it has sealed into seven: provider, lease id, expiry and when, never the credentials. Its [control socket](#running-links-slicc-tray) answers four more ops, and its `--json` prints a `credential` event for each seal, unseal and revoke ([Lifecycle events](#lifecycle-events---json-on-attach-open-pair-and-follow)). Fixture: [`credential.ndjson`](test/integration/testdata/native/credential.ndjson).
838
+ **The host's say over leases.** A process that offers `jerk-seal` keeps, in memory, the leases it has sealed into seven: provider, lease id, expiry and when, never the credentials. It records each lease before sending the lease event to seven, so an immediate unseal has its provider and expiry. Its [control socket](#running-links-slicc-tray) answers four more ops, and its `--json` prints a `credential` event for each seal, unseal and revoke ([Lifecycle events](#lifecycle-events---json-on-attach-open-pair-and-follow)). Fixture: [`credential.ndjson`](test/integration/testdata/native/credential.ndjson).
839
839
  - `{ "v": 1, "op": "leases" }` → `{ "v": 1, "sealing": true, "leases": [{ "provider", "leaseId", "expiresAt", "sealedAt" }] }`, the live leases this process served. Expired ones drop out, and so does one seven unsealed.
840
840
  - `{ "v": 1, "op": "unseal", "leaseId" }` revokes one: slicc runs the drop that seven's `unseal` runs, with no link request, and answers `{ "v": 1, "ok": true, "revoked": true, "upstream"?: true | false }` once jerk has dropped it. Then it tells seven to forget it ([§5.14](#514-jerk-caps-jerk-and-jerk-seal-page--node-j1)). A missing or malformed `leaseId` is `EPROTO`, and a lease this process didn't serve, or has already dropped, is `ENOENT`. Unseals for the same lease run one at a time across the link and control socket. A host request that waits for a successful drop answers revoked without dropping again; a later host request for an already-dropped lease gets `ENOENT`. Repeated link requests reuse the successful result until the recorded lease expires. The host request has a 60-second total deadline, including its lock wait; if the wait uses it up, the answer is `{ "v": 1, "ok": false, "error": "EBUSY" }` and the lease stays listed. Leases remain listed while a drop is in progress. If jerk fails, the answer is `{ "v": 1, "ok": false, "error": "EIO", "exit": <n> }` and the lease stays listed.
841
841
  - `{ "v": 1, "op": "seal-off" }` → `{ "v": 1, "ok": true, "sealing": false }` stops issuing: every later `seal` on this process is `RESET EACCES: the host turned off sealing on this slicc`, and HELLO leaves out `jerk-seal` from the next link on. Live leases stay, and `unseal` still works. `{ "v": 1, "op": "seal-on" }` undoes it, answered with `"sealing": true`. Neither changes what the flags allow: `follow` without `--jerk-seal` has none of these ops.
@@ -2259,6 +2259,150 @@ How a kernel program in seven reaches [§1.4](#14-a-seven-as-follower-leader-to-
2259
2259
  #### 5.17 Reserved
2260
2260
  `exec` is reserved (six's leader `exec`, parked in [slicc-cli#102](https://github.com/ai-ecoverse/slicc-cli/issues/102)).
2261
2261
 
2262
+ #### 5.18 Native view-only screen sharing
2263
+
2264
+ Native screen support is an explicit bundled-app transport; ordinary CLI links remain disabled. The `screen` capability is never offered until a verified, properly signed sliccy.app connects and a local grant is active. Genuine signed-app, exec, descriptor-handoff and running-slice validation are release gates; a merge does not enable sharing without that verified app and its approved bundled-CLI pin. The native sliccy.app owns capture, consent, source policy, the indicator and stop. slicc owns the `screen` effective capability, link streams, node lifetime and authenticated local transport; bios owns seven's consumer. There is no input capability, click/key protocol, Accessibility request or input implementation in this feature. Existing `agent`, `cdp`, `kernel-in` and browser `capture.screen` permissions grant no native capture authority and provide no fallback.
2265
+
2266
+ **Capture boundary.** A human selects eligible apps/windows or one display in sliccy.app. The fixed exclusions are the browser hosting the receiving seven (all its windows, profiles and relevant helpers), sliccy.app, and macOS authorization, TCC and password surfaces/services. System Settings is excluded by default; only the local human may allow it, and its password/permission surfaces remain excluded. Other browsers are eligible. App names, titles, seven's claimed browser, default-browser association and page Origin are not process identity. The app must establish the hosting-browser identity with trustworthy local process evidence and protect newly discovered hosts before any affected output; ambiguous local-host attribution blocks the affected source. A recipient proven to be remote does not imply that an unrelated local browser is a host. Source policy changes or recipient changes require local confirmation, never a remote choice.
2267
+
2268
+ The promise is to exclude protected **surfaces**, not to identify the provenance of every displayed pixel. An allowed app can display copied screenshots/text from a protected app. An app the user allows, such as Terminal, can automate protected apps if macOS lets it. This contract does not prevent that through other capabilities or existing local automation. It imposes no forced application allowlist or automation-proxy ban. Capture safety itself must still be provable through public macOS APIs: unresolved service-hosted sheets, system thumbnails/notifications, translucent composition, menus, child windows or transition races block the affected source; if the unsafe region cannot be bounded reliably, suppress all output. Passing a selected-window test does not qualify display capture.
2269
+
2270
+ The app's ScreenCaptureKit filter builder starts with an empty `exceptingWindows` list and asserts that it stays empty. In the display application-inclusion initializer, exceptions can add an excluded application's window; protected windows must never be placed there as purported extra exclusions. The included set is the user's selection minus protected/unknown surfaces, not a fixed product allowlist. Child-window capture is explicitly configured and tested with sheets. Window scope never silently becomes display scope. Cursor effects, audio, incidental JPEG metadata and remote whole-Mac/window inventories are absent. Source handles are opaque, session-local values, never OS window IDs, titles or paths. Every source or protection change ends the view session: first close the output gate and discard old captured/encoded/queued buffers. Advance the source/protection epochs, apply and verify the new filter, then require a fresh locally approved session before admitting fresh frames. Notifications alone do not prove invalidation precedes compositor visibility. An unprovable transition keeps that scope unavailable.
2271
+
2272
+ **Lifetime and stop.** Off by default; no headless setting or persisted permission enables it. Only local confirmation in the authenticated app creates a grant for the exact live app/CLI pair, link instance, recipient and source. One controller/view session per Mac. Grant admission and cross-child arbitration are app-wide. Resume is local and manual; reconnect, wake, unlock, restart or a recovered verifier never resumes sharing. A fresh session and fresh local consent are required after stop. A window close alone does not quit the menu-bar app; its UI says when sharing continues.
2273
+
2274
+ The native visible indicator and registered Control-Option-Command-Escape stop shortcut must be healthy before capture activates, including with the main window closed/full-screen Spaces. The menu-bar stop also remains available. Stop first atomically invalidates the app grant/output gate and discards buffers; it never waits for remote acknowledgements, an encoder, frame/control queues, MainActor work or audit I/O. slicc independently removes its effective cap before RESET/state/audit work. No post-stop parser completion, delayed state or HELLO restores it. Already transmitted pixels cannot be recalled.
2275
+
2276
+ Stop/revoke on source death, unresolved source/Space/display change, lock, sleep, session resignation, permission/indicator/shortcut/safety-monitor/audit failure, peer identity change, IPC EOF, app/CLI death, link replacement/down, or WebRTC disconnected/failed/closed. Native safety does not wait for WebRTC reconnection grace. Each side sends safety heartbeats every 500 ms; local monotonic expiry is 1.5 s after the last valid current-generation heartbeat. Frame traffic and partial bytes never renew the lease. On process scheduling after suspension, check expiry before any capture/forward/renewal; expired sessions remain disabled. A frozen process cannot execute stop: the 1.5 s lease is a liveness bound subject to scheduling, not the local-stop target. Measure native callback-to-invalidation maximum/p99 with a target <=50 ms under supported load, and healthy-transport RESET notification target <=250 ms, separately from lease failure latency.
2277
+
2278
+ **Negotiation and live capability.** Outer link framing stays v1. Native protocol is `screen.v=1`. An eligible Darwin bundled child configured for private native transport before linking may include this support-only HELLO metadata:
2279
+
2280
+ ```json
2281
+ {"screen":{"v":1,"scopes":["window","display"],"codec":"jpeg","limits":{"headerBytes":4096,"frameBytes":2097152,"longEdge":2560,"pixels":4000000,"defaultFps":5,"maxFps":10,"bytesPerSecond":8388608}}}
2282
+ ```
2283
+
2284
+ Scope metadata describes protocol support; the app must keep each source unavailable until its capture safety is proved. HELLO's static `caps` never contains `screen`; ordinary CLI runs and Linux/Windows/wasm omit the metadata too. No grant/session/epoch from HELLO is trusted. Each new link starts with effective screen caps `[]`. The page must advertise page cap `screen-state`; otherwise no grant and any `screen` OPEN is `EACCES`. An old page cannot receive pixels. A node incorrectly listing `screen` in HELLO caps is incompatible with this extension; bios does not open screen streams on that link. The extension authorizes `screen`, `screen-stop` and `screen-state` handling by the support metadata and negotiated page cap, without changing static gates for other kinds.
2285
+
2286
+ A full `screen-state` replacement has `caps` exactly `[]` or `["screen"]`; duplicate/other capabilities are `EPROTO`, clear viewing and never affect net/http/fs/cdp/credentialed or other link grants. `["screen"]` is the effective capability only while the authenticated native grant is active. On stop both brokers remove it immediately; delivery of the replacement is best effort. Support is not a grant. Limits use the minimum of node support, app grant, page implementation and OPEN request ceilings.
2287
+
2288
+ **JSON and identity rules.** All new records reject invalid UTF-8, duplicate keys at any nesting depth, trailing data, excessive nesting (>8) and every unknown field before use. v1 has no extension namespace; adding fields requires a negotiated protocol revision. u64 counters are JSON decimal strings matching `^(0|[1-9][0-9]{0,19})$`, additionally <=18446744073709551615; reject signs, exponents, fractions, leading zeros and overflow without wrapping. Go/Swift use checked unsigned arithmetic and JS compares BigInt, never Number. Small bounded sizes, fps and dimensions are JSON integers in their stated ranges. Binary lengths and existing outer stream IDs are unsigned big-endian integers; validate before allocation/addition. Reaching a counter limit revokes before increment and requires a fresh session/link as appropriate.
2289
+
2290
+ `link` is a fresh 128-bit random unpadded base64url ID per actual link instance, unrelated to hostname, persistent certificate or HELLO node ID. `session` and `source` are app-issued random 128-bit unpadded base64url IDs. `grantEpoch`, `sourceEpoch` and `protectionEpoch` are app-maintained u64 counters; together with `link`, `session` and `source` they form the required `binding` on active state, OPEN, OPENED and every frame. Both app and CLI compare it to their own live authority; these values are identifiers, not bearer tokens. Any protection/source revision invalidates pending old-binding records before accepting new ones. No old record may finish into output under a new binding.
2291
+
2292
+ `frameSeq` starts at "1" per session and strictly increases across all frames and stream reopenings, with gaps permitted for discarded frames. Stream/channel failure never resets it. A source or protection change ends the session and requires a fresh local grant with a new session ID; `frameSeq` restarts at "1" in that new session. `stateSeq` starts at "1" per link, increases across every replacement including disabled states, and outlives session/stream changes. A duplicate or lower accepted sequence is `ESTALE`; an old link/session cannot create new state. Retain the last stopped session on the same live link solely for idempotent stop; it confers no permission.
2293
+
2294
+ **Stream kinds.** OPEN and OPENED JSON <=4096 bytes for screen/stop and <=65536 for state. Native screen/stop OPENs complete within 3 s; state application has the 10 s bound below. Other kinds on a native-enabled link retain a separate 30 s OPEN deadline. Errors use fixed content-free reasons.
2295
+
2296
+ | Kind and direction | OPEN | OPENED, DATA and close |
2297
+ |---|---|---|
2298
+ | `screen`, page → node | `{kind:"screen",v:1,binding,maxFps,maxWidth,maxHeight}`; defaults 5 fps, width/height 2560, all requested values positive and within hard ceilings | Node validates the current grant, negotiates smaller output bounds, and answers `{v:1,binding,codec:"jpeg",maxWidth,maxHeight,maxFps}`. Each frame must fit maxWidth/maxHeight or the consumer resets `EPROTO`; source windows may resize within those bounds. Page sends END immediately and never DATA. Node sends frame records until RESET. One screen stream per session; a duplicate is `EBUSY`. |
2299
+ | `screen-stop`, page → node | `{kind:"screen-stop",v:1,link,session}` on control channel; allowed with support metadata even when already disabled | CLI invalidates locally first and tells the app, including when disabled or grant admission is pending. `{v:1,stopped:true}` only after acknowledgement of native invalidation issued after this Stop began; then node END, page END; no DATA. Idempotent for the current/last stopped session on this link. `ESTALE` for another session/link. App unavailable/unconfirmed within 1.5 s: `ECONNRESET`, with CLI still revoked and app lease expiring independently. |
2300
+ | `screen-state`, node → page | `{kind:"screen-state",v:1,stateSeq,caps,binding?,scope?,reason,limits?}` on control channel; `scope` is `window` or `display`; binding/scope/limits required when active; disabled form specified below | Full replacement, no DATA. Active limits have exactly the HELLO limits shape and each value <= its HELLO ceiling, else `EPROTO`; page uses the smaller limits. Page validates/applies before OPENED `{}`, then page END and node END. One update in flight, coalesce newest replacement, <=5 updates/s (burst 1); revocation bypasses coalescing locally. Completion >10 s: `ETIMEDOUT` and revoke because reliable state display is lost. No state ack gates native stop. |
2301
+
2302
+ Active state has exactly `{kind:"screen-state",v:1,stateSeq,caps:["screen"],binding,scope,reason:"active",limits}`. Disabled state has exactly `{kind:"screen-state",v:1,stateSeq,caps:[],link,lastSession,reason}`: `link` is the current live link ID and `lastSession` is null before the first grant, otherwise the last issued session on this link. Disabled state never includes binding/source/epochs/scope/limits; `lastSession` is for idempotent stop only. `stateSeq` belongs to the link and continues through every disabled/active transition. An initial screen-stop uses `{kind:"screen-stop",v:1,link,session:null}` and is idempotent only while lastSession is null; later stop uses the current/last session ID. Null never acts as a wildcard. Disabled-state link must equal every earlier accepted state's link ID on this actual link, else `EPROTO`; seven clears buffers and retains no epochs from disabled state. Seven sends Stop only after accepting at least one state, using that state's link and active session or lastSession (possibly null), never inventing either. If a fresh local grant races the click, `ESTALE` leaves that new grant active and seven shows its new active state with Stop available.
2303
+
2304
+ `reason` is a closed enum: `active`, `awaiting-consent`, `paused`, `stopped`, `source-changed`, `protection`, `permission`, `indicator`, `shortcut`, `audit`, `peer-untrusted`, `peer-lost`, `link-lost`, `lease-expired`, `stalled`, `resource-limit` or `incompatible`. `reason` is `active` if and only if caps is `["screen"]`; `active` with `[]` or any other reason with `["screen"]` is `EPROTO`. All other known reasons require `[]`. Seven maps each reason to its own fixed display text and never renders the raw enum value; unknown reason on active state is `EPROTO`, while unknown reason on disabled state displays stopped and remains ungranted. No caller-supplied reason text is rendered.
2305
+
2306
+ Stop resets active screen streams `EACCES` after local invalidation, then sends disabled state best effort. Stale binding is `ESTALE`, unavailable native peer/link `ECONNRESET`, malformed JSON/record `EPROTO`, oversized input `EMSGSIZE`, partial/stalled record `ETIMEDOUT`. Unsupported native kind is `EOPNOTSUPP`. Page RESET ends the current subscription only; it cannot grant, resume or choose a source. It may reopen under the same still-active grant; counters continue. Any abnormal native IPC loss ends the grant, not just the subscription.
2307
+
2308
+ Node sends a new state before emitting any new-binding frames. Different channels can reorder them: seven displays only a frame whose full binding matches the latest active accepted state, dropping an unmatched complete frame without treating it as new authority. If mismatch persists for 2 s it resets the subscription `ETIMEDOUT` and shows stalled. Seven clears pixels and frees buffers on whichever arrives first: local Stop click, `RESET EACCES`, disabled state or link close. Remote Stop UI clears without waiting for OPENED. It never sends enable/resume/source-choice operations.
2309
+
2310
+ **Frame records and backpressure.** Inner records span outer DATA boundaries:
2311
+
2312
+ | Bytes | Value |
2313
+ |---|---|
2314
+ | 4 | JSON-header length, u32 BE, 1..4096 |
2315
+ | header length | UTF-8 JSON `{type:"frame",v:1,binding,frameSeq,capturedMonoMs,width,height,codec:"jpeg"}` |
2316
+ | 4 | JPEG length, u32 BE, 1..2097152 |
2317
+ | JPEG length | One independent JPEG, no EXIF/comment/title/path metadata |
2318
+
2319
+ `capturedMonoMs` is a decimal u64 string of the app's monotonic milliseconds, useful for local freshness, not remote clock authority. No input coordinates, observation/action handles or global geometry are needed. Width/height are positive, longest edge <=2560 and product <=4,000,000. Validate JPEG SOF dimensions before decode/allocation, require FFD8..FFD9 framing, and require decoded dimensions equal the header. Encoded pixels are orientation-normalized; seven preserves aspect ratio and never derives authority from dimensions. No audio or cursor is included.
2320
+
2321
+ Existing DATA remains 1..65536 bytes with 256 KiB directional credit. Credit each chunk after copying into a reserved bounded record buffer, not after a complete 2 MiB JPEG; keep draining every channel. An admitted record has a 2 s absolute deadline from its first length byte, not a slow-drip-reset idle timer. END inside a record is `EPROTO`. An incomplete timed-out record resets the stream. Slicc must also finish forwarding a begun record within 2 s or reset; no credit/no progress for 2 s resets subscription and shows stalled. Native capture gate rejects frames older than 500 ms at initial release; slicc rejects a frame held >500 ms before starting transmission. Already begun reliable records cannot be selectively recalled, only RESET.
2322
+
2323
+ Size each JPEG to finish in about 1 s at the measured available link throughput, leaving margin inside the 2 s absolute deadline; reduce dimensions/quality/fps for slow relay links rather than repeatedly sending 2 MiB records that cannot finish.
2324
+
2325
+ Independent ceilings at app and node: default <=5 fps, hard <=10 fps, token bucket burst 1 frame; JPEG bytes <=8 MiB/s (8,388,608 bytes/s), token bucket burst <=2 MiB. Count encoded JPEG bytes, excluding bounded headers. Full-sized frames cannot sustain 10 fps. Lower fps/quality or discard whole unsent frames to meet all ceilings. Seven may discard superseded complete frames rather than RESET merely for presentation rate; app/node enforce the sender ceilings.
2326
+
2327
+ App holds at most one frame encoding and one latest pending safe frame; slicc one streaming record and one latest unsent record; seven one partial encoded record and one decoded presentation. Each encoded slot is <=2,101,256 bytes including lengths/header. Each raw/decoded RGBA slot <=16,000,000 bytes. App and CLI bound their row padding/conversion/codec working memory to 64 MiB per stage in total; budget failure suppresses/stops. Seven bounds its own one encoded slot and one decoded bitmap; page JavaScript cannot cap the browser JPEG decoder's internal working memory, so this is not a claim to cap total browser memory. Drop superseded whole pending frames and stop pulling source buffers under pressure. Never truncate a started record except by RESET. Retained buffers of an old binding are discarded at every stage. No captured content goes on lifecycle stdout, debug logs, telemetry or audit.
2328
+
2329
+ **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.
2330
+
2331
+ 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.
2332
+
2333
+ 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.
2334
+
2335
+ | Association resource | Agreed quota |
2336
+ |---|---|
2337
+ | Non-control channels by initiator | page 260, node 16; plus one shared control channel |
2338
+ | Live streams by initiator | page 256, node 16 |
2339
+ | Pending OPENs by initiator | page 32, node 8 |
2340
+ | OPEN attempts per direction | page 512/s burst 512, node 32/s burst 32 |
2341
+ | CREDIT per direction | 8192/s burst 8192, separate from other control; no minimum credit size (legitimate minimum measured 1 byte) |
2342
+ | Other control per direction | 1024/s burst 1024; OPEN/OPENED/END/RESET, with OPEN also charged to its own bucket |
2343
+ | Stream-window floor | (256+16) × 256 KiB = 68 MiB; not a total memory ceiling |
2344
+ | CLI SCTP receive storage | 4 MiB; separate from application buffers |
2345
+ | Existing HTTP header limit | 1 MiB per stream |
2346
+ | Existing CDP buffers | 64 MiB per relay buffer; separate from stream windows and other allocations |
2347
+
2348
+ 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.
2349
+
2350
+ 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.
2351
+
2352
+ The node requires page HELLO <=64 KiB within 3 s of control-channel open; bios retains its existing 10 s wait for the node HELLO, which has the same size cap. Native OPENs complete within 3 s except the 10 s state-application deadline. Every partial record has the earlier absolute deadline; timeout cleanup releases all reservations. Keep draining channels while enforcing bounded admission; an unread SCTP stream can stall the association.
2353
+
2354
+ **App-to-slicc transport and live identity.** Existing same-uid public control-socket `status`/`stop`/`detach`/`revoke` behavior is preserved. No new grant/frame upgrade is admitted there. The transport uses app-owned private listeners and two child-created AF_UNIX stream connections after exec, one safety lane and one image lane. Inheriting a socketpair alone is not an identity proof: `LOCAL_PEERTOKEN` can reflect mutable last-owner attribution. Private bootstrap is inherited, rather than the connected data sockets.
2355
+
2356
+ App creates a fresh 0700 same-owner non-symlink directory and 0600 listeners. Launch uses only the bundled approved CLI, a scrubbed environment with no DYLD injection/Go debug preload overrides, and fixed safe descriptor actions. Only bootstrap read FD 3 and intended stdio are inherited; retained lanes are close-on-exec. Nothing secret goes in argv/environment/stdout; join secrets remain separate on stdin/in memory. The 3 s total launch window begins immediately before the app invokes posix_spawn; it includes spawn, bootstrap, both authenticated handshakes and pairing. Each accepted connection additionally has a 3 s deadline, never extending the total launch window. No launch-window timer is renewed by bytes.
2357
+
2358
+ Bootstrap and pre-auth records are `u32 BE JSON-length` then exactly that many UTF-8 JSON bytes, length 1..4096, with no body/line terminator. One bootstrap record is `{v:1,launch,safetyPath,framesPath,challenge,parentAuditToken}`. `launch` and `challenge` are independent 256-bit random unpadded base64url values (43 characters). Paths are absolute UTF-8, <=103 bytes each, in that launch's private directory; they confer no trust. `parentAuditToken` is the app's eight audit_token_t u32 words serialized in index order, each word big-endian, then unpadded base64url of the resulting 32 bytes (43 characters). It is an expected identity to compare with the independently kernel-obtained peer, never authentication by assertion. Close the pipe after one record, reject extra/truncated bootstrap data, never log any field. The app tracks/reaps the exact child without identity reuse; the child checks parent lifetime/incarnation before activating or forwarding.
2359
+
2360
+ Both lanes obtain kernel LOCAL_PEERCRED/LOCAL_PEERPID/LOCAL_PEERTOKEN and verify the exact expected peer incarnation and pinned live signing identity before accepting any pre-auth message as authoritative. Auth sequence is strictly:
2361
+
2362
+ 1. Child creates/connects safety socket after exec and sends `{v:1,lane:"safety",launch,challenge,clientNonce}`. Child nonce is a fresh independent 256-bit random base64url value.
2363
+ 2. App independently authenticates that exact launched child, generates `connection` and `serverNonce` as independent 256-bit random base64url values, and replies `{v:1,lane:"safety",launch,challenge,clientNonce,serverNonce,connection}`. Child independently authenticates the expected app and validates all echoes before proceeding.
2364
+ 3. Child creates/connects frames socket after exec, with a fresh separate nonce, and sends `{v:1,lane:"frames",launch,challenge,clientNonce,connection}`. App verifies the same child incarnation, safety binding and connection, then replies `{v:1,lane:"frames",launch,challenge,clientNonce,serverNonce,connection}` with another fresh server nonce. Child independently verifies the app on this lane and all echoes. Neither lane accepts grant/image records before pairing.
2365
+ 4. Child sends first authenticated safety heartbeat. App's first heartbeat echoes it, proving the frames response was received; pairing/lease-ready completes only after the child receives that echo. Native grant admission waits for this ready state at both ends. App closes/unlinks listeners after pairing. Permit <=4 concurrent pre-auth accepts and 8 attempts total in the launch window; unauthenticated accepts consume no provider slot, but exhaustion fails the launch. No reconnect using old bootstrap material.
2366
+
2367
+ A PID followed by a disk lookup, process name, bundle string or JSON audit token is insufficient. Verify live audit-token guest identity at authentication, grant activation and before admitted records; monitor lifetime/exec and fail on missing/changed token, verifier error, peer exit or PID reuse. Native monitoring must close the observation race; periodic checking alone is insufficient. Do not accept a second genuinely signed copy in place of the expected child. Use recvmsg to reject SCM_RIGHTS and all other ancillary data, close received descriptors, reject truncated control data, and forbid descriptor handoff/duplication to other processes. These are trusted-program restrictions, not kernel proof that every subsequent writer is the same process. AF_UNIX mutable last-owner semantics and handoff/exec races remain explicit native/security proof obligations. Failure leaves screen unavailable, never a uid-only/path fallback; a different signed IPC architecture would need separate review.
2368
+
2369
+ After authentication both lanes use the frame-record envelope. Each safety record has JSON <=4096, body length zero, a 1 s absolute partial-record deadline and the common fields `{type,v:1,launch,connection}`. Each direction is bounded at 16 records/s burst 16 and 64 KiB/s burst 64 KiB. The following table lists the complete additional fields; no other fields are accepted. `B` below denotes the full binding already defined, `R` a fresh 128-bit random base64url request ID, and reason one of the closed enum values. All counters use canonical decimal u64 strings.
2370
+
2371
+ | type | Direction | Additional fields and legal state |
2372
+ |---|---|---|
2373
+ | `heartbeat` | Either | `{seq,echo}`. `seq` starts "1" and strictly increases per direction/connection; `echo` is "0" until one peer heartbeat was accepted, otherwise the highest accepted peer seq. Reject nonmonotonic seq, decreasing echo or echo beyond the largest locally sent seq. Only after both sockets authenticate; valid in paired-disabled, link-ready, grant-pending, active and revoked states. |
2374
+ | `link` | CLI → app | `{link,recipient,browserEvidence}`. Only paired-disabled or revoked; never replaces a current active/pending link. Recipient is `{fingerprint,setup}` with fingerprint the verified page certificate SHA-256 as 64 lowercase hex characters and setup exactly `cdp`, `loopback` or `hub`; it denotes the actual peer of this exact link, not a remote claim. Evidence grammar below. The CLI snapshots the exact live link, opaque id and recipient fingerprint together; stale queued registrations are discarded. Grants wait for completion of that current registration, and replacement during an already-started native write closes the native association. Establishes link-ready, always ungranted. |
2375
+ | `grant` | App → CLI | `{request:R,binding:B,scope,limits}`. Only link-ready after local consent/audit intent and ready lease; `B.link` must be current link. One outstanding grant. App gate remains closed. CLI verifies all local/live limits/identity and reserves the disabled session, entering grant-pending. |
2376
+ | `granted` | CLI → app | `{request:R,binding:B}` exactly matching pending grant. CLI queues the new active screen-state before this reply and enters active. App validates matching request/binding, rechecks gate/identity/source/lease, then opens capture output and enters active; images never precede this. Late reply after invalidation is discarded and never reopens the gate. |
2377
+ | `revoke` | Either | `{request:R,link,session,reason}`. `link` is current link or null before link-ready; `session` is current/last session or null before any session. Sender invalidates first in any paired state. Receiver validates current identifiers (null is never wildcard), invalidates before replying, discards all image/grant work, enters revoked. One pending revoke per direction; crossing revokes are both answered. |
2378
+ | `revoked` | Either, replying to peer revoke | `{request:R,link,session}` exactly echoing that revoke. Confirms prior local invalidation only; sender must already be revoked. Duplicates with the same known request are idempotent; unknown IDs or mismatched identifiers are `EPROTO`. No ack restores a grant. |
2379
+
2380
+ Heartbeat lease is renewed only on a fresh, complete, valid current-connection heartbeat, never on grant/link/revoke/ack/image records or partial bytes. Initial readiness has a 1.5 s absolute deadline after child frames authentication, still within the total 3 s launch window. Thereafter each side revokes when 1.5 s elapses since its last valid heartbeat; require the peer's echoed sequence to make progress within 1.5 s whenever locally sent heartbeats are outstanding, so a one-way-stalled connection cannot remain healthy. Frames/control already queued before process suspension cannot revive an expired lease. Revoke confirmation deadline is 1.5 s, independent of frame queues; timeout closes both native lanes while remaining revoked. Until confirmation, no new grant is admitted; repeated revoke requests and continued heartbeats never extend this deadline. Failed grant admission sends revoke with its request-independent fixed reason, never images. On CLI link replacement/down, invalidate first, revoke the old link/session and only register a new link after old native revocation confirms; otherwise close/relaunch disabled.
2381
+
2382
+ `browserEvidence` is exactly `{location,provenance,hosts}`. `location` is `local`, `remote` or `unknown`; `provenance` is `cdp-owner`, `loopback-owner`, `native-verified` or `unresolved`. `hosts` is an array of at most 8 `{auditToken,bundleIdentifier}` entries; auditToken has the bootstrap token encoding and bundleIdentifier is bounded ASCII <=255 bytes. `local` requires >=1 host and non-unresolved provenance; `remote` requires native-verified evidence and no local hosts; `unknown` requires unresolved provenance and an empty list. No page-provided PID/browser name/Origin is verified host evidence; setup hub alone does not prove remote location. Native app independently resolves every claimed host to live process/signature/helpers, accumulates verified host exclusions and makes the source-safety decision. Uncertainty does not clear a browser. A host-evidence change while active revokes before a new link/evidence registration; no silent widening or stale signature snapshot. These private identities never appear in wire state/audit.
2383
+
2384
+ Image lane accepts only frame records with the same envelope and current launch/connection/binding. Its JSON header adds `launch` and `connection` to the wire frame fields; slicc validates/removes these private fields before forwarding. Its partial-record deadline is 2 s absolute; frame queues/rates match the wire. Lane EOF/error, lease expiry or malformed admitted record revokes both lanes/grant; safety never waits behind an image record. No frame or byte-progress event renews safety health.
2385
+
2386
+ **Signing and cgo.** Reuse the Developer ID Application, Team ID and notarization pipeline of ai-ecoverse/slicc through that repository's existing secret workflow, owned by app/release packaging. Approved identifiers are app `ai.sliccy.mac`, CLI `ai.sliccy.slicc`, and Team `S8LB56P782`. The CLI release already signs with that identifier; no identifier migration is required. Each side pins the Apple anchor, approved Team and other side's identifier in its designated requirement. Pin Apple Developer ID trust, the approved Team and role identifier in designated requirements, validate the running guest strictly and enforce hardened runtime/no `get-task-allow` or injection entitlements. Ad-hoc/current prototype bundles fail. Notarization/install assessment does not substitute for running-code verification.
2387
+
2388
+ slicc stays `CGO_ENABLED=0`. Approved Darwin-only implementation calls public Security.framework/CoreFoundation through purego pinned to an exact dependency version, using `SecCodeCopyGuestWithAttributes` with `kSecGuestAttributeAudit`, then `SecCodeCheckValidity` with pinned requirements, checked ABI/status/CF ownership. Prove the bridge first in a throwaway Darwin test and then in the PR. A load error, missing symbol, failed framework call or identity ambiguity is untrusted: no pixels or grants. This is approved implementation direction, not demonstrated support. Shelling out to `codesign` on a path cannot replace it. If infeasible, screen remains absent until a separately reviewed signed verifier alternative is approved; Linux/Windows/wasm never gain native framework dependencies.
2389
+
2390
+ The app trusts only its bundled CLI release, already pinned by release checksum. At app build, derive and compile the exact approved CodeDirectory hash allowlist for the selected native executable slice(s) of that checksum-verified signed CLI. At runtime, require the exact launched child's audit-token guest to pass the designated requirement and running-code validity, and its validated code identity to match that compiled cdhash pin. This exact-artifact pin is the app's approved CLI floor; no CLI version extraction or execution of --version is needed. Keep CLI packaging `-s -w`, `-trimpath`, `-buildvcs=false`, CGO_ENABLED=0 and rcodesign unchanged. Never infer a version from current Go build metadata: the pinned v1.55.0 fixture has main module `(devel)` and trimpath omits -ldflags.
2391
+
2392
+ slicc carries a compiled-in minimum app version, raised in releases fixing a security problem. Read `CFBundleShortVersionString` from the exact audit-token guest's secured Info.plist via SecCodeCopySigningInformation with signing-information flags; require canonical ASCII major.minor.patch, each component 0..2147483647 without leading zeros, suffixes or overflow, and compare checked numeric triples. Missing/ambiguous metadata is untrusted; the minimum signed app version is `0.1.0`. A separately executed program, IPC version claim, strings scan or unbound adjacent file is never a source.
2393
+
2394
+ SecCodeCopySigningInformation on a dynamic guest can contain disk-derived information, and kSecCodeInfoUnique identifies static code; calling it twice is not independent proof of a kernel-observed running hash. SecCodeCheckValidity must establish running-host/disk consistency for the exact audit-token guest, with selected native architecture, strict static/signature validation and before/after incarnation/exec checks. Demonstrate that replacement/mutation/PID reuse cannot substitute a different approved artifact or metadata. If exact live binding cannot be established, no sharing. Reject translated/unsupported slices unless their exact execution/identity binding has been proved.
2395
+
2396
+ Existing verified downloads/atomic install preserve update integrity; revocation uses npm deprecation for the CLI and app updates for the app. Deprecation does not invalidate an offline/running copy; installed app pins and CLI minimums enforce their own peer policy. No signed monotonic revision, persisted floor, new key-rotation system or symbol-table packaging change is introduced. Neither signatures nor hardened runtime isolate user-owned files/configuration or previously authorized automation.
2397
+
2398
+ **Offline capabilities.** Extend the side-effect-free `capabilities --json` schema/contract 1 with an additive `screen` entry. Existing command/events/agent/control entries keep their meaning; public `control.ops` gains no native grant operations. A binary with the reviewed Darwin implementation reports `screen:{v:1,available:true,transport:"private-child-unix-v1",peer:"audit-token-designated-requirement",lanes:["safety","frames"],kinds:["screen","screen-stop","screen-state"],pageCap:"screen-state",dynamicCaps:true,codecs:["jpeg"],scopes:[...],limits:{...}}`, with the exact limits defined above and named protocol/operation discovery rather than semver inference. `available` describes compiled support, never permission or current peer eligibility; the command probes no app, TCC, socket, file or network. Unsupported builds report `screen:{v:1,available:false}` and no native operations. The running child's status additionally reports `screen:{v:1,available,providerAuthenticated,granted,reason}`, no challenge/paths/recipient secrets; app checks both compiled support and authenticated actual-child state. `available:true` reports compiled transport support only; it does not qualify any capture source or bypass native peer trust.
2399
+
2400
+ **Audit and retention.** Local audit covers admitted consent/grant/policy/source changes, pause/stop, lifecycle loss, fixed broker refusals and audit-health failures. Admission occurs before expensive parsing/logging; on abuse record one fixed first-violation reason, terminate, and make no claim to log every packet/refusal under flood. Audit records have minute-rounded wall time, event category, fixed reason, scope kind and random local session correlation only. No per-frame records, exact timing/latency, coordinates, app/target names, dimensions/lengths, image hashes, content, window titles, URLs, page fingerprints, join/IPC secrets, key/text data or clipboard. Test-only latency measurements use synthetic metadata separately from production audit.
2401
+
2402
+ App journal: `~/Library/Application Support/ai.sliccy.mac/Audit/`; CLI broker journal: its private config `audit/`. Directories 0700, files 0600, no symlink-following. Both participate in one combined budget: delete on age >=30 days or before total would exceed 100 MiB, max 10 MiB/file. Reserve/coordinate quota before append; writer/rotation/quota failure leaves grant off or revokes it. App writes consent/grant intent before opening the output gate and records result; unresolved intent after crash means unknown, never restored. The native CLI provider and the app sweep both journals under the shared lock at startup and every five minutes while running; the app also sweeps after wake, including broker files while the CLI is stopped. Cleanup does not require sharing or a new event and writes no audit row. A busy quota lock defers maintenance to the next tick; writes still prune before append. When both processes are stopped or the Mac is asleep, no cleanup daemon runs; startup/wake removes expired metadata. Stop invalidation precedes audit writes. Local deletion/export is permitted, files are not tamper-evident, and same-user/root edits cannot be prevented. No link/agent audit-history API or automatic upload. Captured content is absent from audit/debug/telemetry/error attachments; crash-memory exposure remains possible. Screenshots deliberately retained between the user and their model provider follow ordinary conversation-content retention; consent discloses that exposure. This is separate from the content-free audit policy.
2403
+
2404
+ **Seven viewer.** The consumer shows the selected device and scope, current sharing state and Stop. This version has no agent frame tool, screenshot persistence or browser-capture fallback. Already received pixels cannot be recalled. Source availability and native identity acceptance remain subject to the app and verifier checks above.
2405
+
2262
2406
  ### 6. Policy (node)
2263
2407
 
2264
2408
  #### 6.1 Where it's checked
@@ -2364,7 +2508,7 @@ PRs merge through the merge queue, which requires `ci / integration` and `ci / r
2364
2508
  1. `scripts/go-major.mjs <version>` (verify, see below).
2365
2509
  2. `scripts/release-build.sh <version>` (prepare): `scripts/package.sh <version>` builds `darwin`, `linux` and `windows` × `amd64`, `arm64` with `CGO_ENABLED=0`, `-trimpath`, `-buildvcs=false` and `-X main.version=<version>`, and `slicc-wasip1-wasm.wasm` (`GOOS=wasip1 GOARCH=wasm`) the same way, with the Go toolchain `go.mod` names (see [Reproducing a release](#reproducing-a-release)). It signs the darwin binaries with [rcodesign](https://github.com/indygreg/apple-platform-rs) (pinned by version and SHA-256, downloaded unless `RCODESIGN` names one), identifier `ai.sliccy.slicc`, hardened runtime, Developer ID with a timestamp, notarizes both in one zip with Apple's Notary API, and writes `SHA256SUMS`. The windows and linux binaries are not signed. In the release (`SLICC_SIGN=required`) a missing secret fails the build; elsewhere (`SLICC_SIGN` unset) it warns and leaves the darwin binaries unsigned, and `SLICC_SIGN=0` skips signing. The script then runs the runner's own binary with `--version`, which must answer `slicc <version>`, and `scripts/npm-stage.mjs` stages `@ai-ecoverse/slicc` and the six platform packages into `dist/npm/`, with `--wasi` also `@ai-ecoverse/wasi-slicc` (from `slicc-wasip1-wasm.wasm` and `npm/wasi-slicc/host/slicc-host.mjs`, with README.md's [Inside seven](#inside-seven) section as its README), and the same launcher as `sliccy` (two bins, `sliccy` and `slicc`, and a short preview README) into `dist/npm-next/` as `7.0.0-next.<version>`, with exact `optionalDependencies` on this release's platform packages. `npx sliccy@next` runs the bin named after the package, and both bins run the same launcher. `--bin <name>` (repeatable) overrides the bins of any staged launcher.
2366
2510
  3. `@semantic-release/github` tags and creates the GitHub release with every binary, `install.sh` and `SHA256SUMS`.
2367
- 4. `scripts/npm-publish.mjs` (publish) publishes the platform packages, then the launcher and `wasi-slicc`, through npm trusted publishing from `ci.yml` (OIDC, with provenance), then `sliccy` with `--tag next`. Versions already on npm are skipped. Before publishing `sliccy`, it checks that every exact-pinned `optionalDependencies` version is on the registry, waits up to `SLICC_REGISTRY_WAIT_SECONDS` (default 900) for freshly published ones, and fails otherwise (exit code 3), so a `sliccy` version never points at missing platform packages.
2511
+ 4. `scripts/npm-publish.mjs` (publish) publishes the platform packages, then the launcher and `wasi-slicc`, through npm trusted publishing from `ci.yml` (OIDC, with provenance), then `sliccy` with `--tag next`. Versions already on npm are skipped. After any real publish error, it checks `npm view <package>@<version> version` again and accepts an exact published version, including when a retry reports a package-version conflict. If the version is still absent and publishing reports `TLOG_CREATE_ENTRY_ERROR` or a transparency-log HTTP 409, it retries with provenance, up to three total attempts with 5- and 10-second backoffs, then fails. Other errors fail after the registry check; dry-run errors fail immediately. Before publishing `sliccy`, it checks that every exact-pinned `optionalDependencies` version is on the registry, waits up to `SLICC_REGISTRY_WAIT_SECONDS` (default 900) for freshly published ones, and fails otherwise (exit code 3), so a `sliccy` version never points at missing platform packages.
2368
2512
 
2369
2513
  After a release, the pipeline attests the build provenance of `artifacts/release/SHA256SUMS` (`attest` in `ci.yml`), which `slicc update` checks (see [Attestations](#attestations)), and `after-release` runs `scripts/go-warm.sh <version>`: it asks `proxy.golang.org` for the module at `v<version>` (`go list -m` with a scratch module cache) and asks `pkg.go.dev` to fetch it. Both only warn.
2370
2514
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@ai-ecoverse/slicc",
3
- "version": "1.57.1",
3
+ "version": "1.58.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.57.1",
22
- "@ai-ecoverse/slicc-darwin-amd64": "1.57.1",
23
- "@ai-ecoverse/slicc-linux-arm64": "1.57.1",
24
- "@ai-ecoverse/slicc-linux-amd64": "1.57.1",
25
- "@ai-ecoverse/slicc-windows-arm64": "1.57.1",
26
- "@ai-ecoverse/slicc-windows-amd64": "1.57.1",
21
+ "@ai-ecoverse/slicc-darwin-arm64": "1.58.1",
22
+ "@ai-ecoverse/slicc-darwin-amd64": "1.58.1",
23
+ "@ai-ecoverse/slicc-linux-arm64": "1.58.1",
24
+ "@ai-ecoverse/slicc-linux-amd64": "1.58.1",
25
+ "@ai-ecoverse/slicc-windows-arm64": "1.58.1",
26
+ "@ai-ecoverse/slicc-windows-amd64": "1.58.1",
27
27
  "@ai-ecoverse/slicc-jerk": "^1.4.0"
28
28
  }
29
29
  }