arcane-os 0.66.0 → 0.68.0

package/browser-runtime/ai/core-local.mjs

@@ -1,5 +1,5 @@
 import Is from '../dependencies/strong-type/index.js';
-import {getInstalledCoreClient} from '../core/client.mjs';
+import {subscribeCoreClient} from '../core/client.mjs';
 
 const is = new Is(false);
 const PROVIDER_PROTOCOL = 'arcane-ai-provider/2';
@@ -22,19 +22,26 @@ function cancelled(reason) {
  * selects its model; Core owns the running engine and its loaded sessions.
  * Creating this provider neither connects a transport nor installs a runtime.
  */
-export function createCoreLocalAIProvider({client = getInstalledCoreClient(), id = 'llama.cpp'} = {}) {
+export function createCoreLocalAIProvider({client: suppliedClient, id = 'llama.cpp'} = {}) {
     if (!is.string(id) || !id.trim()) throw new TypeError('The Core AI provider id must be a nonempty string.');
-    if (client !== null && (!is.function(client?.invoke) || !is.function(client?.events?.on))) {
+    if (suppliedClient !== undefined && suppliedClient !== null
+        && (!is.function(suppliedClient?.invoke) || !is.function(suppliedClient?.events?.on))) {
         throw new TypeError('The Core AI client must expose invoke and events.on.');
     }
 
     let runtime = null;
     let models = [];
     let selection = null;
+    let selectionConnection = null;
     let disposed = false;
     let loading = false;
+    let unloading = false;
     let sequence = 0;
     let lifecycleRevision = 0;
+    let client = null;
+    let connection = null;
+    let stopInstallation;
+    let disposing;
     const requests = new Set();
 
     function requireClient() {
@@ -58,7 +65,13 @@ export function createCoreLocalAIProvider({client = getInstalledCoreClient(), id
     }
 
     function modelReady() {
-        return runtime?.available === true && runtime.state === 'ready' && Boolean(loadedModel());
+        return !unloading && selectionConnection === connection && runtime?.available === true
+            && runtime.state === 'ready' && Boolean(loadedModel());
+    }
+
+    function assertCurrentConnection(value) {
+        if (disposed || connection !== value) throw cancelled();
+        value.controller.signal.throwIfAborted();
     }
 
     function status() {
@@ -67,7 +80,9 @@ export function createCoreLocalAIProvider({client = getInstalledCoreClient(), id
             state: disposed ? 'disposed' : loading ? 'loading' : loaded ? 'ready'
                 : runtime?.error ? 'error' : runtime?.available === true ? 'unloaded' : 'unavailable',
             loaded,
-            busy: loading || requests.size > 0,
+            busy: Boolean(loading || unloading) || [...requests].some(function currentRequest(request) {
+                return request.connection === connection && !request.controller.signal.aborted;
+            }),
             modelId: selection?.modelId ?? null,
             available: !disposed && runtime?.available === true,
             installed: runtime?.installed === true,
@@ -79,6 +94,7 @@ export function createCoreLocalAIProvider({client = getInstalledCoreClient(), id
         runtime = value ?? null;
         models = is.array(runtime?.models) ? runtime.models : [];
         for (const request of requests) {
+            if (request.connection !== connection || request.modelId === null) continue;
             const model = models.find(function requestModel(record) { return record.id === request.modelId; });
             if (model?.loaded === true) request.loaded = true;
             if (runtime?.available !== true || (request.loaded && (runtime.state !== 'ready' || model?.loaded !== true))) {
@@ -88,13 +104,62 @@ export function createCoreLocalAIProvider({client = getInstalledCoreClient(), id
         return status();
     }
 
-    const unsubscribe = client?.events.on('localai.state', function localRuntimeChanged(snapshot) {
-        if (disposed || !is.array(snapshot?.runtimes)) return;
+    function bindClient({client: nextClient, error = null}) {
+        if (disposed || (connection && nextClient === client)) return;
+        const previous = connection;
+        client = nextClient;
+        const currentConnection = {client, controller: new AbortController(), unsubscribe: null};
+        connection = currentConnection;
         lifecycleRevision += 1;
-        acceptRuntime(snapshot.runtimes.find(function llamaRuntime(value) {
-            return value.id === 'llama.cpp';
-        }));
-    }) ?? function noCoreSubscription() {};
+        loading = false;
+        unloading = false;
+        runtime = {installed: false, available: false, state: client ? 'unknown' : 'unavailable', error};
+        models = [];
+        previous?.unsubscribe?.();
+        previous?.controller.abort();
+        if (client) {
+            currentConnection.unsubscribe = client.events.on(
+                'localai.state',
+                function localRuntimeChanged(snapshot) {
+                    if (disposed || connection !== currentConnection || !is.array(snapshot?.runtimes)) return;
+                    lifecycleRevision += 1;
+                    acceptRuntime(snapshot.runtimes.find(function llamaRuntime(value) {
+                        return value.id === 'llama.cpp';
+                    }));
+                }
+            );
+        }
+        if (client && suppliedClient === undefined) {
+            const revision = lifecycleRevision;
+            invokeOwned(client, 'llama.status', {}).then(
+                function installedRuntimeObserved(value) {
+                    if (!disposed && connection === currentConnection && lifecycleRevision === revision) acceptRuntime(value);
+                },
+                function installedRuntimeFailed(error) {
+                    if (!disposed && connection === currentConnection && lifecycleRevision === revision) {
+                        acceptRuntime({...runtime, available: false, state: 'error', error});
+                    }
+                }
+            );
+        }
+    }
+
+    async function invokeOwned(core, method, parameters, signal) {
+        const request = ownRequest(signal, null, core);
+        request.result = Promise.resolve().then(
+            function invokeLocalOperation() {
+                request.controller.signal.throwIfAborted();
+                return core.invoke(method, parameters, {signal: request.controller.signal});
+            }
+        );
+        try {
+            const result = await request.result;
+            request.controller.signal.throwIfAborted();
+            return result;
+        } finally {
+            request.release();
+        }
+    }
 
     function authority(value) {
         return {protocol: AUTHORITY_PROTOCOL, providerId: id, modelId: value.modelId};
@@ -103,12 +168,20 @@ export function createCoreLocalAIProvider({client = getInstalledCoreClient(), id
     async function inspect(value, {signal} = {}) {
         requireSelection(value);
         if (signal?.aborted) throw cancelled(signal.reason);
+        const currentConnection = connection;
+        const statusRevision = lifecycleRevision;
         try {
             const core = requireClient();
-            const statusRevision = lifecycleRevision;
-            const current = await core.invoke('llama.status', {}, {signal});
+            const current = await invokeOwned(core, 'llama.status', {}, signal);
+            assertCurrentConnection(currentConnection);
             if (lifecycleRevision === statusRevision) acceptRuntime(current);
-            if (runtime?.available !== true) {
+            const knownModel = models.some(function matchesModel(model) { return model.id === value.modelId; });
+            // Inspection describes an explicit load capability, never readiness.
+            // Core still verifies the exact model at the actual load boundary.
+            const starting = !runtime?.error && ['starting', 'loading'].includes(runtime?.state);
+            const released = !runtime?.error && runtime?.released === true && runtime.owned === true
+                && runtime.state === 'stopped' && knownModel;
+            if (runtime?.error || (runtime?.available !== true && !starting && !released)) {
                 return {
                     available: false,
                     code: 'ARCANE_AI_PROVIDER_UNAVAILABLE',
@@ -116,7 +189,7 @@ export function createCoreLocalAIProvider({client = getInstalledCoreClient(), id
                     error: runtime?.error ?? null
                 };
             }
-            if (!models.some(function matchesModel(model) { return model.id === value.modelId; })) {
+            if (!starting && !knownModel) {
                 return {
                     available: false,
                     code: 'ARCANE_AI_MODEL_UNAVAILABLE',
@@ -126,48 +199,63 @@ export function createCoreLocalAIProvider({client = getInstalledCoreClient(), id
             return {available: true, authority: authority(value)};
         } catch (error) {
             if (signal?.aborted || error?.name === 'AbortError') throw error;
-            acceptRuntime({...runtime, available: false, state: 'error', error});
+            if (!disposed && connection === currentConnection && lifecycleRevision === statusRevision) {
+                acceptRuntime({...runtime, available: false, state: 'error', error});
+            }
             return {available: false, code: error.code ?? 'ARCANE_AI_CORE_UNAVAILABLE', message: error.message, error};
         }
     }
 
     async function load({selection: value, signal, progress} = {}) {
         const core = requireClient();
+        const currentConnection = connection;
         requireSelection(value);
         if (signal?.aborted) throw cancelled(signal.reason);
         selection = value;
-        loading = true;
+        selectionConnection = currentConnection;
+        const operation = {};
+        loading = operation;
+        unloading = false;
+        lifecycleRevision += 1;
         try {
             progress?.({phase: 'loading', modelId: value.modelId});
             const revision = lifecycleRevision;
-            const current = await core.invoke('llama.load', {model: value.modelId}, {signal});
+            const current = await invokeOwned(core, 'llama.load', {model: value.modelId}, signal);
+            assertCurrentConnection(currentConnection);
+            if (loading !== operation || selection !== value) throw cancelled();
             if (lifecycleRevision === revision) acceptRuntime(current);
             if (!modelReady()) throw localAIError('ARCANE_AI_MODEL_NOT_READY', 'Core did not report the selected model loaded and ready.', current?.error);
             progress?.({phase: 'ready', modelId: value.modelId});
+            assertCurrentConnection(currentConnection);
+            if (loading !== operation || selection !== value) throw cancelled();
             return {authority: authority(value), status: {...status(), state: 'ready', busy: false}};
         } finally {
-            loading = false;
+            if (loading === operation) loading = false;
         }
     }
 
-    function ownRequest(signal, modelId) {
+    function ownRequest(signal, modelId, core = requireClient()) {
+        const currentConnection = connection;
+        if (core !== currentConnection?.client) throw cancelled();
         const controller = new AbortController();
-        function forwardAbort() { controller.abort(signal.reason); }
-        signal?.addEventListener('abort', forwardAbort, {once: true});
-        if (signal?.aborted) forwardAbort();
-        const request = {controller, result: null, modelId, loaded: models.some(function loadedTarget(model) {
+        const operationSignal = signal
+            ? AbortSignal.any([signal, currentConnection.controller.signal]) : currentConnection.controller.signal;
+        function forwardAbort() { controller.abort(operationSignal.reason); }
+        operationSignal.addEventListener('abort', forwardAbort, {once: true});
+        if (operationSignal.aborted) forwardAbort();
+        const request = {controller, connection: currentConnection, result: null, modelId, loaded: models.some(function loadedTarget(model) {
             return model.id === modelId && model.loaded === true;
         })};
         requests.add(request);
         request.release = function releaseRequest() {
-            signal?.removeEventListener('abort', forwardAbort);
+            operationSignal.removeEventListener('abort', forwardAbort);
             requests.delete(request);
         };
         return request;
     }
 
     function streamRequest(core, parameters, signal) {
-        const request = ownRequest(signal, parameters.model);
+        const request = ownRequest(signal, parameters.model, core);
         const chunks = [];
         const readers = [];
         let complete = false;
@@ -195,6 +283,7 @@ export function createCoreLocalAIProvider({client = getInstalledCoreClient(), id
         });
 
         request.result = Promise.resolve().then(function invokeStream() {
+            request.controller.signal.throwIfAborted();
             return core.invoke('llama.chat', {...parameters, stream: true, streamId}, {signal: request.controller.signal});
         }).then(function streamCompleted(result) {
             if (request.controller.signal.aborted) throw cancelled(request.controller.signal.reason);
@@ -237,15 +326,17 @@ export function createCoreLocalAIProvider({client = getInstalledCoreClient(), id
 
     async function request({selection: value, operation, payload, signal} = {}) {
         const core = requireClient();
+        const currentConnection = connection;
         requireSelection(value);
         if (signal?.aborted) throw cancelled(signal.reason);
-        if (loading || selection?.modelId !== value.modelId) {
+        if (loading || unloading || selectionConnection !== connection || selection?.modelId !== value.modelId) {
             throw localAIError('ARCANE_AI_MODEL_NOT_READY', 'Load the selected local model before requesting inference.');
         }
         const model = payload?.model ?? value.modelId;
         if (!models.some(function knownModel(record) { return record.id === model; })) {
             const revision = lifecycleRevision;
-            const current = await core.invoke('llama.status', {}, {signal});
+            const current = await invokeOwned(core, 'llama.status', {}, signal);
+            assertCurrentConnection(currentConnection);
             if (lifecycleRevision === revision) acceptRuntime(current);
         }
         if (!models.some(function knownModel(record) { return record.id === model; })) {
@@ -258,8 +349,9 @@ export function createCoreLocalAIProvider({client = getInstalledCoreClient(), id
         const parameters = {model, payload};
         if (operation === 'stream') return streamRequest(core, parameters, signal);
         if (operation !== 'chat') throw localAIError('ARCANE_AI_PROVIDER_OPERATION_UNAVAILABLE', 'The local llama.cpp provider supports chat and stream.');
-        const pending = ownRequest(signal, model);
+        const pending = ownRequest(signal, model, core);
         pending.result = Promise.resolve().then(function invokeChat() {
+            pending.controller.signal.throwIfAborted();
             return core.invoke('llama.chat', {...parameters, stream: false}, {signal: pending.controller.signal});
         }).then(function chatCompleted(result) {
             if (pending.controller.signal.aborted) throw cancelled(pending.controller.signal.reason);
@@ -268,26 +360,86 @@ export function createCoreLocalAIProvider({client = getInstalledCoreClient(), id
         return pending.result;
     }
 
-    async function unload({selection: value = selection, signal} = {}) {
+    async function unload({signal} = {}) {
+        const value = selection;
         const core = requireClient();
+        const currentConnection = connection;
         if (signal?.aborted) throw cancelled(signal.reason);
+        if (value && value === selection && selectionConnection !== currentConnection) {
+            throw localAIError('ARCANE_AI_CORE_UNAVAILABLE', 'The selected model belongs to a retired Core connection.');
+        }
+        if (value) requireSelection(value);
+        const operation = {};
+        unloading = operation;
+        loading = false;
+        lifecycleRevision += 1;
         for (const request of requests) request.controller.abort();
-        await Promise.allSettled([...requests].map(function activeResult(request) { return request.result; }));
-        if (!value) return status();
-        requireSelection(value);
-        const revision = lifecycleRevision;
-        const current = await core.invoke('llama.unload', {model: value.modelId}, {signal});
-        if (lifecycleRevision === revision) acceptRuntime(current);
-        selection = null;
-        return status();
+        try {
+            await Promise.allSettled([...requests].map(function activeResult(request) { return request.result; }));
+            assertCurrentConnection(currentConnection);
+            if (unloading !== operation) throw cancelled();
+            if (value) {
+                const revision = lifecycleRevision;
+                const current = await invokeOwned(core, 'llama.unload', {model: value.modelId}, signal);
+                assertCurrentConnection(currentConnection);
+                if (unloading !== operation) throw cancelled();
+                if (lifecycleRevision === revision) acceptRuntime(current);
+            }
+            if (unloading !== operation) throw cancelled();
+            selection = null;
+            selectionConnection = null;
+            unloading = false;
+            return status();
+        } catch (error) {
+            if (!disposed && connection === currentConnection && unloading === operation) {
+                runtime = {...runtime, state: 'error', error};
+            }
+            throw error;
+        } finally {
+            if (unloading === operation) unloading = false;
+        }
     }
 
-    async function dispose(options = {}) {
-        if (disposed) return status();
-        if (selection || requests.size) await unload(options);
+    function dispose({signal} = {}) {
+        if (disposing) return disposing;
+        // The runtime also supplies its configured selection after unload.
+        // Only this provider's retained selection owns a native release.
+        const value = selection;
+        const core = selectionConnection?.client;
         disposed = true;
-        unsubscribe();
-        return status();
+        loading = false;
+        unloading = false;
+        lifecycleRevision += 1;
+        stopInstallation?.();
+        connection?.unsubscribe?.();
+        connection?.controller.abort();
+        disposing = Promise.resolve().then(
+            async function disposeLocalProvider() {
+                await Promise.allSettled([...requests].map(function activeResult(request) { return request.result; }));
+                if (value) {
+                    requireSelection(value);
+                    if (!core) throw localAIError('ARCANE_AI_CORE_UNAVAILABLE', 'The retired Core connection cannot unload the selected model.');
+                    // Disposal owns this final release on the captured client only.
+                    // Subscription cleanup above remains complete if it rejects.
+                    await core.invoke('llama.unload', {model: value.modelId}, {signal});
+                }
+                selection = null;
+                selectionConnection = null;
+                return status();
+            }
+        ).catch(
+            function nativeReleaseFailed(error) {
+                runtime = {...runtime, error};
+                throw error;
+            }
+        );
+        return disposing;
+    }
+
+    if (suppliedClient === undefined) {
+        stopInstallation = subscribeCoreClient(bindClient);
+    } else {
+        bindClient({client: suppliedClient});
     }
 
     return {

package/browser-runtime/ai/core-onnx.mjs

@@ -1,4 +1,4 @@
-import {getInstalledCoreClient} from '../core/client.mjs';
+import {subscribeCoreClient} from '../core/client.mjs';
 import {createArcaneEventSource} from '../event-manager.mjs';
 import {encodeTensorMap, decodeTensorMap, encodeTensorFetches} from './onnx-tensors.mjs';
 
@@ -9,16 +9,26 @@ function unavailable(message) {
 }
 
 /** Optional system ONNX access. Construction neither connects nor installs. */
-export function createCoreONNXRuntime({client = getInstalledCoreClient()} = {}) {
+export function createCoreONNXRuntime({client: suppliedClient} = {}) {
     const owner = {};
     const events = createArcaneEventSource(owner, {source: 'core-onnx', eventTypes: ['onnx.state']});
     const lifetime = new AbortController();
     const pending = new Set();
+    let client = null;
+    let connection = null;
+    let stopInstallation;
     let state = {id: 'onnx', installed: false, available: false, state: 'unknown', models: []};
     let revision = 0;
     let closed = false;
 
-    function current() { return {...state, busy: pending.size > 0, closed}; }
+    function current() {
+        const busy = [...pending].some(
+            function currentRequest(request) {
+                return request.connection === connection && !request.signal.aborted;
+            }
+        );
+        return {...state, busy, closed};
+    }
     function publish() { events.dispatch('onnx.state', current()); }
     function accept(value) {
         state = value ?? {id: 'onnx', installed: false, available: false, state: 'unavailable', models: []};
@@ -26,30 +36,66 @@ export function createCoreONNXRuntime({client = getInstalledCoreClient()} = {})
         publish();
     }
 
-    const unsubscribe = client?.events.on('localai.state', function localStateChanged(snapshot) {
-        if (!closed) accept(snapshot?.runtimes?.find(function onnxRuntime(runtime) { return runtime.id === 'onnx'; }));
-    }) ?? function noCoreSubscription() {};
+    function bindClient({client: nextClient, error = null}) {
+        if (closed || (connection && nextClient === client)) return;
+        const previous = connection;
+        client = nextClient;
+        const currentConnection = {client, controller: new AbortController(), unsubscribe: null};
+        connection = currentConnection;
+        revision += 1;
+        state = {id: 'onnx', installed: false, available: false, state: client ? 'unknown' : 'unavailable', models: [], error};
+        previous?.unsubscribe?.();
+        previous?.controller.abort();
+        if (client) {
+            currentConnection.unsubscribe = client.events.on(
+                'localai.state',
+                function localStateChanged(snapshot) {
+                    if (!closed && connection === currentConnection) {
+                        accept(snapshot?.runtimes?.find(function onnxRuntime(runtime) { return runtime.id === 'onnx'; }));
+                    }
+                }
+            );
+        }
+        publish();
+        if (!closed && connection === currentConnection && client && suppliedClient === undefined) {
+            inspect().catch(
+                function initialONNXStateUnavailable(error) {
+                    if (!closed && connection === currentConnection && !currentConnection.controller.signal.aborted) {
+                        globalThis.console?.error('Core ONNX initial state unavailable.', error);
+                    }
+                }
+            );
+        }
+    }
 
     async function invoke(method, parameters, {signal, timeoutMs = 0} = {}) {
         if (closed) throw unavailable('The Core ONNX accessor is closed.');
         if (!client) throw unavailable('Local ONNX requires an available Core connection.');
-        const request = {};
-        const operationSignal = signal ? AbortSignal.any([signal, lifetime.signal]) : lifetime.signal;
+        const currentConnection = connection;
+        const operationSignal = AbortSignal.any(
+            [lifetime.signal, currentConnection.controller.signal, ...(signal ? [signal] : [])]
+        );
+        const request = {connection: currentConnection, signal: operationSignal};
         operationSignal.throwIfAborted();
         pending.add(request);
         publish();
         try {
-            return await client.invoke(method, parameters, {signal: operationSignal, timeoutMs});
+            operationSignal.throwIfAborted();
+            const result = await currentConnection.client.invoke(method, parameters, {signal: operationSignal, timeoutMs});
+            operationSignal.throwIfAborted();
+            return result;
         } finally {
             pending.delete(request);
-            if (!closed) publish();
+            if (!closed && connection === currentConnection) publish();
         }
     }
 
     async function inspect(options) {
         const before = revision;
+        const currentConnection = connection;
         try {
             const result = await invoke('onnx.status', {}, options);
+            currentConnection.controller.signal.throwIfAborted();
             if (!closed && revision === before) accept(result);
             return current();
         } catch (error) {
@@ -61,14 +107,19 @@ export function createCoreONNXRuntime({client = getInstalledCoreClient()} = {})
     }
 
     async function load({id, model, sessionOptions, signal, timeoutMs} = {}) {
-        return invoke('onnx.load', {id, model, sessionOptions}, {signal, timeoutMs});
+        const currentConnection = connection;
+        const result = await invoke('onnx.load', {id, model, sessionOptions}, {signal, timeoutMs});
+        currentConnection.controller.signal.throwIfAborted();
+        return result;
     }
 
     async function run({id, feeds, fetches, runOptions, signal, timeoutMs} = {}) {
+        const currentConnection = connection;
         const result = await invoke('onnx.run', {
             id, feeds: encodeTensorMap(feeds),
             fetches: encodeTensorFetches(fetches), runOptions
         }, {signal, timeoutMs});
+        currentConnection.controller.signal.throwIfAborted();
         return decodeTensorMap(result);
     }
 
@@ -86,11 +137,19 @@ export function createCoreONNXRuntime({client = getInstalledCoreClient()} = {})
         if (closed) return;
         closed = true;
         lifetime.abort();
-        unsubscribe();
+        stopInstallation?.();
+        connection?.unsubscribe?.();
+        connection?.controller.abort();
         state = {...state, available: false, state: 'closed'};
         publish();
         events.dispose();
     }
 
+    if (suppliedClient === undefined) {
+        stopInstallation = subscribeCoreClient(bindClient, {signal: lifetime.signal});
+    } else {
+        bindClient({client: suppliedClient});
+    }
+
     return {load, run, unload, inspect, current, subscribe, close};
 }

package/docs/reference/README.md

@@ -54,6 +54,7 @@ alone does not make bare module names resolve in a browser.
 | Connect a browser to one Core transport | [Core browser client](core-client.md) |
 | Cancel one Core speech synthesis request without changing its payload | [Speech request lifetime](core-client.md#events-and-request-lifetime) and [Core facade](sdk-api.md#createcorefacade) |
 | Compose native Core dispatch, service lifecycle, and stdio hosting | [Native Core runtime](core-runtime.md) |
+| Reuse dependency-ready native services without a renderer | [Core service composition](core-runtime.md#native-service-composition) and [existing ONNX owner](local-ai.md#native-service-owners) |
 | Compose application Core services during source development, independently of local AI | [Development Core services](core-development.md) |
 | Own an explicitly selected native Codex App Server session | [Codex App Server](codex-app-server.md) |
 | Expose application-owned tools and static resources through Node STDIO | [MCP STDIO server](mcp-stdio.md) |
@@ -66,11 +67,14 @@ alone does not make bare module names resolve in a browser.
 | Select the optional Intel NPU encoder with independent CUDA or CPU decoding | [Intel NPU Whisper](../guides/native-whisper-openvino.md) |
 | Edit an original PNG with a complete prompt and explicit strength | [Local image editing](local-image-editing.md) |
 | Project complete stored model files into native working files | [Model assets through Core](model-assets.md) |
+| Prepare selected upstream model members in native services | [Native preparation and retained lifetime](model-assets.md#native-ownership) |
 | Retain a Nemotron model and diarize caller-fed audio streams | [Native speaker diarization](diarization.md) |
 | Persist application-selected preferences through Core | [Core preferences service](core-preferences.md) |
 | Read complete selected Git text without changing a checkout | [Git text snapshots](git-text-snapshot.md) |
 | Own a native working checkout under per-user ArcaneData/Repos | [Native repository workspaces](core-repositories.md) |
+| Read Git identity defaults or select child-only author and credential hints | [Git identity configuration](core-repositories.md#git-identity-configuration) |
 | Write, commit and push complete selected repository text | [Selected-text repository writing](core-repositories.md#write-commit-and-push-selected-text) |
+| Observe existing checkout configuration and capture an explicit remote/ref | [Repository configuration and selected targets](core-repositories.md#existing-checkout-configuration-and-selected-targets) |
 | Build an installed-SDK portable Core payload | [Portable Core packaging](core-native-packaging.md) |
 | Pass host-selected state defaults and unchanged explicit launch values to services | [Launch-time locations](core-native-packaging.md#launch-time-locations) |
 | Build a Windows executable without an OS checkout | [Windows executable packaging](core-native-packaging.md#windows-executable) |
@@ -78,6 +82,7 @@ alone does not make bare module names resolve in a browser.
 | Subscribe to native events | [Arcane event reference](core/arcane-events.md) |
 | Use provider-neutral AI lifecycle, chat, speech, persistence, or document context | [Normalized AI](#normalized-ai) |
 | Choose a normalized typed browser decision surface | [Browser typed decisions](ai/browser-decisions.md) |
+| Score complete typed options with native Laya FP32 | [Native typed decisions](native-decisions.md) |
 | Run a caller-selected local LLM in the browser | [Browser-WASM local AI](ai/browser-wasm.md) |
 | Run caller-selected Whisper/Kokoro, native browser recognition/voices or cloud TTS | [Browser speech providers](ai/browser-speech.md) |
 | Send TWiN chat, System One state/questions or image requests | [TWiN Cloud guide](ai/twin-cloud.md) |
@@ -238,6 +243,7 @@ Ollama, Wllama, Whisper, Kokoro, native, or cloud transport:
 | Run application-selected native llama.cpp/Ollama chat | [`arcane-os/ai/core-local`, `arcane-os/core/local-ai`](local-ai.md) | Explicit Core connection and selected native runtimes; installation, availability and loaded-model readiness remain distinct. |
 | Transcribe complete recordings with a retained native Whisper model | [`arcane-os/local-ai/whisper`](local-whisper.md) and [Core speech](native-speech.md) | Matching native helper, Whisper libraries, decoder and selected model; Windows defaults and explicit other-platform distributions have distinct preparation requirements. |
 | Run a local ONNX graph with named tensors | [`arcane-os/local-ai/onnx`, `arcane-os/ai/core-onnx`](local-ai.md#native-onnx-sessions) | Retained native workers; browser access requires an available Core ONNX service. |
+| Score typed options without a renderer | [`arcane-os/local-ai/decisions`, `arcane-os/core/decisions`](native-decisions.md) | Explicit native Laya FP32 activation using the existing ONNX owner; complete scores and outputs, joined Worker cleanup. |
 | Generate local images from complete prompts and selected model resources | [`arcane-os/local-ai/image`, `arcane-os/ai/core-image`](local-image-generation.md) | Prepared native image runtime; browser access requires its Core service. CPU Windows/Linux and Mac Metal/CPU paths have distinct actual host requirements. |
 | Supply complete stored model members to a native engine | [`arcane-os/ai/core-model-assets`, `arcane-os/core/model-assets`](model-assets.md) | Available Core service; DBOPFS originals stay authoritative while native owners retain working files. |
 | Run caller-selected Whisper/Kokoro locally | [`arcane-os/ai/browser-speech`](ai/browser-speech.md) | Browser with DBOPFS, Web Locks, Workers and selected upstream sources; automatic WebNN NPU, WebGPU, then WASM loading, or an explicit backend. |

package/docs/reference/availability-and-normalization.md

@@ -74,6 +74,7 @@ where listed. See [native output and host requirements](core-native-packaging.md
 | Share one native WebSocket by exact URI and ordered protocols | `arcane-os/websocket-client` | **Node** and **Browser**, using the host's native `WebSocket` | The selected upstream `ws-share` instance owns the connection pool and global observation. Native socket messages and events remain unchanged; there is no reconnect, heartbeat, application envelope, storage, or fallback. |
 | Build browser UI and app-local behavior | `/arcane/modules/*.js`, shared entities, and components | **Browser**; many modules also run inside every native renderer | Pure modules own their result contracts. Modules that call `Arcane` inherit the bridge boundary described below. |
 | Score caller-supplied typed options with Laya or Julia | `arcane-os/ai/browser-decisions` | **Browser** only; caller-selected upstream runtime/model and backend | Typed decisions retain complete rows and return typed values, scores, probabilities, and diagnostics in caller order. This surface is separate from chat and speech and does not silently change model, precision, backend, or family. |
+| Score complete typed options with native Laya FP32 | [`arcane-os/local-ai/decisions`, `arcane-os/core/decisions`](native-decisions.md) | **Node** Windows/Linux/macOS with selected ONNX Runtime and model; Android needs host adaptation | Reuses the existing native ONNX owner and a tokenizer Worker, with explicit load and joined cleanup. Preserves separate state/question/options/type, original rows, raw scores and complete graph outputs. GPU preference attempts actual advertised providers before CPU; provider configuration does not prove physical acceleration. No renderer, chat provider or automatic persistence is required. |
 | Select and observe independent LLM/STT/TTS roles | `/arcane/modules/AIProviderRuntime.js` and `AIRuntimeState.js` | **Cross-host** controller/state; registered providers retain their own host requirements | Required/projected provider members, route/configuration records, and status fields; per-role lifecycle, cancellation, stream cleanup, sticky state, and startup barriers are normalized. `localOnly` creates no fallback. |
 | Run a caller-selected local LLM entirely in a browser renderer | `arcane-os/ai/browser-wasm` through `createArcaneAI()` | **Browser** only; secure context, WebAssembly, and OPFS/DBOPFS; full WebGPU offload by default or explicit CPU with `gpuLayers:0` | The public AI API module normalizes multi-model lifecycle, status, complete all-choice streaming, cancellation, exact ordered structural tool-call visibility, and session persistence. Model sources are canonical ordered file descriptors; licenses and model choice remain application policy. |
 | Run caller-selected Whisper or Kokoro in a browser renderer | `arcane-os/ai/browser-speech` registered with `AIProviderRuntime` | **Browser** only; DBOPFS, Web Locks, Workers, Fetch/object URLs, and a caller-supplied self-contained runtime/model closure are required | Independent provider/2 lifecycle and status, with `auto`, `webnn-npu`, `webgpu`, or `wasm` execution. Whisper owns one Worker/session; Kokoro defaults to four and accepts one through four. Complete model/runtime selection, offline behavior, cancellation, Worker teardown, and request/result shapes are normalized. No runtime/model content or cloud fallback is supplied. |

package/docs/reference/core-native-packaging.md

@@ -261,10 +261,17 @@ service exposes retained worker sessions through `onnx.load/run/unload/status`;
 model files remain caller-selected application resources. See
 [native ONNX sessions](local-ai.md#native-onnx-sessions).
 
-Selected `stable-diffusion.cpp` additionally composes
-`createLocalImageService` from `arcane-os/core/image` and one shared
-`createModelAssetService` from `arcane-os/core/model-assets`. The image factory
-receives the full authored selection plus that same model-assets instance.
+Selecting ONNX, image generation, or both composes one shared
+`createModelAssetService` from `arcane-os/core/model-assets`. Native application
+services obtain that same definition with `await context.getService('model-assets')`.
+They obtain the selected local-AI owner with `await context.getService('local-ai')`
+and its current native ONNX handle with `getONNXRuntime()`. These lookups await
+only their selected service startup, independently of renderer readiness. See
+[native service ownership and cleanup](local-ai.md#native-service-owners).
+
+Selected `stable-diffusion.cpp` additionally composes `createLocalImageService`
+from `arcane-os/core/image`. The image factory receives the full authored
+selection plus that same model-assets instance.
 Library, Koffi binding and variant paths resolve from the artifact root;
 ordinary browser imports use `arcane-os/ai/core-image` and
 `arcane-os/ai/core-model-assets` through the managed import map.