arcane-os 0.79.1 → 0.81.0

package/src/core/services/decisions.mjs

@@ -8,32 +8,52 @@ function sameExecutionTarget(left, right) {
     return left === right || (left != null && right != null && left.deviceId !== undefined && left.deviceId === right.deviceId);
 }
 
+function sameActivation(left, right) {
+    if (!left || !right || !sameExecutionTarget(left.executionTarget, right.executionTarget) || left.assetProjectionId !== right.assetProjectionId) return false;
+    if (left.family !== right.family || left.model !== right.model || left.revision !== right.revision || left.dtype !== right.dtype) return false;
+    if (left.resourcePaths === right.resourcePaths) return true;
+    if (!left.resourcePaths || !right.resourcePaths) return false;
+    const entries = Object.entries(left.resourcePaths);
+    return entries.length === Object.keys(right.resourcePaths).length
+        && entries.every(function sameResource([role, member]) { return right.resourcePaths[role] === member; });
+}
+
 /** App-owned selection; shared typed-decision execution, without a renderer. */
 export function createNativeDecisionService(configuration = {}, {appRoot = process.cwd()} = {}) {
     const events = createArcaneEventSource({}, {source: 'core-decisions', eventTypes: ['decisions.state']});
     const lifetime = new AbortController();
+    const loads = new Set();
+    const provisionalCleanupFailures = [];
     let context;
+    let modelAssetOwner;
     let model;
     let loading;
     let loadController;
     let releasing;
     let closing;
     let unsubscribe;
-    let selectedTarget = configuration.executionTarget;
-    let loadingTarget;
-    let loadedTarget;
+    let selectedActivation = {
+        family: configuration.family === undefined ? 'laya' : configuration.family,
+        model: configuration.model === undefined ? 'onnx-community/laya-typed-decisions-ONNX' : configuration.model,
+        revision: configuration.revision === undefined ? 'main' : configuration.revision,
+        dtype: configuration.dtype === undefined ? 'fp32' : configuration.dtype,
+        executionTarget: configuration.executionTarget,
+        ...(configuration.assetProjectionId == null ? {} : {assetProjectionId: configuration.assetProjectionId, resourcePaths: configuration.resourcePaths && {...configuration.resourcePaths}})
+    };
+    let loadingActivation;
+    let loadedActivation;
 
     function current() {
         const snapshot = model?.current() ?? {
-            family: 'laya', model: configuration.model ?? 'onnx-community/laya-typed-decisions-ONNX',
+            family: configuration.family ?? 'laya', model: configuration.model ?? 'onnx-community/laya-typed-decisions-ONNX',
             revision: configuration.revision ?? 'main', dtype: configuration.dtype ?? 'fp32',
             state: closing ? 'disposed' : 'unloaded', loaded: false, busy: Boolean(loading),
             activeRequests: 0, progress: null, error: null, execution: null
         };
-        const pending = Boolean(loading) && (!snapshot.loaded || !sameExecutionTarget(loadedTarget, loadingTarget));
+        const pending = Boolean(loading) && (!snapshot.loaded || !sameActivation(loadedActivation, loadingActivation));
         return {
             ...snapshot, busy: snapshot.busy || pending,
-            pendingActivation: pending ? {executionTarget: loadingTarget} : snapshot.pendingActivation ?? null
+            pendingActivation: pending ? {...loadingActivation} : snapshot.pendingActivation ?? null
         };
     }
 
@@ -51,57 +71,100 @@ export function createNativeDecisionService(configuration = {}, {appRoot = proce
 
     function operationSignal(signal) { return signal ? AbortSignal.any([signal, lifetime.signal]) : lifetime.signal; }
 
-    function load({signal, executionTarget: requestedTarget} = {}) {
+    function load({
+        family: requestedFamily, model: requestedModel, revision: requestedRevision, dtype: requestedDtype,
+        signal, executionTarget: requestedTarget, assetProjectionId: requestedProjection, resourcePaths: requestedPaths
+    } = {}) {
         operationSignal(signal).throwIfAborted();
         if (!context) throw new CoreError({code: 'CORE_NOT_READY', message: 'Register and start the decision service with Core before loading.'});
-        const target = requestedTarget === undefined ? selectedTarget : requestedTarget;
-        if (loading && !loadController.signal.aborted && sameExecutionTarget(loadingTarget, target)) return observeLoad(loading, loadController, signal);
-        if (!loading && model?.current().loaded && sameExecutionTarget(loadedTarget, target)) return Promise.resolve(current());
+        const projection = requestedProjection === undefined ? selectedActivation.assetProjectionId : requestedProjection;
+        const mapping = requestedPaths === undefined ? selectedActivation.resourcePaths : requestedPaths;
+        const selection = {
+            family: requestedFamily === undefined ? selectedActivation.family : requestedFamily,
+            model: requestedModel === undefined ? selectedActivation.model : requestedModel,
+            revision: requestedRevision === undefined ? selectedActivation.revision : requestedRevision,
+            dtype: requestedDtype === undefined ? selectedActivation.dtype : requestedDtype,
+            executionTarget: requestedTarget === undefined ? selectedActivation.executionTarget : requestedTarget,
+            ...(projection == null ? {} : {assetProjectionId: projection, resourcePaths: mapping && typeof mapping === 'object' && !Array.isArray(mapping) ? {...mapping} : mapping})
+        };
+        if (loading && !loadController.signal.aborted && sameActivation(loadingActivation, selection)) return observeLoad(loading, loadController, signal);
+        if (!loading && model?.current().loaded && sameActivation(loadedActivation, selection)) return Promise.resolve(current());
         const previousLoad = loading;
         const previousController = loadController;
         const controller = new AbortController();
         const selectedSignal = AbortSignal.any([lifetime.signal, controller.signal]);
         const precedingRelease = releasing;
+        let retained;
+        let retainError;
         const task = Promise.resolve().then(async function loadSelectedModel() {
-            selectedSignal.throwIfAborted();
-            if (precedingRelease) await precedingRelease;
-            if (previousLoad) await Promise.allSettled([previousLoad]);
-            selectedSignal.throwIfAborted();
-            if (model) await model.dispose();
-            selectedSignal.throwIfAborted();
-            unsubscribe?.();
-            // Only the explicit load waits for its native dependencies. Merely
-            // registering this service does not download a model or delay UI.
-            const [localAI, modelAssets] = await Promise.all([
-                context.getService('local-ai'),
-                configuration.paths ? undefined : context.getService('model-assets')
-            ]);
-            selectedSignal.throwIfAborted();
-            const paths = configuration.paths && Object.fromEntries(
-                Object.entries(configuration.paths).map(function nativePath([name, value]) { return [name, path.resolve(appRoot, value)]; })
-            );
-            model = createNativeDecisionModel({
-                ...configuration, paths, onnx: localAI.getONNXRuntime(), modelAssets, executionTarget: target,
-                signal: lifetime.signal
-            });
-            unsubscribe = model.subscribe(function modelStateChanged() { publish(); });
-            const result = await model.load({signal: selectedSignal});
-            selectedSignal.throwIfAborted();
-            loadedTarget = target;
-            return result;
+            const replaced = new CoreError({name: 'AbortError', code: 'ARCANE_AI_REQUEST_ABORTED', message: 'The native decision activation request was replaced.'});
+            try {
+                if (retainError) throw retainError;
+                selectedSignal.throwIfAborted();
+                if (loading !== task) throw replaced;
+                // Only explicit load waits for these owners. A provisional use
+                // protects incoming files while the preceding model retires.
+                const [localAI, modelAssets] = await Promise.all([
+                    context.getService('local-ai'),
+                    configuration.paths && selection.assetProjectionId === undefined ? undefined : context.getService('model-assets')
+                ]);
+                selectedSignal.throwIfAborted();
+                if (loading !== task) throw replaced;
+                if (modelAssets) modelAssetOwner = modelAssets;
+                if (selection.assetProjectionId !== undefined && !retained) retained = modelAssets.retain(selection.assetProjectionId);
+                selectedSignal.throwIfAborted();
+                if (loading !== task) throw replaced;
+                previousController?.abort(replaced);
+                if (precedingRelease) await precedingRelease;
+                if (previousLoad) await Promise.allSettled([previousLoad]);
+                selectedSignal.throwIfAborted();
+                if (loading !== task) throw replaced;
+                if (model) await model.dispose();
+                selectedSignal.throwIfAborted();
+                if (loading !== task) throw replaced;
+                unsubscribe?.();
+                const paths = configuration.paths && Object.fromEntries(
+                    Object.entries(configuration.paths).map(function nativePath([name, value]) { return [name, path.resolve(appRoot, value)]; })
+                );
+                model = createNativeDecisionModel({
+                    ...configuration, paths, onnx: localAI.getONNXRuntime(), modelAssets,
+                    family: selection.family, model: selection.model, revision: selection.revision, dtype: selection.dtype,
+                    executionTarget: selection.executionTarget, assetProjectionId: selection.assetProjectionId,
+                    resourcePaths: selection.resourcePaths, signal: lifetime.signal
+                });
+                unsubscribe = model.subscribe(function modelStateChanged() { publish(); });
+                const result = await model.load({signal: selectedSignal});
+                selectedSignal.throwIfAborted();
+                loadedActivation = selection;
+                return result;
+            } finally {
+                previousController?.abort(replaced);
+                try { await retained?.release(); }
+                catch (error) {
+                    provisionalCleanupFailures.push(error);
+                    throw error;
+                }
+            }
         });
         function settled() {
+            loads.delete(task);
             if (loading !== task) return;
             loading = undefined;
             loadController = undefined;
             publish();
         }
         task.then(settled, settled).catch(function reportStateFailure(error) { console.error('Native decision state publication failed.', error); });
+        loads.add(task);
         loading = task;
         loadController = controller;
-        loadingTarget = target;
-        selectedTarget = target;
-        previousController?.abort(new CoreError({name: 'AbortError', code: 'ARCANE_AI_REQUEST_ABORTED', message: 'The native decision activation request was replaced.'}));
+        loadingActivation = selection;
+        selectedActivation = selection;
+        // A pending predecessor may hold the final native use while its workers
+        // exit. Take our use before making that predecessor's cleanup runnable.
+        if (selection.assetProjectionId !== undefined && modelAssetOwner) {
+            try { retained = modelAssetOwner.retain(selection.assetProjectionId); }
+            catch (error) { retainError = error; }
+        }
         publish();
         return observeLoad(task, controller, signal);
     }
@@ -133,9 +196,12 @@ export function createNativeDecisionService(configuration = {}, {appRoot = proce
         // rather than wait for it to download and activate first.
         loadController?.abort(new CoreError({name: 'AbortError', code: 'ARCANE_AI_REQUEST_ABORTED', message: 'The native decision load was cancelled.'}));
         const task = model?.unload() ?? Promise.resolve();
-        const acceptedLoad = loading;
+        const acceptedLoads = [...loads];
         releasing = Promise.resolve().then(async function releaseSelectedModel() {
-            const results = await Promise.allSettled([task, acceptedLoad]);
+            const results = await Promise.allSettled([task, ...acceptedLoads]);
+            if (provisionalCleanupFailures.length) throw new AggregateError([
+                ...(results[0].status === 'rejected' ? [results[0].reason] : []), ...provisionalCleanupFailures
+            ], 'Releasing native decision resources failed.');
             if (results[0].status === 'rejected') throw results[0].reason;
             return current();
         });
@@ -149,7 +215,8 @@ export function createNativeDecisionService(configuration = {}, {appRoot = proce
         const reason = new CoreError({name: 'AbortError', code: 'ARCANE_AI_REQUEST_ABORTED', message: 'The native decision service is closing.'});
         closing = Promise.resolve().then(async function closeDecisionService() {
             const failures = [];
-            try { await loading; } catch (error) { if (!lifetime.signal.aborted) failures.push(error); }
+            await Promise.allSettled([...loads]);
+            failures.push(...provisionalCleanupFailures);
             try { await model?.dispose(); } catch (error) { failures.push(error); }
             unsubscribe?.();
             publish();
@@ -165,7 +232,13 @@ export function createNativeDecisionService(configuration = {}, {appRoot = proce
         start(serviceContext) { context = serviceContext; },
         methods: {
             'decisions.status': current,
-            'decisions.load': function loadRequest(parameters, request) { return load({executionTarget: parameters?.executionTarget, signal: request.signal}); },
+            'decisions.load': function loadRequest(parameters, request) {
+                return load({
+                    family: parameters?.family, model: parameters?.model, revision: parameters?.revision, dtype: parameters?.dtype,
+                    executionTarget: parameters?.executionTarget, assetProjectionId: parameters?.assetProjectionId,
+                    resourcePaths: parameters?.resourcePaths, signal: request.signal
+                });
+            },
             'decisions.evaluate': async function evaluateRequest({rows, runOptions}, request) {
                 const result = await evaluate(rows, {runOptions, signal: request.signal});
                 // Typed arrays retain their complete values through Core's

package/src/local-ai/decision-tokenizer-worker.mjs

@@ -17,7 +17,7 @@ try {
     };
     parentPort.on('message', function encodeRequest({id, rows}) {
         try {
-            const {encoded, pad} = encodeDecisionRows(interfaceAdapter, rows, 'laya');
+            const {encoded, pad} = encodeDecisionRows(interfaceAdapter, rows, workerData.family);
             const inputs = createDecisionInputs(encoded, pad);
             parentPort.postMessage({id, result: inputs});
         } catch (error) {

package/src/local-ai/decision-tokenizer.mjs

@@ -6,7 +6,7 @@ function cancelled() {
 }
 
 /** One tokenizer worker owned by one native model activation. */
-export function createDecisionTokenizer({tokenizerPath, tokenizerConfigPath, signal, onError}) {
+export function createDecisionTokenizer({family = 'laya', tokenizerPath, tokenizerConfigPath, signal, onError}) {
     signal?.throwIfAborted();
     const pending = new Map();
     let nextId = 0;
@@ -14,7 +14,7 @@ export function createDecisionTokenizer({tokenizerPath, tokenizerConfigPath, sig
     let terminalError;
     let exited = false;
     const worker = new Worker(new URL('./decision-tokenizer-worker.mjs', import.meta.url), {
-        workerData: {tokenizerPath, tokenizerConfigPath}
+        workerData: {family, tokenizerPath, tokenizerConfigPath}
     });
     let resolveExit;
     const exit = new Promise(function tokenizerExit(resolve) { resolveExit = resolve; });

package/src/local-ai/decisions.mjs

@@ -5,7 +5,13 @@ import {decodeDecisionOutputs} from '../../browser-runtime/ai/decision-runtime.m
 import {createDecisionTokenizer} from './decision-tokenizer.mjs';
 
 const STATE_EVENT = 'ai.decisions.state';
-const LAYA_FILES = ['onnx/model.onnx', 'onnx/model.onnx_data', 'tokenizer.json', 'tokenizer_config.json'];
+
+function selectedGraph(family, dtype) {
+    if (family === 'laya' && dtype === 'fp32') return 'onnx/model.onnx';
+    if (family === 'laya' && dtype === 'fp16') return 'onnx/model_fp16.onnx';
+    if (family === 'julia' && dtype === 'fp32') return 'model.onnx';
+    throw new TypeError('Native decisions support Laya fp32/fp16 and Julia fp32 graph selections.');
+}
 
 function cancellation(message) {
     return new CoreError({name: 'AbortError', code: 'ARCANE_AI_REQUEST_ABORTED', message});
@@ -17,18 +23,30 @@ function sameExecutionTarget(left, right) {
     return left === right || (left != null && right != null && left.deviceId !== undefined && left.deviceId === right.deviceId);
 }
 
+function sameActivation(left, right) {
+    if (left.family !== right.family || left.model !== right.model || left.revision !== right.revision || left.dtype !== right.dtype) return false;
+    if (!sameExecutionTarget(left.executionTarget, right.executionTarget) || left.assetProjectionId !== right.assetProjectionId) return false;
+    if (left.resourcePaths === right.resourcePaths) return true;
+    if (!left.resourcePaths || !right.resourcePaths) return false;
+    const entries = Object.entries(left.resourcePaths);
+    return entries.length === Object.keys(right.resourcePaths).length
+        && entries.every(function sameResource([role, member]) { return right.resourcePaths[role] === member; });
+}
+
 /**
- * One explicitly activated Laya FP32 model using an existing native ONNX owner.
+ * One explicitly activated typed-decision model using an existing native ONNX owner.
  * It does not create another inference runtime or load on construction.
  */
 export function createNativeDecisionModel({
-    onnx, modelAssets, workingDirectory, paths,
-    model = 'onnx-community/laya-typed-decisions-ONNX', revision = 'main',
+    onnx, modelAssets, workingDirectory, paths, assetProjectionId, resourcePaths,
+    family = 'laya', model = 'onnx-community/laya-typed-decisions-ONNX', revision = 'main',
     dtype = 'fp32', sessionOptions, executionPreference = 'gpu', executionTarget, signal
 } = {}) {
-    if (dtype !== 'fp32') throw new TypeError('This native Laya graph selection requires dtype fp32.');
+    selectedGraph(family, dtype);
     const owner = {};
     const events = createArcaneEventSource(owner, {source: 'native-decisions', eventTypes: [STATE_EVENT]});
+    const loads = new Set();
+    const provisionalCleanupFailures = [];
     let activation;
     let releaseTask;
     let disposal;
@@ -37,18 +55,23 @@ export function createNativeDecisionModel({
     let progress = null;
     let lastError = null;
     let execution = null;
-    let selectedTarget = executionTarget;
+    let selectedActivation = {
+        family, model, revision, dtype, executionTarget,
+        ...(assetProjectionId == null ? {} : {assetProjectionId, resourcePaths: resourcePaths && {...resourcePaths}})
+    };
+    let activeSelection = selectedActivation;
     let pendingActivation;
 
     function current() {
         const pending = pendingActivation && (state !== 'ready' || pendingActivation.entry !== activation) ? pendingActivation : null;
         return {
-            family: 'laya', model, revision, dtype, state,
+            family: activeSelection.family, model: activeSelection.model,
+            revision: activeSelection.revision, dtype: activeSelection.dtype, state,
             loaded: state === 'ready', busy: state === 'loading' || Boolean(pending) || Boolean(activation?.jobs.size),
             activeRequests: activation?.jobs.size ?? 0, progress,
             error: lastError ? serializeCoreError(lastError) : null,
             execution,
-            pendingActivation: pending ? {executionTarget: pending.executionTarget} : null
+            pendingActivation: pending ? {...pending.selection} : null
         };
     }
 
@@ -131,12 +154,32 @@ export function createNativeDecisionModel({
     }
 
     async function prepareFiles(entry) {
+        if (entry.selection.assetProjectionId !== undefined) {
+            const mapping = entry.selection.resourcePaths;
+            if (!mapping || typeof mapping !== 'object' || Array.isArray(mapping)) {
+                throw new TypeError('Projected decisions require resourcePaths for model, tokenizer and tokenizerConfig.');
+            }
+            const files = {};
+            for (const role of ['model', 'tokenizer', 'tokenizerConfig']) {
+                const member = entry.retained.members.find(function selectedMember(value) { return value.path === mapping[role]; });
+                if (!member) throw new CoreError({
+                    code: 'ARCANE_DECISION_RESOURCE_UNAVAILABLE',
+                    message: `The retained decision projection has no member ${String(mapping[role])} for ${role}.`
+                });
+                files[role] = member.nativePath;
+            }
+            return files;
+        }
         if (paths) return paths;
         if (!modelAssets) throw new CoreError({code: 'ARCANE_DECISION_ASSETS_UNAVAILABLE', message: 'Native decisions need prepared paths or the Core model-assets owner.'});
-        const base = `https://huggingface.co/${model}/resolve/${encodeURIComponent(revision)}/`;
+        const {family: selectedFamily, model: selectedModel, revision: selectedRevision, dtype: selectedDtype} = entry.selection;
+        const graph = selectedGraph(selectedFamily, selectedDtype);
+        const companion = selectedFamily === 'laya' ? `${graph}_data` : `${graph}.data`;
+        const members = [graph, companion, 'tokenizer.json', 'tokenizer_config.json'];
+        const base = `https://huggingface.co/${selectedModel}/resolve/${encodeURIComponent(selectedRevision)}/`;
         const projection = await modelAssets.prepare({
             id: entry.id, workingDirectory,
-            members: LAYA_FILES.map(function selectFile(path) { return {path, url: new URL(path, base).href}; }),
+            members: members.map(function selectFile(path) { return {path, url: new URL(path, base).href}; }),
             signal: entry.controller.signal,
             onProgress(value) { updateProgress(entry, value); }
         });
@@ -146,12 +189,18 @@ export function createNativeDecisionModel({
         await modelAssets.release(entry.id);
         entry.prepared = false;
         const files = Object.fromEntries(projection.members.map(function memberFile(member) { return [member.path, member.nativePath]; }));
-        return {model: files['onnx/model.onnx'], tokenizer: files['tokenizer.json'], tokenizerConfig: files['tokenizer_config.json']};
+        return {model: files[graph], tokenizer: files['tokenizer.json'], tokenizerConfig: files['tokenizer_config.json']};
     }
 
-    function beginActivation(target) {
-        const entry = {id: randomUUID(), controller: new AbortController(), jobs: new Set(), prepared: false, onnxLoadStarted: false, executionTarget: target};
+    function beginActivation(request) {
+        const entry = {
+            id: randomUUID(), controller: new AbortController(), jobs: new Set(), prepared: false, onnxLoadStarted: false,
+            selection: request.selection, executionTarget: request.selection.executionTarget, retained: request.retained
+        };
+        request.retained = undefined;
+        request.entry = entry;
         activation = entry;
+        activeSelection = entry.selection;
         state = 'loading';
         progress = {phase: 'preparing-model'};
         lastError = null;
@@ -161,6 +210,7 @@ export function createNativeDecisionModel({
             entry.controller.signal.throwIfAborted();
             updateProgress(entry, {phase: 'loading-model'});
             entry.tokenizer = createDecisionTokenizer({
+                family: entry.selection.family,
                 tokenizerPath: files.tokenizer, tokenizerConfigPath: files.tokenizerConfig,
                 signal: entry.controller.signal,
                 onError(error) {
@@ -223,33 +273,57 @@ export function createNativeDecisionModel({
         }).finally(function detachLoadCaller() { operationSignal?.removeEventListener('abort', abort); });
     }
 
-    async function load({signal: operationSignal, executionTarget: requestedTarget} = {}) {
+    async function load({
+        family: requestedFamily, model: requestedModel, revision: requestedRevision, dtype: requestedDtype,
+        signal: operationSignal, executionTarget: requestedTarget, assetProjectionId: requestedProjection, resourcePaths: requestedPaths
+    } = {}) {
         assertOpen(operationSignal);
-        const target = requestedTarget === undefined ? selectedTarget : requestedTarget;
-        if (pendingActivation && !pendingActivation.controller.signal.aborted && sameExecutionTarget(pendingActivation.executionTarget, target)) {
+        const projection = requestedProjection === undefined ? selectedActivation.assetProjectionId : requestedProjection;
+        const mapping = requestedPaths === undefined ? selectedActivation.resourcePaths : requestedPaths;
+        const selection = {
+            family: requestedFamily === undefined ? selectedActivation.family : requestedFamily,
+            model: requestedModel === undefined ? selectedActivation.model : requestedModel,
+            revision: requestedRevision === undefined ? selectedActivation.revision : requestedRevision,
+            dtype: requestedDtype === undefined ? selectedActivation.dtype : requestedDtype,
+            executionTarget: requestedTarget === undefined ? selectedActivation.executionTarget : requestedTarget,
+            ...(projection == null ? {} : {assetProjectionId: projection, resourcePaths: mapping && typeof mapping === 'object' && !Array.isArray(mapping) ? {...mapping} : mapping})
+        };
+        selectedGraph(selection.family, selection.dtype);
+        if (pendingActivation && !pendingActivation.controller.signal.aborted && sameActivation(pendingActivation.selection, selection)) {
             return observeLoad(pendingActivation, operationSignal);
         }
-        if (!pendingActivation && activation && sameExecutionTarget(activation.executionTarget, target)) {
+        if (!pendingActivation && activation && sameActivation(activation.selection, selection)) {
             return awaitActivation(activation, operationSignal);
         }
         const previous = pendingActivation;
-        const request = {executionTarget: target, controller: new AbortController()};
+        const request = {selection, controller: new AbortController()};
         let precedingRelease;
         // Retain the replacement before synchronous abort/state observers run.
         // Only this model's retiring activation must finish before its successor.
         request.task = Promise.resolve().then(async function loadSelectedTarget() {
-            request.controller.signal.throwIfAborted();
-            if (precedingRelease) await precedingRelease;
-            assertOpen(request.controller.signal);
-            if (pendingActivation !== request) throw cancellation('The decision activation request was replaced.');
-            request.entry ??= activation ?? beginActivation(request.executionTarget);
-            return awaitActivation(request.entry, request.controller.signal);
+            try {
+                if (request.error) throw request.error;
+                request.controller.signal.throwIfAborted();
+                if (precedingRelease) await precedingRelease;
+                assertOpen(request.controller.signal);
+                if (pendingActivation !== request) throw cancellation('The decision activation request was replaced.');
+                request.entry ??= activation ?? beginActivation(request);
+                return await awaitActivation(request.entry, request.controller.signal);
+            } finally {
+                // A superseded request may own files without ever starting workers.
+                try { await request.retained?.release(); }
+                catch (error) {
+                    provisionalCleanupFailures.push(error);
+                    throw error;
+                } finally { request.retained = undefined; }
+            }
         });
         function settled(error) {
+            loads.delete(request.task);
             request.detach?.();
             if (pendingActivation !== request) return;
             pendingActivation = undefined;
-            if (!request.entry && !activation && !disposed && state === 'loading') {
+            if (!request.entry && !activation && !disposed && (state === 'loading' || request.error)) {
                 state = request.controller.signal.aborted ? 'unloaded' : 'error';
                 progress = null;
                 lastError = request.controller.signal.aborted ? null : error;
@@ -257,14 +331,24 @@ export function createNativeDecisionModel({
             publish();
         }
         request.task.then(function loaded() { settled(); }, function loadFailed(error) { settled(error); }).catch(reportCleanupFailure);
+        loads.add(request.task);
         pendingActivation = request;
-        selectedTarget = target;
-        const reason = cancellation('The decision execution target was replaced.');
+        selectedActivation = selection;
+        try {
+            if (selection.assetProjectionId !== undefined) {
+                if (!modelAssets) throw new CoreError({code: 'ARCANE_DECISION_ASSETS_UNAVAILABLE', message: 'Projected decisions require the Core model-assets owner.'});
+                // retain is synchronous at the model-assets public boundary.
+                // Acquire before retiring the last native use of these files.
+                request.retained = modelAssets.retain(selection.assetProjectionId);
+            }
+        } catch (error) { request.error = error; }
+        const reason = cancellation('The decision activation was replaced.');
+        if (pendingActivation !== request) request.controller.abort(reason);
         previous?.controller.abort(reason);
-        if (activation && !sameExecutionTarget(activation.executionTarget, target)) stop(activation, reason);
+        if (!request.error && !request.controller.signal.aborted && activation && !sameActivation(activation.selection, selection)) stop(activation, reason);
         precedingRelease = !activation ? releaseTask : undefined;
-        if (!activation && !precedingRelease) {
-            request.entry = beginActivation(target);
+        if (!request.error && !request.controller.signal.aborted && !activation && !precedingRelease) {
+            request.entry = beginActivation(request);
             request.detach = observeCancellation(request.entry, request.controller.signal);
         }
         publish();
@@ -316,8 +400,11 @@ export function createNativeDecisionModel({
         const pending = pendingActivation;
         pending?.controller.abort(reason);
         const release = activation ? stop(activation, reason) : releaseTask ?? Promise.resolve(current());
-        if (!pending) return release;
-        return Promise.allSettled([release, pending.task]).then(function releasedActivation(results) {
+        if (!loads.size && !provisionalCleanupFailures.length) return release;
+        return Promise.allSettled([release, ...loads]).then(function releasedActivation(results) {
+            if (provisionalCleanupFailures.length) throw new AggregateError([
+                ...(results[0].status === 'rejected' ? [results[0].reason] : []), ...provisionalCleanupFailures
+            ], 'Releasing native decision resources failed.');
             if (results[0].status === 'rejected') throw results[0].reason;
             return current();
         });
@@ -332,7 +419,10 @@ export function createNativeDecisionModel({
         let release;
         disposal = Promise.resolve().then(async function disposeNativeModel() {
             try {
-                const results = await Promise.allSettled([release, pending?.task]);
+                const results = await Promise.allSettled([release, ...loads]);
+                if (provisionalCleanupFailures.length) throw new AggregateError([
+                    ...(results[0].status === 'rejected' ? [results[0].reason] : []), ...provisionalCleanupFailures
+                ], 'Releasing native decision resources failed.');
                 if (results[0].status === 'rejected') throw results[0].reason;
             }
             finally { state = 'disposed'; publish(); events.dispose(); }