arcane-os 0.66.0 → 0.67.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.67.0
+
+- Add native Laya FP32 typed decisions through `arcane-os/local-ai/decisions`
+  and `arcane-os/core/decisions`, using the existing native ONNX and model-assets
+  owners plus the approved `@huggingface/tokenizers@0.2.0` Worker dependency.
+  Explicit activation preserves complete rows, graph outputs, ordered results,
+  current-state replay, cancellation and actual worker-exit file lifetime.
+- Compose selected native services through one Core owner, prepare complete
+  model files through the existing asset owner, and expose actual GPU-provider
+  attempts with CPU fallback. Accepted configuration does not prove GPU execution.
+- Follow late Core client installation and retirement in default AI accessors.
+  Keep explicit clients fixed, model observation non-loading and disposal tied
+  to actual retained ownership. Preserve recoverable native inference errors
+  without retiring a healthy session or cancelling sibling work; terminal
+  stopping revokes readiness while resources remain retained until actual exit.
+- Add repository `configuration()` observations and captured `target:{remote,ref}`
+  options for ordinary fast-forward pull, non-force push and write. Preserve
+  complete configuration values, payloads and failures without switching branches,
+  rewriting Git configuration or changing omitted-target behavior.
+- Keep theme controls, shared same-app host discovery and optional NPU asset
+  transport follow-through separate. No app data migration or automatic model
+  activation is introduced; applications own their selections and orchestration.
+
 ## 0.66.0
 
 - Add `readGitIdentity` from `arcane-os/core/repositories` for separate global,

package/README.md

@@ -20,7 +20,7 @@ selected SDK projection or an explicit live SDK source mount. Both profiles
 share the theme, packaging, event, cancellation,
 and browser run contracts while retaining their selected application layout.
 
-This checkout defines the `0.66.0` SDK contract. Development applications declare
+This checkout defines the `0.67.0` SDK contract. Development applications declare
 `arcane-os` as `latest` and retain their lockfile. Exact SDK pins begin when Roshi
 designates a production build. Follow [Consumer updates](docs/consumer-updates.md)
 to refresh and compare the installed SDK and lockfile with the published channel;

package/browser-runtime/ai/core-image.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';
 import {CoreError, serializeCoreError} from '../core/contracts.mjs';
 import {createArcaneEventSource} from '../event-manager.mjs';
 
