arcane-os 0.65.0 → 0.67.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/browser-runtime/ai/decision-runtime.mjs

@@ -82,7 +82,8 @@ export function encodeDecisionRows(tokenizer, rows, family) {
     return {encoded, pad};
 }
 
-function decisionInputs(Tensor, encoded, pad) {
+/** Plain tensor records shared by browser and native ONNX execution owners. */
+export function createDecisionInputs(encoded, pad) {
     let sequenceLength = 0;
     let optionCount = 0;
     for (const row of encoded) {
@@ -108,26 +109,11 @@ function decisionInputs(Tensor, encoded, pad) {
         types[rowIndex] = BigInt(row.qtype);
     }
     return {
-        input_ids: new Tensor(
-            'int64', ids,
-            [batch, sequenceLength]
-        ),
-        attention_mask: new Tensor(
-            'int64', attention,
-            [batch, sequenceLength]
-        ),
-        marker_pos: new Tensor(
-            'int64', positions,
-            [batch, optionCount]
-        ),
-        marker_mask: new Tensor(
-            'bool', mask,
-            [batch, optionCount]
-        ),
-        qtype: new Tensor(
-            'int64', types,
-            [batch]
-        )
+        input_ids: {type: 'int64', data: ids, dims: [batch, sequenceLength]},
+        attention_mask: {type: 'int64', data: attention, dims: [batch, sequenceLength]},
+        marker_pos: {type: 'int64', data: positions, dims: [batch, optionCount]},
+        marker_mask: {type: 'bool', data: mask, dims: [batch, optionCount]},
+        qtype: {type: 'int64', data: types, dims: [batch]}
     };
 }
 
@@ -210,7 +196,8 @@ export function decodeDecisionOutputs(rows, outputs) {
 }
 
 export async function loadDecisionRuntime(configuration, report) {
-    const {family, model: repository, revision = 'main', device = 'webgpu', runtime} = configuration;
+    const {family, model: repository, revision = 'main', device = 'webgpu',
+        dtype = family === 'laya' ? 'fp16' : 'fp32', runtime} = configuration;
     report(
         {phase: 'loading-runtime'}
     );
@@ -219,7 +206,7 @@ export async function loadDecisionRuntime(configuration, report) {
         namespace.env.backends.onnx.wasm.wasmPaths = runtime.wasmPaths;
     }
     const {AutoTokenizer, AutoModel, PreTrainedModel, Tensor} = namespace;
-    const options = {revision, device, dtype: family === 'laya' ? 'fp16' : 'fp32'};
+    const options = {revision, device, dtype};
     // No progress_callback: upstream 4.3 otherwise performs file-size
     // aggregation. This owner reports actual semantic lifecycle transitions.
     report(
@@ -261,7 +248,10 @@ export async function loadDecisionRuntime(configuration, report) {
     async function evaluate(rows) {
         const {encoded, pad} = encodeDecisionRows(tokenizer, rows, family);
         if (encoded.length === 0) return {decisions: [], outputs: {}};
-        const inputs = decisionInputs(Tensor, encoded, pad);
+        const inputs = {};
+        for (const [name, record] of Object.entries(createDecisionInputs(encoded, pad))) {
+            inputs[name] = new Tensor(record.type, record.data, record.dims);
+        }
         let output;
         try {
             output = await model(inputs);

package/docs/publishing.md

@@ -116,6 +116,45 @@ tag and GitHub release title must both be the same bare numeric
 `MAJOR.MINOR.PATCH`. Prerelease versions do not get a misleading numeric
 GitHub release, and no release creates a Git branch for an npm dist-tag.
 
+## Native runtime assets on numeric releases
+
+Default SDK-hosted native asset URLs use the installed SDK's version and its
+matching numeric GitHub release. Publishing npm alone does not make those
+downloads available. Every applicable numeric release therefore includes its
+compatible retained SDK-hosted assets as release follow-through:
+
+| Selected capability | Windows x64 release asset |
+| --- | --- |
+| Native application host | `arcane-native-windows-x64.tar.gz` |
+| Ordinary native Whisper helper | `arcane-whisper-windows-x64.tar.gz` |
+| Optional Intel NPU Whisper encoder | `arcane-whisper-openvino-windows-x64.tar.gz` |
+
+Attach each asset used by the selected package's default SDK-hosted download
+paths, including later releases whose native implementation is unchanged.
+Include the optional NPU asset when that release supplies `encoder:
+"openvino-npu"`; applications still opt in, and the ordinary Whisper asset
+remains available. Upstream runtime and model versions retain their separate
+upstream distribution URLs; they are not renamed to the SDK version.
+
+Reuse the producer's retained compatible archive and its recorded selected
+evidence. Do not rebuild or redownload an unchanged archive for each release.
+An actual native change belongs to its producer under the existing build and
+dependency authority. Preserve the complete runtime closure and its packaging
+notices together. Models continue through their upstream acquisition path
+unless their redistribution is separately requested.
+
+The release owner assigns each upload, observes its outcome and records the
+exact asset name and public release URL in the durable release handoff. If an
+upload result is uncertain, inspect that release's existing asset before
+retrying. Retain the exact pending operation, executing owner and last result
+until delivery finishes; reassign idle delegated work rather than treating
+delegation as completion.
+
+Source delivery, selected package verification, npm publication, native asset
+delivery, requester notices and documentation/site delivery are distinct.
+Native archive follow-through does not gate npm publication or require a new
+package build. Consumer adoption remains with each application owner.
+
 ## Documentation publication
 
 After every successful npm release and its applicable requester notices, the