arcane-os 0.57.0 → 0.59.0

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

@@ -1,23 +1,121 @@
 {
   "schemaVersion": 1,
-  "sdkVersion": "0.56.0",
+  "sdkVersion": "0.57.0",
   "environment": {
     "runtime": "Node.js for Node entrypoints; browser for browser-only entrypoints",
     "minimumVersion": "22.23.2 for Node entrypoints",
     "moduleSystem": "ESM"
   },
-  "memberCount": 254,
+  "memberCount": 267,
   "runtimeSubpathPatterns": {
     "arcane-os/modules/*": "./runtime/arcane/modules/*",
     "arcane-os/entities/*": "./runtime/arcane/entities/*"
   },
   "members": [
+    {
+      "id": "local-ai-onnx:createONNXRuntime",
+      "name": "createONNXRuntime",
+      "displayName": "createONNXRuntime()",
+      "kind": "function",
+      "signature": "createONNXRuntime({modulePath,signal,onEvent}={})",
+      "entrypoints": ["arcane-os/local-ai/onnx"],
+      "primaryImport": "arcane-os/local-ai/onnx",
+      "group": "Core local AI",
+      "summary": "Owns explicitly loaded ONNX graphs and complete named tensor inference in retained native workers.",
+      "availability": "Node on Windows/Linux/macOS x64/arm64 with prepared onnxruntime-node; Android needs host adaptation",
+      "protocol": "Per-session worker lifecycle with structured-clone tensors and replaying state",
+      "normalization": "Returns load/run/unload/current/subscribe/close; explicit model and session IDs; native calls may delay worker termination, and close observes actual exit"
+    },
+    {
+      "id": "core-onnx:createCoreONNXRuntime",
+      "name": "createCoreONNXRuntime",
+      "displayName": "createCoreONNXRuntime()",
+      "kind": "function",
+      "signature": "createCoreONNXRuntime({client=getInstalledCoreClient()}={})",
+      "entrypoints": ["arcane-os/ai/core-onnx"],
+      "primaryImport": "arcane-os/ai/core-onnx",
+      "group": "Core local AI",
+      "summary": "Accesses local system ONNX through an existing Core client with complete tensor transport.",
+      "availability": "Browser with available Core ONNX service; construction installs no runtime or model",
+      "protocol": "arcane/1 onnx.status/load/run/unload and localai.state",
+      "normalization": "Returns load/run/unload/inspect/current/subscribe/close; preserves typed and string tensors; accessor close cancels its requests without closing shared Core or implicitly unloading shared models"
+    },
+    {
+      "id": "root:createGitTextSnapshot",
+      "name": "createGitTextSnapshot",
+      "displayName": "createGitTextSnapshot()",
+      "kind": "function",
+      "signature": "createGitTextSnapshot({cacheDirectory,remote,ref,selectPath,onEvent,run=runProcess}={})",
+      "entrypoints": ["arcane-os"],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Reads complete selected text from one fetched revision using a dedicated bare Git object cache and batched retrieval.",
+      "availability": "Node with Git; Android requires a host supplying Git/process capability",
+      "protocol": "Git tree and batched blob transport through the shared process owner",
+      "normalization": "Returns {refresh,close,drain,dispose}; refresh yields {revision,files:[{path,content}]}, shares concurrent work, reuses unchanged revisions, preserves exact UTF-8 text, isolates caller cancellation and drains accepted work. See git-text-snapshot.md."
+    },
+    {
+      "id": "diarization:createDiarization",
+      "name": "createDiarization",
+      "displayName": "createDiarization()",
+      "kind": "function",
+      "signature": "createDiarization({executable,modelPath,runtime,onEvent}={})",
+      "entrypoints": ["arcane-os/diarization"],
+      "primaryImport": "arcane-os/diarization",
+      "group": "Native speaker diarization",
+      "summary": "Retains one selected Nemotron 3 model helper and independently owned caller-fed audio streams.",
+      "availability": "Node with a host-built first-party helper, official NeMo-Speech.cpp CPU libraries and caller-selected model",
+      "protocol": "Owned native helper transport and replayable model lifecycle; mono Float32 audio streams",
+      "normalization": "Preserves complete audio, timed segments and requested probability frames; generic speaker labels are not person identity; finish/cancel/close retain native drain and complete failures"
+    },
+    {
+      "id": "diarization-build:buildDiarizationHelper",
+      "name": "buildDiarizationHelper",
+      "displayName": "buildDiarizationHelper()",
+      "kind": "function",
+      "signature": "async buildDiarizationHelper({runtime,outputRoot,signal,onEvent}={})",
+      "entrypoints": ["arcane-os/diarization/build"],
+      "primaryImport": "arcane-os/diarization/build",
+      "group": "Native speaker diarization",
+      "summary": "Builds the first-party helper against the explicitly installed NeMoSpeech Diarization component.",
+      "availability": "Node, installed CMake/C++17 toolchain and matching official CPU runtime for the current host",
+      "protocol": "CMake configure, build and install using runtime.cmakeDirectory",
+      "normalization": "Returns actual platform, architecture, root, executable and complete diagnostics; no compiler or model download"
+    },
+    {
+      "id": "core-diarization:createDiarizationService",
+      "name": "createDiarizationService",
+      "displayName": "createDiarizationService()",
+      "kind": "function",
+      "signature": "createDiarizationService(options={},launch={})",
+      "entrypoints": ["arcane-os/core/diarization"],
+      "primaryImport": "arcane-os/core/diarization",
+      "group": "Native speaker diarization",
+      "summary": "Composes lazy native diarization as an application-selected Core service.",
+      "availability": "Node Core runtime with explicitly selected helper, runtime and model",
+      "protocol": "arcane/1 diarization methods and state/update/probability events; f32le audio transport",
+      "normalization": "Resolves relative paths from selected workspaceRoot or appRoot; session audio uses service lifetime, recording cancellation is independent, and model loading never blocks Core startup"
+    },
+    {
+      "id": "core-diarization:default",
+      "name": "default",
+      "displayName": "createDiarizationService default export",
+      "kind": "function",
+      "signature": "default as createDiarizationService",
+      "entrypoints": ["arcane-os/core/diarization"],
+      "primaryImport": "arcane-os/core/diarization",
+      "group": "Native speaker diarization",
+      "summary": "Default binding for the same native Core diarization service factory.",
+      "availability": "Node Core runtime",
+      "protocol": "arcane/1 service definition",
+      "normalization": "Binding identity equals the named createDiarizationService export"
+    },
     {
       "id": "core-local:createCoreLocalAIProvider",
       "name": "createCoreLocalAIProvider",
       "displayName": "createCoreLocalAIProvider()",
       "kind": "function",
-      "signature": "createCoreLocalAIProvider({client,id='llama.cpp'}={})",
+      "signature": "createCoreLocalAIProvider({client=getInstalledCoreClient(),id='llama.cpp'}={})",
       "entrypoints": ["arcane-os/ai/core-local"],
       "primaryImport": "arcane-os/ai/core-local",
       "group": "Core local AI",
@@ -35,9 +133,9 @@
       "entrypoints": ["arcane-os/core/local-ai"],
       "primaryImport": "arcane-os/core/local-ai",
       "group": "Core local AI",
-      "summary": "Composes selected native llama.cpp and Ollama engines as a Core service with retained process ownership and model lifecycle.",
+      "summary": "Composes selected native llama.cpp, Ollama and ONNX engines as a Core service with retained process/worker ownership and model lifecycle.",
       "availability": "Node with selected upstream runtime distributions or available configured system services",
-      "protocol": "arcane/1 methods and events; llama.cpp OpenAI HTTP/SSE and Ollama native HTTP/NDJSON",
+      "protocol": "arcane/1 methods and events; llama.cpp OpenAI HTTP/SSE, Ollama native HTTP/NDJSON and ONNX tensor transport",
       "normalization": "Application-owned runtime and model requirements; independent startup, complete responses and exact owned-process cleanup"
     },
     {
@@ -59,13 +157,13 @@
       "name": "ensureLocalAIRuntimes",
       "displayName": "ensureLocalAIRuntimes()",
       "kind": "function",
-      "signature": "ensureLocalAIRuntimes({runtimes=[],directory,platform,architecture,signal,onEvent}={})",
+      "signature": "async ensureLocalAIRuntimes({runtimes=[],directory,platform=process.platform,architecture=process.arch,signal,onEvent}={})",
       "entrypoints": ["arcane-os/local-ai"],
       "primaryImport": "arcane-os/local-ai",
       "group": "Core local AI",
-      "summary": "Reuses selected managed native runtimes or installs complete official llama.cpp and Ollama distributions.",
+      "summary": "Reuses selected managed native runtimes or installs complete official llama.cpp/Ollama distributions, ONNX npm runtime trees or NeMo libraries.",
       "availability": "Node; upstream platform and architecture assets determine runtime availability",
-      "protocol": "Official upstream release downloads and host archive extraction",
+      "protocol": "Official upstream release archives or selected ONNX npm installation",
       "normalization": "Returns absolute runtime records; shares matching concurrent installs, preserves libraries and reports failures without changing global PATH or services"
     },
     {
@@ -73,7 +171,7 @@
       "name": "bundleLocalAIRuntimes",
       "displayName": "bundleLocalAIRuntimes()",
       "kind": "function",
-      "signature": "bundleLocalAIRuntimes({runtimes=[],directory,outputRoot,platform,architecture,signal,onEvent}={})",
+      "signature": "async bundleLocalAIRuntimes({runtimes=[],directory,outputRoot,platform=process.platform,architecture=process.arch,signal,onEvent}={})",
       "entrypoints": ["arcane-os/local-ai"],
       "primaryImport": "arcane-os/local-ai",
       "group": "Core local AI",
@@ -1114,7 +1212,7 @@
       ],
       "primaryImport": "arcane-os",
       "group": "Targets, native plans, and providers",
-      "summary": "Loads the fixed provider for one target from an explicitly selected Arcane OS checkout and authenticates that provider generation for the current SDK process.",
+      "summary": "Loads the installed SDK provider for portable or windows-x64 when arcaneRoot is omitted, or retains the explicitly selected Arcane OS checkout provider route.",
       "availability": "Node; selected browser/native target or provider as documented",
       "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
       "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
@@ -1860,16 +1958,16 @@
       "name": "runProcess",
       "displayName": "runProcess()",
       "kind": "function",
-      "signature": "async runProcess(command, args=[], { cwd, env, signal, onEvent, heartbeatMs=5000, terminationGraceMs=DEFAULT_TERMINATION_GRACE_MS, allowNonzero=false, input }={})",
+      "signature": "async runProcess(command, args=[], { cwd, env, signal, onEvent, onOutput, captureOutput=true, emitOutputEvents=true, outputEncoding='utf8', heartbeatMs=5000, terminationGraceMs=DEFAULT_TERMINATION_GRACE_MS, allowNonzero=false, input, cancellationMode='terminate-tree' }={})",
       "entrypoints": [
         "arcane-os"
       ],
       "primaryImport": "arcane-os",
       "group": "Events, processes, and testing",
-      "summary": "Runs one shell-free child command with complete stdout and stderr, ordered stream events, heartbeats, and process-tree cancellation.",
+      "summary": "Runs one shell-free child command with complete output and ordered events; default tree termination or explicit close-input cancellation waits for the selected child lifecycle.",
       "availability": "Node",
       "protocol": "Node ESM / owned process or test lifecycle",
-      "normalization": "SDK event/error/report normalization"
+      "normalization": "Defaults to complete UTF-8 capture/events. AsyncIterable input and awaited onOutput retain backpressure. Explicit null outputEncoding delivers native Buffers only to a selected onOutput owner with capture and line events disabled for that stream; failures retain complete chunks and drained process diagnostics."
     },
     {
       "id": "root:runRegisteredTests",
@@ -2012,7 +2110,7 @@
       ],
       "primaryImport": "arcane-os",
       "group": "Workspace, doctor, repository, and server",
-      "summary": "Starts one owned browser development server with exact runtime/app route mappings and an unguessable session capability.",
+      "summary": "Starts an owned source or packaged browser server with complete selected routes, HTTPS by default, explicit HTTP selection, listener readiness and shutdown.",
       "availability": "Node control plane; browser data plane",
       "protocol": "Node ESM",
       "normalization": "SDK-normalized inputs, errors, events, and documented result"
@@ -3779,14 +3877,14 @@
       "name": "createCoreClient",
       "displayName": "createCoreClient()",
       "kind": "function",
-      "signature": "createCoreClient({global=globalThis,transport=null,eventOwner=arcaneEvents,eventOwnerReady,autoConnect=true,replayRuntimeState=false,onError}={})",
+      "signature": "createCoreClient({global=globalThis,transport=null,eventOwner=arcaneEvents,eventOwnerReady,autoConnect=true,replayRuntimeState=false,webKitDocumentLifecycle=false,onError}={})",
       "entrypoints": ["arcane-os/core/client"],
       "primaryImport": "arcane-os/core/client",
       "group": "Core browser client",
       "summary": "Creates one correlated Arcane Core RPC client with explicit transport, readiness, events, cancellation and lifetime ownership.",
       "availability": "Browser and native WebView JavaScript hosts; custom transports require a callable send(frame)",
       "protocol": "arcane/1 over the selected host transport",
-      "normalization": "Preserves complete request, result and event data; retains FIFO event-owner handoff; failTransport(error) settles pending RPCs and acknowledgements with the complete failure and releases the client lifetime; opt-in replayRuntimeState sends one observed nonblocking runtime.replay control after transport readiness"
+      "normalization": "Preserves complete request, result and event data; retains FIFO event-owner handoff; failTransport(error) settles pending RPCs and acknowledgements with the complete failure and releases the client lifetime; opt-in replayRuntimeState sends one observed nonblocking runtime.replay control after transport readiness. Optional webKitDocumentLifecycle selects WithReply activate/frame/retire metadata outside unchanged Core JSON, synchronous acceptsNativeDelivery(activation), guarded receive/failure delivery, page-hide retirement and fresh restored activation with current-state replay. Requests cancelled while awaiting attachment are never submitted afterward. Subscriptions survive restoration; retired renderer promises abort while accepted service-lifetime work continues. Existing transport behavior is unchanged when omitted; see core-client.md for the native ownership and acknowledgement contract"
     },
     {
       "id": "core-client:createCoreFacade",
@@ -3814,7 +3912,7 @@
       "summary": "Installs one synchronous global Arcane facade, native receive callback and terminal transport-failure callback for the selected renderer lifetime.",
       "availability": "Browser and native WebView JavaScript hosts",
       "protocol": "arcane/1 renderer facade",
-      "normalization": "Repeated installation returns the same client; close/failTransport release owned resources and restore prior globals only while still owned; __arcaneTransportFailed preserves the complete host failure without killing Core"
+      "normalization": "Repeated installation returns the same client; close/failTransport release owned resources and restore prior globals only while still owned; __arcaneTransportFailed preserves the complete host failure without killing Core. Forwards optional webKitDocumentLifecycle:false by default; when selected, __arcaneWebKitDocumentCurrent(activation) probes the executing realm and __arcaneReceive(json,activation)/__arcaneTransportFailed(error,activation) reject delivery to retired or different activations before changing installation ownership"
     },
     {
       "id": "core-client:getInstalledCoreClient",
@@ -3835,14 +3933,14 @@
       "name": "createCoreClassicSource",
       "displayName": "createCoreClassicSource()",
       "kind": "function",
-      "signature": "async createCoreClassicSource({eventOwnerModuleURL,replayRuntimeState=false}={})",
+      "signature": "async createCoreClassicSource({eventOwnerModuleURL,replayRuntimeState=false,webKitDocumentLifecycle=false}={})",
       "entrypoints": ["arcane-os/core/classic-source"],
       "primaryImport": "arcane-os/core/classic-source",
       "group": "Core classic client projection",
       "summary": "Generates the native host's classic injection script from the installed canonical Core client and contracts.",
       "availability": "Node; generated source runs in browser and native WebView renderers",
       "protocol": "arcane/1 classic-script injection",
-      "normalization": "Returns the complete canonical client projection; installs synchronous facade shapes while deferring only the event-owner module connection when document parsing is incomplete; forwards explicit runtime replay selection with a false default"
+      "normalization": "Returns the complete canonical client projection; installs synchronous facade shapes while deferring only the event-owner module connection when document parsing is incomplete; forwards explicit replayRuntimeState and webKitDocumentLifecycle selections with false defaults. Optional WebKit lifetime requires a native WithReply lifecycle host and the existing runtime.replay control; restoration requests current state after fresh activation while rendering and independent Core startup continue"
     },
     {
       "id": "core-runtime:createCoreRuntime",
@@ -3905,7 +4003,7 @@
       "name": "createPortableNativeProvider",
       "displayName": "createPortableNativeProvider()",
       "kind": "function",
-      "signature": "createPortableNativeProvider({services}={})",
+      "signature": "createPortableNativeProvider({services,packagedWeb=false,webKitDocumentLifecycle=false}={})",
       "entrypoints": ["arcane-os/native/portable-provider"],
       "primaryImport": "arcane-os/native/portable-provider",
       "group": "Portable native provider",
@@ -3984,19 +4082,103 @@
       "protocol": "arcane-native-builder/1 windows-x64 provider",
       "normalization": "Binding identity is exactly equal to the named arcaneNativeBuilderProvider export"
     },
