arcane-os 0.53.0 → 0.54.0

package/browser-runtime/dependencies/event-pubsub/dependencies/strong-type/licence

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Brandon Nozaki Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/browser-runtime/dependencies/event-pubsub/dependencies/strong-type/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "strong-type",
+  "version": "2.0.0",
+  "type": "module",
+  "description": "Dependency-free native ESM type enforcement for JavaScript values, objects, classes, browsers, and Node.",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./index.js": "./index.js",
+    "./node": "./node.js",
+    "./node.js": "./node.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "node.js",
+    "assets/strong-type-header.png",
+    "README.md",
+    "licence"
+  ],
+  "sideEffects": false,
+  "directories": {
+    "example": "example"
+  },
+  "engines": {
+    "node": ">=12.21.0"
+  },
+  "scripts": {
+    "test": "node scripts/test.js",
+    "test:core": "node scripts/test.js core",
+    "test:node": "node scripts/test.js node",
+    "test:docs": "node scripts/test.js docs",
+    "test:legacy": "node scripts/test.js legacy",
+    "coverage": "node --test --experimental-test-coverage --test-coverage-include=index.js --test-coverage-include=node.js --test-coverage-lines=95 --test-coverage-branches=90 --test-coverage-functions=95 test/CI.js test/node.js test/docs.js",
+    "start": "node scripts/serve.js",
+    "nodeExample": "node ./example/node/typecheck.js",
+    "check": "npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RIAEvangelist/strong-type.git"
+  },
+  "keywords": [
+    "strong",
+    "type",
+    "validation",
+    "validate",
+    "check",
+    "checking",
+    "esm",
+    "isomorphic",
+    "browser",
+    "node"
+  ],
+  "author": "Roshi _ _",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/RIAEvangelist/strong-type/issues"
+  },
+  "homepage": "https://riaevangelist.github.io/strong-type/"
+}

package/browser-runtime/dependencies/event-pubsub/index.js

@@ -1,5 +1,5 @@
-// Shim allowing the same module path to run in Node and an unbundled browser.
-import Is from '../strong-type/index.js';
+// Preserve the package manager's dependency boundary instead of reaching for a consumer-root sibling.
+import Is from 'strong-type';
 
 const is = new Is();
 const ALL_EVENTS = Symbol.for('event-pubsub-all');

package/browser-runtime/dependencies/event-pubsub/package.json

@@ -1,9 +1,10 @@
 {
   "name": "event-pubsub",
-  "version": "6.1.0",
-  "description": "Small, synchronous, extensible publish/subscribe events for modern Node.js and browsers.",
+  "version": "6.1.1",
+  "description": "Small, synchronous publish/subscribe events for Node.js plus bundled and unbundled browsers.",
   "type": "module",
   "main": "./index.js",
+  "browser": "./index.js",
   "engines": {
     "node": ">=22.12.0"
   },
@@ -13,6 +14,7 @@
     "test:unit": "npm run stage && node ./test-runtime/event-pubsub/test/node.js unit",
     "test:functional": "npm run stage && node ./test-runtime/event-pubsub/test/node.js functional",
     "test:integration": "npm run stage && node ./test-runtime/event-pubsub/test/node.js integration",
+    "test:behavioral": "npm run stage && node ./test-runtime/event-pubsub/test/node.js behavioral",
     "test:regression": "npm run stage && node ./test-runtime/event-pubsub/test/node.js regression",
     "test:interface": "npm run stage && node ./test-runtime/event-pubsub/test/node.js interface",
     "coverage": "npm run stage && vanilla-test coverage all",
@@ -23,11 +25,12 @@
     "benchmark:chart": "node ./scripts/benchmark-chart.js",
     "benchmark:chart:check": "node ./scripts/benchmark-chart.js --check",
     "test:package": "node ./scripts/package-smoke.js",
+    "test:browser-consumer": "node ./scripts/browser-consumer-smoke.js",
     "site:check": "npm run stage && npm run benchmark:chart:check && node ./scripts/site-check.js",
     "site:assemble": "node ./scripts/assemble-site.js _site",
     "site:deployment-check": "node ./scripts/deployment-check.js _site",
     "start": "node ./scripts/serve.js",
-    "verify": "npm test && npm run coverage && npm run benchmark:smoke && npm run test:package && npm run site:check && npm run site:assemble && npm run site:deployment-check"
+    "verify": "npm test && npm run coverage && npm run benchmark:smoke && npm run test:package && npm run test:browser-consumer && npm run site:check && npm run site:assemble && npm run site:deployment-check"
   },
   "repository": {
     "type": "git",
@@ -46,7 +49,9 @@
     "event-emitter",
     "node",
     "browser",
-    "esm"
+    "esm",
+    "import-map",
+    "unbundled"
   ],
   "author": "Brandon Nozaki Miller",
   "license": "MIT",