@@ -50,7 +50,7 @@ async function encodeImage(image, signal) {
 
 /** Browser access to the selected native image service; no result persistence. */
 export function createCoreImageRuntime(
-    {client = getInstalledCoreClient(), signal, onEvent} = {}
+    {client: suppliedClient, signal, onEvent} = {}
 ) {
     const owner = {};
     const events = createArcaneEventSource(
@@ -60,26 +60,37 @@ export function createCoreImageRuntime(
     const lifetime = new AbortController();
     const lifetimeSignal = signal ? AbortSignal.any([signal, lifetime.signal]) : lifetime.signal;
     const pending = new Set();
-    let state = {
-        id: 'stable-diffusion.cpp',
-        installed: false,
-        available: false,
-        selectedModel: null,
-        loaded: false,
-        state: client ? 'unknown' : 'unavailable',
-        backend: null,
-        devices: [],
-        resources: {},
-        progress: null,
-        error: null,
-        models: []
-    };
+    let client = null;
+    let connection = null;
+    let stopInstallation;
+    let state = emptyState();
     let revision = 0;
     let closed = false;
     let closing;
 
+    function emptyState(error = null) {
+        return {
+            id: 'stable-diffusion.cpp',
+            installed: false,
+            available: false,
+            selectedModel: null,
+            loaded: false,
+            state: client ? 'unknown' : 'unavailable',
+            backend: null,
+            devices: [],
+            resources: {},
+            progress: null,
+            error: error ? serializeCoreError(error) : null,
+            models: []
+        };
+    }
+
     function current() {
-        const requests = [...pending].map(
+        const requests = [...pending].filter(
+            function currentConnectionRequest(request) {
+                return request.connection === connection && !request.signal.aborted;
+            }
+        ).map(
             function requestState(request) {
                 return {
                     method: request.method,
@@ -97,7 +108,7 @@ export function createCoreImageRuntime(
                     return request.status === 'Thinking';
                 }
             ) ? 'Thinking' : null,
-            busy: pending.size > 0,
+            busy: requests.length > 0,
             closed
         };
     }
@@ -146,8 +157,38 @@ export function createCoreImageRuntime(
         publish();
     }
 
-    const unsubscribe = client?.events.on('image.state', accept)
-        ?? 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 = emptyState(error);
+        previous?.unsubscribe?.();
+        previous?.controller.abort();
+        if (client) {
+            currentConnection.unsubscribe = client.events.on(
+                'image.state',
+                function currentImageState(value) {
+                    if (connection === currentConnection) accept(value);
+                }
+            );
+        }
+        publish();
+        if (!closed && connection === currentConnection && client) {
+            // Observe only; installation never loads an engine or model.
+            inspect().catch(
+                function initialImageStateUnavailable(error) {
+                    if (!closed && connection === currentConnection && !currentConnection.controller.signal.aborted) {
+                        reportObserverFailure(error);
+                    }
+                }
+            );
+        }
+    }
 
     function invoke(method, parameters, {signal: requestSignal, onProgress} = {}) {
         if (closed) {
@@ -156,11 +197,15 @@ export function createCoreImageRuntime(
         if (!client) {
             throw unavailable('Local image generation requires an available Core connection.');
         }
-        const operationSignal = requestSignal
-            ? AbortSignal.any([requestSignal, lifetimeSignal]) : lifetimeSignal;
+        const currentConnection = connection;
+        const operationSignal = AbortSignal.any(
+            [lifetimeSignal, currentConnection.controller.signal, ...(requestSignal ? [requestSignal] : [])]
+        );
         operationSignal.throwIfAborted();
         const request = {
             method,
+            connection: currentConnection,
+            signal: operationSignal,
             revision,
             streamId: parameters.streamId,
             status: method === 'image.generate' || method === 'image.edit' ? 'Thinking' : null,
@@ -169,7 +214,7 @@ export function createCoreImageRuntime(
         };
         let stopProgress;
         if (request.streamId) {
-            stopProgress = client.events.on(
+            stopProgress = currentConnection.client.events.on(
                 'image.progress',
                 function imageProgress(value) {
                     if (closed || operationSignal.aborted || value.streamId !== request.streamId) {
@@ -202,7 +247,7 @@ export function createCoreImageRuntime(
                     {type: 'image.request', data: {method, parameters: requestParameters}}
                 );
                 operationSignal.throwIfAborted();
-                const result = await client.invoke(
+                const result = await currentConnection.client.invoke(
                     method,
                     requestParameters,
                     {signal: operationSignal, timeoutMs: 0}
@@ -238,7 +283,7 @@ export function createCoreImageRuntime(
             function releaseImageRequest() {
                 stopProgress?.();
                 pending.delete(request);
-                if (!closed) {
+                if (!closed && connection === currentConnection) {
                     publish();
                 }
             }
@@ -251,12 +296,14 @@ export function createCoreImageRuntime(
 
     async function inspect({signal: requestSignal} = {}) {
         const before = revision;
+        const currentConnection = connection;
         try {
             const result = await invoke(
                 'image.status',
                 {},
                 {signal: requestSignal}
             );
+            currentConnection.controller.signal.throwIfAborted();
             if (!closed && revision === before) {
                 accept(result);
             }
@@ -273,11 +320,13 @@ export function createCoreImageRuntime(
 
     async function load({model, context, assetProjectionId, resourcePaths, signal: requestSignal} = {}) {
         const before = revision;
+        const currentConnection = connection;
         const result = await invoke(
             'image.load',
             {model, context, assetProjectionId, resourcePaths},
             {signal: requestSignal}
         );
+        currentConnection.controller.signal.throwIfAborted();
         if (!closed && revision === before) {
             accept(result);
         }
@@ -308,11 +357,13 @@ export function createCoreImageRuntime(
 
     async function unload({signal: requestSignal} = {}) {
         const before = revision;
+        const currentConnection = connection;
         const result = await invoke(
             'image.unload',
             {},
             {signal: requestSignal}
         );
+        currentConnection.controller.signal.throwIfAborted();
         if (!closed && revision === before) {
             accept(result);
         }
@@ -365,8 +416,10 @@ export function createCoreImageRuntime(
         );
         lifetime.abort();
         lifetimeSignal.removeEventListener('abort', close);
-        unsubscribe();
-        state = {...state, available: false, state: 'closed'};
+        stopInstallation?.();
+        connection?.unsubscribe?.();
+        connection?.controller.abort();
+        state = {...state, available: false, loaded: false, state: 'closed'};
         publish();
         events.dispose();
         return closing;
@@ -379,13 +432,10 @@ export function createCoreImageRuntime(
     );
     if (lifetimeSignal.aborted) {
         close();
-    } else if (client) {
-        // Subscribe before the snapshot request so a later lifecycle event wins.
-        inspect().catch(
-            function initialImageStateUnavailable(error) {
-                globalThis.console?.error('Core image initial state unavailable.', error);
-            }
-        );
+    } else if (suppliedClient === undefined) {
+        stopInstallation = subscribeCoreClient(bindClient, {signal: lifetimeSignal});
+    } else {
+        bindClient({client: suppliedClient});
     }
 
     return {load, generate, edit, unload, inspect, current, subscribe, close};

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 {