+    {
+      "id": "native-macos-provider:createMacOSNativeProvider",
+      "name": "createMacOSNativeProvider",
+      "displayName": "createMacOSNativeProvider()",
+      "kind": "function",
+      "signature": "createMacOSNativeProvider({services,hostDirectory}={})",
+      "entrypoints": ["arcane-os/native/macos-provider"],
+      "primaryImport": "arcane-os/native/macos-provider",
+      "group": "macOS native provider",
+      "summary": "Composes a complete selected portable payload with the architecture-selected SDK Mac host in an application bundle.",
+      "availability": "Node assembly; matching Darwin architecture and selected host artifact for execution",
+      "protocol": "arcane-native-builder/1 macos-arm64 and macos-x64 provider",
+      "normalization": "Resources remains target.rootDir; bundleRoot names the app bundle; selected hostDirectory or exact-version host assets; run closes stdin and awaits graceful drain; source availability does not establish artifact publication or Mac execution"
+    },
+    {
+      "id": "native-macos-provider:arcaneNativeBuilderProvider",
+      "name": "arcaneNativeBuilderProvider",
+      "displayName": "arcaneNativeBuilderProvider",
+      "kind": "singleton",
+      "signature": "const arcaneNativeBuilderProvider",
+      "entrypoints": ["arcane-os/native/macos-provider"],
+      "primaryImport": "arcane-os/native/macos-provider",
+      "group": "macOS native provider",
+      "summary": "SDK-owned Mac provider selected by macos-arm64 and macos-x64 CLI routes.",
+      "availability": "Node assembly; matching Darwin architecture and selected host artifact for execution",
+      "protocol": "arcane-native-builder/1",
+      "normalization": "Uses descriptor services and selected exact-version host; identical to the default binding"
+    },
+    {
+      "id": "native-macos-provider:default",
+      "name": "default",
+      "displayName": "arcaneNativeBuilderProvider default export",
+      "kind": "singleton",
+      "signature": "default as arcaneNativeBuilderProvider",
+      "entrypoints": ["arcane-os/native/macos-provider"],
+      "primaryImport": "arcane-os/native/macos-provider",
+      "group": "macOS native provider",
+      "summary": "Default binding for the same SDK Mac native provider.",
+      "availability": "Node assembly; matching Darwin architecture and selected host artifact for execution",
+      "protocol": "arcane-native-builder/1",
+      "normalization": "Identical to named arcaneNativeBuilderProvider export"
+    },
+    {
+      "id": "core-packaged-web:createPackagedWebService",
+      "name": "createPackagedWebService",
+      "displayName": "createPackagedWebService()",
+      "kind": "function",
+      "signature": "createPackagedWebService({artifactRoot},context={})",
+      "entrypoints": ["arcane-os/core/packaged-web"],
+      "primaryImport": "arcane-os/core/packaged-web",
+      "group": "Native packaged web serving",
+      "summary": "Owns one packaged HTTP listener, persisted loopback port, real readiness and draining shutdown inside Core.",
+      "availability": "Node Core service lifetime",
+      "protocol": "arcane/1 core.web.ready and core.web.failed events",
+      "normalization": "Preserves full webRoot and start URL; stateRoot keeps the selected port across launches; no origin fallback on conflicts; unchanged launch record; explicit ready/failure events and complete listener lifecycle"
+    },
+    {
+      "id": "core-preferences:createPreferencesService",
+      "name": "createPreferencesService",
+      "displayName": "createPreferencesService()",
+      "kind": "function",
+      "signature": "createPreferencesService({file}={})",
+      "entrypoints": ["arcane-os/core/preferences"],
+      "primaryImport": "arcane-os/core/preferences",
+      "group": "Core preference persistence",
+      "summary": "Supplies the five existing preference RPC methods with application-selected file storage.",
+      "availability": "Node Core runtime",
+      "protocol": "arcane/1 preferences methods and schemaVersion 1 entries file",
+      "normalization": "Preserves exact keys, complete JSON values and existing metadata; writes use service lifetime and flush before acknowledgment; unreadable files remain untouched and drain waits for accepted work"
+    },
+    {
+      "id": "core-preferences:default",
+      "name": "default",
+      "displayName": "createPreferencesService default export",
+      "kind": "function",
+      "signature": "default as createPreferencesService",
+      "entrypoints": ["arcane-os/core/preferences"],
+      "primaryImport": "arcane-os/core/preferences",
+      "group": "Core preference persistence",
+      "summary": "Default binding for the same Core preferences service factory.",
+      "availability": "Node Core runtime",
+      "protocol": "arcane/1 preferences methods and schemaVersion 1 entries file",
+      "normalization": "Binding identity is exactly equal to the named createPreferencesService export"
+    },
     {
       "id": "core-host:readCoreLaunchContext",
       "name": "readCoreLaunchContext",
       "displayName": "readCoreLaunchContext()",
       "kind": "function",
-      "signature": "readCoreLaunchContext({argv=process.argv.slice(2)}={})",
+      "signature": "async readCoreLaunchContext({argv=process.argv.slice(2)}={})",
       "entrypoints": ["arcane-os/core/host"],
       "primaryImport": "arcane-os/core/host",
       "group": "Native Core host composition",
-      "summary": "Reads the complete JSON object explicitly selected by --arcane-launch-config for native service launch context.",
+      "summary": "Reads explicit launch JSON with the separately supplied native host stateRoot default for service launch context.",
       "availability": "Node, including the selected external-entry SEA launcher",
       "protocol": "Explicit launch arguments and JSON configuration",
-      "normalization": "Returns an empty record without the flag; preserves every supplied field and value, surfaces file and JSON failures, and performs no configuration search, rewrite or environment mutation"
+      "normalization": "Optional --arcane-host-state-root <directory> supplies the stateRoot default; every explicit --arcane-launch-config JSON field takes precedence unchanged, including relative or null stateRoot and application-owned preferencesFile. Returns an empty record with neither argument; surfaces missing argument values, file and JSON failures; performs no directory selection, path resolution, configuration search, rewrite, migration or environment mutation"
     },
     {
       "id": "core-host:startCoreHost",

package/docs/reference/local-ai.md

@@ -1,13 +1,13 @@
 # Local AI through Core
 
-Core owns native llama.cpp and Ollama processes. The browser retains its own
+Core owns native llama.cpp and Ollama processes and ONNX worker sessions. The browser retains its own
 Wllama and ONNX implementations, and can also use an explicitly connected Core
 when that system service is available. Runtime installation, model loading and
 inference are separate operations.
 
-This native service currently implements llama.cpp and Ollama. Native ONNX
-inference remains separate unfinished work. Browser ONNX continues through its
-existing browser implementation.
+Native ONNX runs caller-selected graphs with complete named input/output tensors.
+Applications own preprocessing, tokenization and model-specific pipelines.
+Browser ONNX continues through its existing browser implementation.
 
 ## Application requirements
 
@@ -19,7 +19,8 @@ Existing native fields remain alongside this record:
 {
   "runtimes": [
     {"id": "llama.cpp"},
-    {"id": "ollama"}
+    {"id": "ollama"},
+    {"id": "onnx"}
   ],
   "llamaCpp": {
     "modelsDirectory": "models/llama"
@@ -31,7 +32,8 @@ Existing native fields remain alongside this record:
 ```
 
 Each runtime requirement accepts `id`, optional upstream `version`, and an
-optional runtime archive `url`. A string runtime ID is also accepted.
+optional runtime archive `url`. ONNX resolves its official npm package or an
+explicitly supplied package archive. A string runtime ID is also accepted.
 Omitting the version allows reuse of an available runtime. Explicit versions
 select that upstream distribution; an existing service must match the requested
 version before it is reused. A service occupying the selected address is
@@ -48,7 +50,7 @@ application. Applications choose and provision their models explicitly.
 ## Development
 
 ```sh
-arcane dev --local-ai llama.cpp,ollama
+arcane dev --local-ai llama.cpp,ollama,onnx
 ```
 
 The option adds those runtime requirements to the authored application
@@ -64,6 +66,13 @@ service or machine environment. Windows and macOS use the host archive utility;
 Linux requires `tar`, and `unzip` when extracting a selected Windows ZIP.
 Zstandard archives use the supported Node runtime's decompressor.
 
+Selected ONNX preparation installs `onnxruntime-node@1.30.0` by default into a
+managed npm prefix, retaining its complete published runtime dependency tree.
+It uses the upstream CPU installation option to skip supplementary GPU downloads.
+Node/npm must be available while preparing that runtime; a native app consumes
+the bundled tree without installing it again. Applications that omit ONNX do
+not install its package.
+
 For the optional development browser connection, load the bootstrap after the
 managed import map and before creating a Core-backed provider:
 
@@ -111,6 +120,9 @@ service and a loaded model are separate facts.
 `localai.services.recover({runtimes: ['llama.cpp']})` makes one explicit recovery
 attempt for the selected runtimes; omission selects all configured runtimes.
 Recovery restarts only SDK-owned processes and reconnects to external services.
+Recovering ONNX releases its sessions; explicitly load models again afterward.
+Its state is `recovering` and unavailable until the previous workers exit and
+the new session owner is ready.
 An external llama.cpp server returns HTTP 503 during initial model loading and
 offers no readiness subscription at that stage. Core retains `state: 'loading'`;
 a subsequent explicit load or recovery request checks again. There is no
@@ -175,6 +187,106 @@ silently change the application's saved model choice. Release registration
 with `unregister()` and dispose the provider at the application's owning
 lifecycle boundary.
 
+## Native ONNX sessions
+
+```js
+import {ensureLocalAIRuntimes} from 'arcane-os/local-ai';
+import {createONNXRuntime} from 'arcane-os/local-ai/onnx';
+
+const [runtime] = await ensureLocalAIRuntimes({
+  runtimes: ['onnx'], directory: '.arcane/local-ai/runtimes'
+});
+const onnx = createONNXRuntime({modulePath: runtime.modulePath});
+try {
+  const loaded = await onnx.load({id: 'cheese-radar', model: absoluteModelPath});
+  // Supply the actual names, shapes and values expected by this graph.
+  const outputs = await onnx.run({id: loaded.id, feeds});
+  console.log(outputs);
+} finally {
+  await onnx.close();
+}
+```
+
+The factory accepts `{modulePath,signal?,onEvent?}` and starts no worker until
+`load({id,model,sessionOptions?,signal?})`. The model path is absolute for this
+direct Node API. Session creation defaults to the CPU execution provider;
+explicit native session options remain caller-owned. The returned session
+record contains `id`, `model`, `state`, `loaded`, `error`, input/output names and
+metadata. A live ID requires explicit unload before replacement. An ID may be
+loaded again once its previous worker exits after a failed load or unload.
+A run error retains the loaded session so a corrected request can use it.
+
+`run({id,feeds,fetches?,runOptions?,signal?})` returns the complete output-name
+map of `{type,dims,data}` tensors. Input records use that same shape with native
+typed data or string arrays. Optional `fetches` selects output names or supplies
+output tensors using the upstream API. Worker transport copies supplied tensor
+data; returned output records contain the results, and caller-owned preallocated
+buffers are not mutated in place. Each session retains its own worker and
+loaded graph; work for independent sessions proceeds concurrently. Runs for one
+session execute in order and wait at that session's loading boundary. There is
+no token streaming in the generic tensor operation.
+
+String input containing U+0000 reports an incompatibility at the native tensor
+boundary: the Node binding uses null-terminated strings and cannot preserve
+that input completely. The SDK does not alter the supplied string.
+
+`current()` returns `{sessions,closed}`. `subscribe(listener)` replays current
+state synchronously and returns an unsubscribe function. Load, readiness,
+unload and failures remain observable. `unload({id,signal?})` releases that
+session; `close()` owns all remaining workers and awaits their actual exits.
+
+Cancelling a queued run removes that run. Cancelling active native work stops
+delivery and retires its worker; the session becomes unavailable until loaded
+again. ONNX Runtime's Node binding offers no native inference interruption:
+worker termination can wait for a native call to return. Shutdown observes the
+actual exit and does not claim that rejecting a request stopped native work.
+Other sessions retain their own lifetimes.
+
+### ONNX through Core and the browser
+
+| Core method | Parameters | Result |
+| --- | --- | --- |
+| `onnx.status` | `{}` | Runtime availability and current `models` session records |
+| `onnx.load` | `{id,model,sessionOptions?}` | Loaded session; relative model paths resolve from `appRoot` |
+| `onnx.run` | `{id,feeds,fetches?,runOptions?}` | Complete encoded tensor output map |
+| `onnx.unload` | `{id}` | Released session record |
+
+Use the browser accessor to handle the Core tensor transport:
+
+```js
+import {createCoreONNXRuntime} from 'arcane-os/ai/core-onnx';
+
+const onnx = createCoreONNXRuntime({client});
+const stop = onnx.subscribe(function showRuntime(state) { console.log(state); });
+await onnx.inspect();
+await onnx.load({id: 'cheese-radar', model: 'models/cheese-radar.onnx'});
+const outputs = await onnx.run({id: 'cheese-radar', feeds});
+await onnx.unload({id: 'cheese-radar'});
+stop();
+onnx.close();
+```
+
+The accessor exposes `load`, `run`, `unload`, `inspect`, `current`, `subscribe`
+and `close`. Request methods accept `signal` and optional `timeoutMs` (default
+`0`, no elapsed-time cutoff). It preserves full typed tensor values, including
+64-bit integers, floating-point special values and strings, through the
+transport codec. `current()` adds `busy` and `closed` to its latest Core state.
+Closing the accessor cancels its requests and subscriptions; model unloading
+is explicit because other accessors may share the Core session. It never
+closes the shared Core client.
+
+Construction neither opens a connection nor installs a runtime. A browser needs
+an already available native Core service or the explicit development bridge.
+Unavailable native ONNX leaves browser ONNX/Wllama under the application's
+existing selection. This tensor API does not select an LLM, tokenizer, speech,
+image or avatar pipeline.
+
+Native ONNX CPU package targets are Windows, Linux and macOS on `x64`/`arm64`,
+as listed in Microsoft's [Node binding platform matrix](https://github.com/microsoft/onnxruntime/blob/v1.30.0/js/node/README.md).
+Android needs its host's native ONNX adapter; the Node package contains no
+Android binding. Platform support here describes upstream package targets,
+not execution evidence on each platform.
+
 ## Native bundling
 
 The SDK portable native build includes selected official runtime trees under
@@ -191,7 +303,29 @@ Architectures are `x64` or `arm64`. Availability depends on the upstream
 runtime's published platform assets; Ollama has no official Android runtime
 archive in this installer.
 
-Ensure returns absolute `{id,version,platform,architecture,root,executable}`
-records. Bundle returns `{runtimes,files}`, with artifact-relative runtime paths
-and a complete emitted file inventory. Bundling requires a fresh native staging
-destination, preserving existing completed outputs.
+Ensure returns absolute `{id,version,platform,architecture,root}` records.
+Server runtimes also include `executable`; ONNX includes `modulePath` pointing
+to its public package entry. Bundle returns `{runtimes,files}`,
+with artifact-relative runtime paths and a complete emitted file inventory.
+Bundling requires a fresh native staging destination, preserving existing
+completed outputs.
+
+### NeMo Speech library runtime
+
+The runtime helpers also accept `{id: 'nemo-speech', version: '0.2.0'}` to
+prepare NVIDIA's official CPU library distribution. An omitted NeMo version
+selects `0.2.0`. Its published targets are Windows `x64`, Linux `x64`/`arm64`,
+and macOS `x64`/`arm64`.
+
+NeMo records include `includeDirectory`, `libraryDirectory`, `binaryDirectory`,
+and `cmakeDirectory`; they have no server `executable`. The complete upstream
+tree remains under `root`, including any archive prefix directory. Use the
+returned `cmakeDirectory` as `NeMoSpeech_DIR` when calling
+`find_package(NeMoSpeech CONFIG REQUIRED COMPONENTS Diarization)`, then link
+the upstream `NeMoSpeech::Diarization` target. Bundling preserves the complete
+tree and makes all these paths relative to the native artifact root.
+
+This helper installs the library. The application configuration and development
+CLI select llama.cpp, Ollama and ONNX services described above;
+NeMo model selection and a native diarization helper belong to their owning
+integration.