@@ -54,6 +59,8 @@
     "strong-type": "2.0.0"
   },
   "devDependencies": {
+    "@rollup/plugin-node-resolve": "16.0.3",
+    "rollup": "4.62.5",
     "vanilla-test": "2.1.1"
   }
 }

package/browser-runtime/dependencies/ws-share/WS.js

@@ -0,0 +1,128 @@
+const wsList = new Map();
+const connections = new Set();
+let nextId = 0;
+let events;
+
+class WS {
+    static async observe() {
+        if (!events) {
+            const {default: EventPubSub} = await import('event-pubsub');
+            events ??= new EventPubSub();
+        }
+        return events;
+    }
+
+    static getConnections() {
+        return Array.from(connections, describeConnection);
+    }
+
+    constructor(uri, protocols) {
+        if (!uri) {
+            throw new TypeError('WS requires a uri to initialize');
+        }
+
+        const address = String(uri);
+        const requestedProtocols = !protocols
+            ? []
+            : typeof protocols !== 'string' && protocols[Symbol.iterator]
+                ? Array.from(protocols, String)
+                : [String(protocols)];
+        const protocolKey = JSON.stringify(requestedProtocols);
+        let sockets = wsList.get(address);
+        const shared = sockets?.get(protocolKey);
+
+        if (shared && shared.readyState < 2) {
+            return shared;
+        }
+
+        const ws = new globalThis.WebSocket(address, requestedProtocols);
+
+        if (!sockets) {
+            sockets = new Map();
+            wsList.set(address, sockets);
+        }
+        sockets.set(protocolKey, ws);
+
+        ws.addListener = ws.addEventListener;
+        ws.removeListener = ws.removeEventListener;
+
+        Object.defineProperties(
+            ws,
+            {
+                uri: {enumerable: true, value: uri},
+                protocols: {enumerable: true, value: protocols},
+                on: {enumerable: true, value: ws.addEventListener},
+                off: {enumerable: true, value: ws.removeEventListener}
+            }
+        );
+
+        const connection = {id: ++nextId, socket: ws, protocols: requestedProtocols};
+        connections.add(connection);
+
+        function publishOpen(event) {
+            emitLifecycle(connection, 'open', event);
+        }
+
+        function publishError(event) {
+            emitLifecycle(connection, 'error', event);
+        }
+
+        ws.addEventListener(
+            'open',
+            publishOpen,
+            {once: true}
+        );
+        ws.addEventListener('error', publishError);
+        ws.addEventListener(
+            'close',
+            function releaseSocket(event) {
+                ws.removeEventListener('open', publishOpen);
+                ws.removeEventListener('error', publishError);
+                connections.delete(connection);
+
+                // A closing connection may already have a replacement.
+                if (sockets.get(protocolKey) === ws) {
+                    sockets.delete(protocolKey);
+                    if (sockets.size === 0) {
+                        wsList.delete(address);
+                    }
+                }
+                emitLifecycle(connection, 'close', event);
+            },
+            {once: true}
+        );
+
+        if (events) {
+            // Observer failures must not turn successful construction into a throw.
+            queueMicrotask(
+                function publishCreated() {
+                    emitLifecycle(connection, 'created');
+                }
+            );
+        }
+
+        return ws;
+    }
+}
+
+function describeConnection(connection) {
+    return {
+        id: connection.id,
+        socket: connection.socket,
+        url: connection.socket.url,
+        protocols: [...connection.protocols],
+        readyState: connection.socket.readyState
+    };
+}
+
+function emitLifecycle(connection, type, event) {
+    if (!events) {
+        return;
+    }
+    const detail = describeConnection(connection);
+    detail.event = event;
+    events.emit(type, detail);
+}
+
+export {WS, WS as 'module.exports'};
+export default WS;

package/browser-runtime/dependencies/ws-share/licence.md

@@ -0,0 +1,27 @@
+# DON'T BE A DICK PUBLIC LICENSE
+
+> Version 1, December 2009
+
+> Copyright (C) 2009 Philip Sturgeon <email@philsturgeon.co.uk>
+ 
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+> DON'T BE A DICK PUBLIC LICENSE
+> TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 1. Do whatever you like with the original work, just don't be a dick.
+
+     Being a dick includes - but is not limited to - the following instances:
+
+	 1a. Outright copyright infringement - Don't just copy this and change the name.  
+	 1b. Selling the unmodified original with no work done what-so-ever, that's REALLY being a dick.  
+	 1c. Modifying the original work to contain hidden harmful content. That would make you a PROPER dick.  
+
+ 2. If you become rich through modifications, related works/services, or supporting the original work,
+ share the love. Only a dick would make loads off this work and not buy the original work's 
+ creator(s) a pint.
+ 
+ 3. Code is provided with no warranty. Using somebody else's code and bitching when it goes wrong makes 
+ you a DONKEY dick. Fix the problem yourself. A non-dick would submit the fix back.

package/browser-runtime/dependencies/ws-share/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "ws-share",
+  "version": "3.1.0",
+  "description": "Share native WebSocket connections across Node.js modules and browser components, with optional lifecycle events.",
+  "type": "module",
+  "main": "./WS.js",
+  "browser": "./WS.js",
+  "files": [
+    "WS.js",
+    "ws-share-vanilla.js",
+    "CHANGELOG.md",
+    "licence.md"
+  ],
+  "scripts": {
+    "test": "node test/ws-share.test.js",
+    "build:browser": "node scripts/browser.js",
+    "prepack": "npm run build:browser",
+    "start": "node devServer.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RIAEvangelist/ws-share.git"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "keywords": [
+    "react",
+    "react.js",
+    "reactjs",
+    "websocket",
+    "websockets",
+    "web",
+    "socket",
+    "sockets",
+    "share",
+    "shared",
+    "sharing",
+    "ws",
+    "list",
+    "common",
+    "flux",
+    "reflux",
+    "component",
+    "components",
+    "store",
+    "stores",
+    "action",
+    "actions",
+    "vanilla"
+  ],
+  "author": "Brandon Nozaki Miller",
+  "license": "DBAD",
+  "bugs": {
+    "url": "https://github.com/RIAEvangelist/ws-share/issues"
+  },
+  "homepage": "https://riaevangelist.github.io/ws-share/",
+  "dependencies": {
+    "event-pubsub": "6.1.1"
+  },
+  "devDependencies": {
+    "vanilla-test": "2.1.3"
+  }
+}

package/browser-runtime/websocket-client.mjs

@@ -0,0 +1 @@
+export {default, WS} from 'ws-share';

package/docs/event-manager.md

@@ -253,10 +253,13 @@ other privileged effects.
 ## Browser delivery boundary
 
 The package entry point works directly in Node and through browser bundlers.
-The npm artifact bundles the exact `event-pubsub` and `strong-type` pair because
-`event-pubsub@6.1.0` uses a sibling-relative runtime import. Unbundled browser
-use must preserve that physical sibling layout and provide import-map entries
-for the public SDK entry and `event-pubsub`.
+The npm artifact retains its bundled `event-pubsub` and `strong-type`
+dependencies. `event-pubsub@6.1.1` resolves its declared `strong-type@2.0.0`
+through the package boundary, while the SDK's direct version remains 2.0.1.
+Unbundled browser use provides mappings for the public SDK entry and
+`event-pubsub`, plus the event package's scoped strong-type mapping. The
+canonical browser projection generator copies those installed runtime files
+unchanged; managed physical and installed-package maps preserve their scope.
 
 The managed Arcane browser runtime ships the focused entry and its
 dependency closure. Its import map resolves `arcane-os/event-manager` exactly;

package/docs/reference/ai/browser-decisions.md

@@ -0,0 +1,184 @@
+# Browser typed decisions
+
+`arcane-os/ai/browser-decisions` owns browser-local Laya typed-decisions FP16
+and Julia-1 FP32 inference. It is separate from chat and speech because these
+models score caller-supplied options instead of generating conversational text.
+Applications supply the model repository, state, questions, option meanings and
+policy; the SDK owns the reusable tokenizer, tensors, inference and lifecycle.
+
+## Explicit use
+
+```js
+import {createBrowserDecisionModel} from 'arcane-os/ai/browser-decisions';
+
+const model = createBrowserDecisionModel(
+    {
+        family: 'laya',
+        model: 'onnx-community/laya-typed-decisions-ONNX',
+        revision: 'main',
+        device: 'webgpu'
+    }
+);
+
+const unsubscribe = model.subscribe(
+    function showModelStatus(state) {
+        status.textContent = state.progress?.phase ?? state.state;
+    }
+);
+
+runButton.addEventListener(
+    'click',
+    async function decideDragonTea() {
+        try {
+            const result = await model.evaluate(
+                [
+                    {
+                        state: 'A sleeping dragon blocks the kitchen. The kettle whistles.',
+                        question: 'What should the tea robot do?',
+                        options: ['Wait quietly', 'Boil the kettle']
+                    }
+                ]
+            );
+            output.textContent = result.decisions[0].value;
+        } catch (error) {
+            console.error('The decision request failed.', error);
+            status.textContent = 'The decision could not be completed.';
+        }
+    }
+);
+```
+
+Here `status`, `runButton` and `output` are application DOM elements. Changing
+the state, question or options changes the actual model request. Importing the
+module and constructing the client start no Worker or download. Only explicit
+`load()` or `evaluate()` use loads the selected runtime and model. Concurrent
+requests share the same activation; ready inference reuses that model session.
+
+For Julia, select `family: 'julia'` and
+`model: 'SupersonicLabs/Julia-1-ONNX'`. This selects the official FP32 graph;
+it does not substitute a quantized graph or another model.
+
+## Configuration and upstream delivery
+
+| Field | Meaning |
+| --- | --- |
+| `family` | Required `laya` or `julia`; chooses the model's encoding and graph layout. |
+| `model` | Required upstream repository/base URL accepted by Transformers.js. The application owns its selection. |
+| `revision` | Upstream revision, default `main`; select a stable revision when repeatable model selection is needed. |
+| `device` | Transformers.js backend, default `webgpu`; an explicit supported alternative is caller-owned. No automatic backend fallback. |
+| `runtime.moduleUrl` | Defaults to `https://cdn.jsdelivr.net/npm/@huggingface/transformers@4.3.0/dist/transformers.web.js`. An explicit compatible public runtime URL may be supplied. |
+| `runtime.wasmPaths` | Optional upstream ONNX WASM location passed to the selected runtime's public environment API. |
+
+The runtime, tokenizer and weights use normal upstream loading and caching;
+the SDK does not redistribute them or create a second model store. Browser
+network, cross-origin and backend availability still apply. WebGPU needs a
+compatible browser/device context. Unsupported precision or backend errors
+are returned, not replaced with a different model, backend or precision.
+
+Laya selects `dtype: 'fp16'`, loading `onnx/model_fp16.onnx` and its
+`model_fp16.onnx_data` companion through Transformers.js. The published mixed
+precision graph retains selected operations/outputs in FP32; FP16 selection
+does not claim every graph operation runs in half precision.
+
+Julia selects `dtype: 'fp32'`, loading root `model.onnx` with the exact
+`model.onnx.data` external-data name. Its custom five-input graph is loaded
+through the public generic `PreTrainedModel` API, not a text-generation
+pipeline. Existing Wllama, cloud, speech and chat APIs are unchanged.
+
+## Complete rows and results
+
+`evaluate(rows, {signal})` accepts an array in caller order. Each row has
+string `state`, string `question`, string-array `options`, and optional
+`type` defaulting to `choice`. Additional row fields remain in the returned
+row without affecting inference. Neither strings nor option arrays are
+trimmed, rewritten, clipped or capped by the SDK.
+
+The model's required token framing puts the complete type/question header,
+option markers/options and state into `input_ids`; accompanying inputs are
+`attention_mask`, `marker_pos`, `marker_mask` and `qtype`. Right padding aligns
+rows in a batch. Literal marker text inside supplied content remains content;
+option positions identify only markers inserted by the encoding owner.
+Tokenizer encoding is called without special-token insertion and without
+the upstream batch-tokenizer truncation path.
+
+The result is `{decisions, outputs}`. `decisions` follows input order and each
+entry contains the original row record, option `logits`, unrounded raw-softmax
+`probabilities`, the highest-logit `answerIndex`, and `value`:
+
+| Type | `value` |
+| --- | --- |
+| `choice` | The complete selected option string. |
+| `score` | Raw-softmax weighted zero-based option index. Applications map this to their own score scale. |
+| `noul` | Probability of option 1; supply exactly `[falseOption, trueOption]` in that order. |
+
+If the actual graph supplies `act_logits`, the entry additionally includes
+complete `actionLogits`, unrounded `actionProbabilities`, and raw-softmax
+`actProbability` at index 0. Julia's
+published ONNX export has no action head; the SDK does not invent one.
+
+`outputs` preserves every returned graph tensor, including padding and extra
+named outputs, as `{type, dims, data}` with complete copied typed data. This
+keeps model results available for explicit application interpretation and
+diagnostics. Probabilities are raw model scores, not claimed calibrated
+confidence, probabilities rounded to two decimal places, or policy decisions.
+No result is inserted into chat history, memory extraction or DBOPFS.
+
+## Lifecycle, events and cancellation
+
+`status()` returns `{family, model, revision, device, dtype, state, loaded,
+busy, activeRequests, progress, error}`. States are `unloaded`, `loading`,
+`ready`, `error` and `disposed`. `subscribe(listener, {emitCurrent: true,
+signal})` observes the owning Arcane event source, replays current state by
+default and returns an unsubscribe function. Successful rows and graph results
+return to the calling operation rather than lifecycle notifications. Complete
+errors, including graph diagnostics when decoding fails, remain available in
+`error`; they belong in developer diagnostics, not ordinary status text.
+
+Work is acknowledged synchronously before loading/inference waits. Progress
+reports real semantic phases such as `waiting-for-model`, `loading-runtime`, `loading-tokenizer`,
+`loading-model`, `ready`, `evaluating` and `complete`; it is not a synthetic
+percentage. Loading the model and tokenizer proceeds concurrently. Repeated
+identical state text is tokenized once per batch. Independent requests are
+accepted concurrently; the selected backend still owns its execution ordering.
+
+`load({signal})` explicitly prepares the shared activation. `evaluate()` also
+loads on its first explicit use. An `AbortSignal`, `unload()` or `dispose()`
+terminates the client's dedicated Worker and rejects all its outstanding
+operations. Cancellation is client-wide because the model session and GPU
+work belong to that Worker. Use separate clients when independent cancellation
+is required. `unload()` permits later explicit reactivation; `dispose()` is
+terminal. Old Worker replies cannot affect a replacement activation.
+
+A Worker operation failure releases the failed activation and rejects its
+waiting calls. The next explicit use starts a fresh Worker rather than reusing
+an upstream inference queue that may remain rejected after a backend failure.
+Error records preserve the original
+name, message, stack, code, cause and available custom fields across the Worker
+boundary. Applications keep technical diagnostics out of ordinary user status.
+
+## Model limits and evidence
+
+The published Laya and Julia families advertise an 8192-token native context.
+Their reference wrappers apply smaller budgets and, for Julia, a documented
+2–20-option interface. The SDK does not reproduce those wrapper clipping or
+rounding policies or claim arbitrary lengths are supported by the graph.
+Actual model/backend failures remain observable. Long-input quality and
+option-count behavior must be established for the application's selected
+model; no hidden windowing or result aggregation is performed.
+
+Julia's Transformers.js tokenizer route exists in the official browser
+adapter, alongside a Rust tokenizer. Repeated-space/Metaspace segmentation can
+differ between those tokenizer implementations. Complete text is preserved at
+the tokenizer boundary, and Python/Rust token-ID or numerical parity is not
+claimed. Applications needing that parity must use an established compatible
+tokenizer contract rather than silently rewriting text.
+
+Upstream graph/loading contracts were reviewed from primary source. Browser
+model loading, FP16/FP32 inference, cancellation and numerical behavior require
+selected-output verification; static compatibility review alone is not a
+runtime pass.
+
+Primary references: [Laya ONNX](https://huggingface.co/onnx-community/laya-typed-decisions-ONNX),
+[Laya reference](https://github.com/NandhaKishorM/laya),
+[Julia-1 ONNX](https://huggingface.co/SupersonicLabs/Julia-1-ONNX),
+[Transformers.js 4.3.0](https://github.com/huggingface/transformers.js/tree/4.3.0/packages/transformers).

package/docs/reference/inventory/package-api.json

@@ -6,12 +6,40 @@
     "minimumVersion": "22.23.2 for Node entrypoints",
     "moduleSystem": "ESM"
   },
-  "memberCount": 224,
+  "memberCount": 226,
   "runtimeSubpathPatterns": {
     "arcane-os/modules/*": "./runtime/arcane/modules/*",
     "arcane-os/entities/*": "./runtime/arcane/entities/*"
   },
   "members": [
+    {
+      "id": "root:WS",
+      "name": "WS",
+      "displayName": "WS",
+      "kind": "class",
+      "signature": "new WS(uri,protocols?)",
+      "entrypoints": ["arcane-os", "arcane-os/websocket-client"],
+      "primaryImport": "arcane-os/websocket-client",
+      "group": "Shared WebSocket clients",
+      "summary": "Published ws-share constructor with shared native sockets, one lifecycle observer and current connection snapshots.",
+      "availability": "Node and browser hosts with native WebSocket; browser use requires the focused managed module entry",
+      "protocol": "Native WebSocket per-socket events plus event-pubsub created/open/error/close and wildcard lifecycle records",
+      "normalization": "Exact native socket and complete messages; URI plus ordered requested protocols select the per-loaded-module pool"
+    },
+    {
+      "id": "browser-decisions:createBrowserDecisionModel",
+      "name": "createBrowserDecisionModel",
+      "displayName": "createBrowserDecisionModel()",
+      "kind": "function",
+      "signature": "createBrowserDecisionModel({family,model,revision,device,runtime})",
+      "entrypoints": ["arcane-os/ai/browser-decisions"],
+      "primaryImport": "arcane-os/ai/browser-decisions",
+      "group": "Browser typed decisions",
+      "summary": "Explicit-load Laya FP16 and Julia-1 FP32 decisions with complete inputs and graph results.",
+      "availability": "Browser module Workers and the selected Transformers.js backend; import/construction starts no model load",
+      "protocol": "Caller-owned state/question/options rows; five-input decision graph; native Worker request/result lifecycle",
+      "normalization": "Full field tokenization, raw logits and unrounded softmax; no policy thresholds, storage or precision fallback"
+    },
     {
       "id": "root:acceptWebSocket",
       "name": "acceptWebSocket",
@@ -2137,7 +2165,7 @@
       "name": "verifyApp",
       "displayName": "verifyApp()",
       "kind": "function",
-      "signature": "async verifyApp({workspaceRoot, appId, signal, onEvent})",
+      "signature": "async verifyApp({workspaceRoot, appId, outputDirectory, signal, onEvent})",
       "entrypoints": [
         "arcane-os",
         "arcane-os/packager"

package/docs/reference/inventory/runtime-modules.json

@@ -8,9 +8,9 @@
     "sdkVersion": "0.51.1",
     "protocol": "arcane/1"
   },
-  "artifactCount": 92,
-  "javascriptArtifactCount": 90,
-  "esmExportCount": 372,
+  "artifactCount": 93,
+  "javascriptArtifactCount": 91,
+  "esmExportCount": 373,
   "artifacts": [
     {
       "file": "runtime/arcane/modules/AI.js",
@@ -719,12 +719,25 @@
       "exports": [
         "default"
       ],
-      "summary": "Defines the same-origin `<html-import>` loader with open shadow root, inline script execution, and readiness/error events.",
+      "summary": "Defines the same-origin `<html-import>` loader with open shadow root, inline or packaged external script execution, and readiness/error events.",
       "availability": "Browser / native WebView",
       "protocol": "Same-origin fetch + DOM",
       "normalization": "Public error detail normalized; fetch/DOM failure preserved.",
       "surface": "default `HTMLImport`; registers `html-import`; `connectedCallback()` and `ready`."
     },
+    {
+      "file": "runtime/arcane/modules/HTMLImportScript.js",
+      "name": "HTMLImportScript.js",
+      "kind": "esm",
+      "exports": [
+        "createHTMLImportScript"
+      ],
+      "summary": "Renders the complete classic-script host wrapper shared by HTMLImport and native-module packaging.",
+      "availability": "Cross-host",
+      "protocol": "In-process only",
+      "normalization": "Complete source retained with a terminating newline before the wrapper closes.",
+      "surface": "`createHTMLImportScript(source)` returns the script text without executing it."
+    },
     {
       "file": "runtime/arcane/modules/InMemoryCommunicationProvider.js",
       "name": "InMemoryCommunicationProvider.js",