arcane-os 0.66.0 → 0.68.0

package/src/git-identity.mjs

@@ -3,6 +3,7 @@ import Is from 'strong-type';
 import {ArcaneError, throwIfAborted} from './errors.mjs';
 import {runProcess} from './process.mjs';
 import {createEventQueue} from './event-queue.mjs';
+import {readGitText} from './repository.mjs';
 
 const is = new Is(false);
 
@@ -16,67 +17,30 @@ export async function readGitIdentity({directory, signal, onEvent, run = runProc
         const args = ['config'];
         if (scope !== 'effective') args.push(`--${scope}`);
         args.push('--includes', '--null', '--get-regexp', '^(user[.](name|email)|github[.]user)$');
-        const chunks = [];
-        try {
-            const result = await run('git', args, {
-                cwd, signal, onEvent: events.send, allowNonzero: true,
-                outputEncoding: {stdout: null},
-                captureOutput: {stdout: false},
-                emitOutputEvents: {stdout: false},
-                // Git configuration may contain non-UTF-8 values. Keep its raw
-                // output until close rather than silently replacing characters.
-                onOutput: function observeOutput({stream, chunk}) {
-                    if (stream === 'stdout') chunks.push(chunk);
-                }
-            });
-            try { throwIfAborted(signal); }
-            catch (error) { error.details = result; throw error; }
-            const identity = {name: null, email: null, githubUser: null};
-            if (result.code === 1) return identity;
-            if (result.code !== 0) {
-                throw new ArcaneError('ARCANE_OPERATION_FAILED',
-                    `Git ${scope} identity lookup exited with code ${String(result.code)}.`, {details: result});
-            }
-            let output;
-            try { output = new TextDecoder('utf-8', {fatal: true, ignoreBOM: true}).decode(Buffer.concat(chunks)); }
-            catch (cause) {
-                throw new ArcaneError('ARCANE_GIT_IDENTITY_NOT_TEXT',
-                    `Git ${scope} identity configuration cannot be represented as UTF-8 text.`, {cause, details: result});
-            }
-            const fields = {'user.name': 'name', 'user.email': 'email', 'github.user': 'githubUser'};
-            // Git's NUL record framing preserves complete values, including newlines
-            // and empty strings. The last occurrence is the effective scalar value.
-            for (const record of output.split('\0')) {
-                if (record === '') continue;
-                const separator = record.indexOf('\n');
-                const key = separator === -1 ? record : record.slice(0, separator);
-                if (Object.hasOwn(fields, key)) {
-                    identity[fields[key]] = separator === -1 ? '' : record.slice(separator + 1);
-                }
-            }
-            return identity;
-        } catch (error) {
-            // Keep the process error and its native details intact. Raw stdout
-            // belongs to this reader because the process owner did not decode it.
-            const rawStdout = Buffer.concat(chunks);
-            let attached = false;
-            let attachmentError;
-            try {
-                if (error !== null && (is.object(error) || is.function(error)) && !('rawStdout' in error)) {
-                    Object.defineProperty(error, 'rawStdout', {
-                        value: rawStdout, writable: true, enumerable: true, configurable: true
-                    });
-                    attached = true;
-                }
-            } catch (cause) { attachmentError = cause; }
-            if (attached) throw error;
-            const failure = new ArcaneError(error?.code ?? 'ARCANE_OPERATION_FAILED',
-                error instanceof Error ? error.message : String(error),
-                {cause: error, details: error?.details, exitCode: error?.exitCode});
+        const {result, output, rawStdout} = await readGitText(args, {
+            cwd, signal, onEvent: events.send, run, allowNonzero: true,
+            notTextCode: 'ARCANE_GIT_IDENTITY_NOT_TEXT', label: `Git ${scope} identity configuration`
+        });
+        const identity = {name: null, email: null, githubUser: null};
+        if (result.code === 1) return identity;
+        if (result.code !== 0) {
+            const failure = new ArcaneError('ARCANE_OPERATION_FAILED',
+                `Git ${scope} identity lookup exited with code ${String(result.code)}.`, {details: result});
             failure.rawStdout = rawStdout;
-            if (attachmentError) failure.attachmentError = attachmentError;
             throw failure;
         }
+        const fields = {'user.name': 'name', 'user.email': 'email', 'github.user': 'githubUser'};
+        // Git's NUL record framing preserves complete values, including newlines
+        // and empty strings. The last occurrence is the effective scalar value.
+        for (const record of output.split('\0')) {
+            if (record === '') continue;
+            const separator = record.indexOf('\n');
+            const key = separator === -1 ? record : record.slice(0, separator);
+            if (Object.hasOwn(fields, key)) {
+                identity[fields[key]] = separator === -1 ? '' : record.slice(separator + 1);
+            }
+        }
+        return identity;
     }
 
     const scopes = cwd === undefined ? ['global'] : ['global', 'local', 'effective'];

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

@@ -0,0 +1,31 @@
+import {readFile} from 'node:fs/promises';
+import {parentPort, workerData} from 'node:worker_threads';
+import {Tokenizer} from '@huggingface/tokenizers';
+import {createDecisionInputs, encodeDecisionRows} from '../../browser-runtime/ai/decision-runtime.mjs';
+import {serializeCoreError} from '../../browser-runtime/core/contracts.mjs';
+
+// Parsing and tokenization run here, not on Core's request/rendering thread.
+try {
+    const [tokenizerText, configurationText] = await Promise.all([
+        readFile(workerData.tokenizerPath, 'utf8'),
+        readFile(workerData.tokenizerConfigPath, 'utf8')
+    ]);
+    const tokenizer = new Tokenizer(JSON.parse(tokenizerText), JSON.parse(configurationText));
+    const interfaceAdapter = {
+        encode(text, options) { return tokenizer.encode(text, options).ids; },
+        convert_tokens_to_ids(token) { return tokenizer.token_to_id(token); }
+    };
+    parentPort.on('message', function encodeRequest({id, rows}) {
+        try {
+            const {encoded, pad} = encodeDecisionRows(interfaceAdapter, rows, 'laya');
+            const inputs = createDecisionInputs(encoded, pad);
+            parentPort.postMessage({id, result: inputs});
+        } catch (error) {
+            parentPort.postMessage({id, error: serializeCoreError(error)});
+        }
+    });
+    parentPort.postMessage({id: 0, result: {ready: true}});
+} catch (error) {
+    parentPort.postMessage({id: 0, error: serializeCoreError(error)});
+    parentPort.close();
+}

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

@@ -0,0 +1,109 @@
+import {Worker} from 'node:worker_threads';
+import {CoreError} from '../../browser-runtime/core/contracts.mjs';
+
+function cancelled() {
+    return new CoreError({name: 'AbortError', code: 'ARCANE_AI_REQUEST_ABORTED', message: 'Decision tokenization was cancelled.'});
+}
+
+/** One tokenizer worker owned by one native model activation. */
+export function createDecisionTokenizer({tokenizerPath, tokenizerConfigPath, signal, onError}) {
+    signal?.throwIfAborted();
+    const pending = new Map();
+    let nextId = 0;
+    let closing;
+    let terminalError;
+    let exited = false;
+    const worker = new Worker(new URL('./decision-tokenizer-worker.mjs', import.meta.url), {
+        workerData: {tokenizerPath, tokenizerConfigPath}
+    });
+    let resolveExit;
+    const exit = new Promise(function tokenizerExit(resolve) { resolveExit = resolve; });
+
+    function rejectPending(error) {
+        terminalError ??= error;
+        for (const operation of pending.values()) operation.reject(error);
+        pending.clear();
+    }
+
+    function operation(id) {
+        return new Promise(function retainOperation(resolve, reject) {
+            pending.set(id, {resolve, reject});
+        });
+    }
+
+    const ready = operation(0);
+    // The native owner observes ready together with ONNX load. Retain an error
+    // handler immediately when the other owner is still starting.
+    ready.catch(function observeTokenizerLoadFailure() {});
+    worker.on('message', function tokenizerMessage(message) {
+        const request = pending.get(message.id);
+        if (!request) return;
+        pending.delete(message.id);
+        if (Object.hasOwn(message, 'error')) {
+            const error = new CoreError(message.error);
+            request.reject(error);
+            if (message.id === 0) failed(error);
+        }
+        else request.resolve(message.result);
+    });
+    worker.on('error', failed);
+    worker.on('messageerror', failed);
+    worker.once('exit', function tokenizerExited(code) {
+        exited = true;
+        signal?.removeEventListener('abort', abort);
+        const error = terminalError ?? new CoreError({
+            code: 'ARCANE_DECISION_TOKENIZER_CLOSED',
+            message: `The decision tokenizer worker exited with code ${code}.`
+        });
+        if (!closing) failed(error);
+        else rejectPending(error);
+        resolveExit(code);
+    });
+
+    function failed(error) {
+        const firstFailure = !terminalError && !closing;
+        rejectPending(error);
+        close(error).catch(function reportTokenizerFailure(value) { console.error(value); });
+        if (firstFailure) onError?.(error);
+    }
+
+    function close(reason = cancelled()) {
+        if (closing) return closing;
+        rejectPending(reason);
+        signal?.removeEventListener('abort', abort);
+        closing = Promise.resolve().then(async function releaseTokenizer() {
+            let terminationError;
+            try { if (!exited) await worker.terminate(); }
+            catch (error) {
+                terminationError = error;
+                console.error('Terminating the decision tokenizer failed.', error);
+            }
+            // A rejected termination request is not evidence that the worker
+            // has stopped reading its files. Retain ownership until real exit.
+            await exit;
+            if (terminationError) throw terminationError;
+        });
+        return closing;
+    }
+
+    function abort() {
+        close(signal.reason).catch(function reportTokenizerCloseFailure(error) { console.error(error); });
+    }
+    signal?.addEventListener('abort', abort, {once: true});
+    if (signal?.aborted) abort();
+
+    async function encode(rows) {
+        await ready;
+        if (terminalError || closing || exited) throw terminalError ?? cancelled();
+        const id = ++nextId;
+        const result = operation(id);
+        try { worker.postMessage({id, rows}); }
+        catch (error) {
+            pending.get(id).reject(error);
+            pending.delete(id);
+        }
+        return result;
+    }
+
+    return {ready, encode, close, get exited() { return exited; }};
+}

package/src/local-ai/decisions.mjs

@@ -0,0 +1,273 @@
+import {randomUUID} from 'node:crypto';
+import {createArcaneEventSource} from '../event-manager.mjs';
+import {CoreError, serializeCoreError} from '../../browser-runtime/core/contracts.mjs';
+import {decodeDecisionOutputs} from '../../browser-runtime/ai/decision-runtime.mjs';
+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 cancellation(message) {
+    return new CoreError({name: 'AbortError', code: 'ARCANE_AI_REQUEST_ABORTED', message});
+}
+
+function reportCleanupFailure(error) { console.error('Native decision cleanup failed.', error); }
+
+/**
+ * One explicitly activated Laya FP32 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',
+    dtype = 'fp32', sessionOptions, executionPreference = 'gpu', signal
+} = {}) {
+    if (dtype !== 'fp32') throw new TypeError('This native Laya graph selection requires dtype fp32.');
+    const owner = {};
+    const events = createArcaneEventSource(owner, {source: 'native-decisions', eventTypes: [STATE_EVENT]});
+    let activation;
+    let releaseTask;
+    let disposal;
+    let disposed = false;
+    let state = 'unloaded';
+    let progress = null;
+    let lastError = null;
+    let execution = null;
+
+    function current() {
+        return {
+            family: 'laya', model, revision, dtype, state,
+            loaded: state === 'ready', busy: state === 'loading' || Boolean(activation?.jobs.size),
+            activeRequests: activation?.jobs.size ?? 0, progress,
+            error: lastError ? serializeCoreError(lastError) : null,
+            execution
+        };
+    }
+
+    function publish() { events.dispatch(STATE_EVENT, current()); }
+
+    function subscribe(listener, {emitCurrent = true, signal: subscriptionSignal} = {}) {
+        const unsubscribe = events.on(STATE_EVENT, function changed(event) { listener(event.detail); }, {signal: subscriptionSignal});
+        try { if (emitCurrent && !subscriptionSignal?.aborted) listener(current()); }
+        catch (error) { unsubscribe(); throw error; }
+        return unsubscribe;
+    }
+
+    function assertOpen(operationSignal) {
+        if (disposed) throw new CoreError({code: 'ARCANE_AI_DISPOSED', message: 'The native decision model is disposed.'});
+        signal?.throwIfAborted();
+        operationSignal?.throwIfAborted();
+    }
+
+    function updateProgress(entry, value) {
+        if (activation !== entry || entry.controller.signal.aborted) return;
+        progress = value;
+        publish();
+    }
+
+    function stop(entry, reason, terminalState = 'unloaded') {
+        if (entry.release) return entry.release;
+        if (activation === entry) {
+            activation = undefined;
+            state = disposed ? 'disposing' : 'unloading';
+            progress = null;
+            lastError = terminalState === 'error' ? reason : null;
+        }
+        // Establish cleanup ownership before abort observers or state listeners
+        // can request another unload or dispose.
+        entry.release = Promise.resolve().then(async function releaseActivation() {
+            const failures = [];
+            await Promise.allSettled([entry.loading, ...entry.jobs]);
+            entry.unsubscribe?.();
+            const ownedSession = onnx.current().sessions.some(function owned(value) { return value.id === entry.id; });
+            const engineRelease = entry.onnxLoadStarted && ownedSession
+                ? onnx.unload({id: entry.id})
+                : Promise.resolve();
+            const releases = await Promise.allSettled([engineRelease, entry.tokenizer?.close(reason)]);
+            for (const result of releases) if (result.status === 'rejected') failures.push(result.reason);
+            // unload joins actual native worker exit, even when load/run already
+            // rejected. Working files cannot be retired at promise rejection.
+            const exited = onnx.current().sessions.find(function owned(value) { return value.id === entry.id; })?.exited;
+            const engineStopped = releases[0].status === 'fulfilled' || exited === true;
+            const tokenizerStopped = !entry.tokenizer || entry.tokenizer.exited;
+            if (engineStopped && tokenizerStopped) {
+                try { await entry.retained?.release(); } catch (error) { failures.push(error); }
+                if (entry.prepared) {
+                    try { await modelAssets.release(entry.id); } catch (error) { failures.push(error); }
+                }
+            }
+            const cleanupError = failures.length ? new AggregateError(failures, 'Releasing native decision resources failed.') : null;
+            if (!activation) {
+                state = disposed ? 'disposed' : cleanupError ? 'error' : terminalState;
+                progress = null;
+                execution = null;
+                if (cleanupError) lastError = cleanupError;
+                publish();
+            }
+            if (cleanupError) throw cleanupError;
+            return current();
+        });
+        releaseTask = entry.release;
+        entry.controller.abort(reason);
+        entry.tokenizer?.close(reason).catch(reportCleanupFailure);
+        publish();
+        entry.release.catch(reportCleanupFailure);
+        return entry.release;
+    }
+
+    function observeCancellation(entry, operationSignal) {
+        function abort() { stop(entry, operationSignal.reason).catch(reportCleanupFailure); }
+        operationSignal?.addEventListener('abort', abort, {once: true});
+        if (operationSignal?.aborted) abort();
+        return function detachAbort() { operationSignal?.removeEventListener('abort', abort); };
+    }
+
+    async function prepareFiles(entry) {
+        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 projection = await modelAssets.prepare({
+            id: entry.id, workingDirectory,
+            members: LAYA_FILES.map(function selectFile(path) { return {path, url: new URL(path, base).href}; }),
+            signal: entry.controller.signal,
+            onProgress(value) { updateProgress(entry, value); }
+        });
+        entry.prepared = true;
+        entry.controller.signal.throwIfAborted();
+        entry.retained = modelAssets.retain(entry.id);
+        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']};
+    }
+
+    function beginActivation() {
+        const entry = {id: randomUUID(), controller: new AbortController(), jobs: new Set(), prepared: false, onnxLoadStarted: false};
+        activation = entry;
+        state = 'loading';
+        progress = {phase: 'preparing-model'};
+        lastError = null;
+        execution = null;
+        entry.loading = Promise.resolve().then(async function activateNativeModel() {
+            const files = await prepareFiles(entry);
+            entry.controller.signal.throwIfAborted();
+            updateProgress(entry, {phase: 'loading-model'});
+            entry.tokenizer = createDecisionTokenizer({
+                tokenizerPath: files.tokenizer, tokenizerConfigPath: files.tokenizerConfig,
+                signal: entry.controller.signal,
+                onError(error) {
+                    if (activation === entry) stop(entry, error, 'error').catch(reportCleanupFailure);
+                }
+            });
+            entry.onnxLoadStarted = true;
+            const loaded = onnx.load({
+                id: entry.id, model: files.model, sessionOptions, executionPreference,
+                signal: entry.controller.signal
+            });
+            const results = await Promise.allSettled([loaded, entry.tokenizer.ready]);
+            const failures = results.filter(function failed(result) { return result.status === 'rejected'; })
+                .map(function reason(result) { return result.reason; });
+            if (failures.length) throw failures.length === 1 ? failures[0] : new AggregateError(failures, 'Loading the native decision model failed.');
+            entry.controller.signal.throwIfAborted();
+            if (activation !== entry) throw cancellation('The decision activation was replaced.');
+            execution = results[0].value;
+            state = 'ready';
+            progress = {phase: 'ready'};
+            entry.unsubscribe = onnx.subscribe(function nativeStateChanged(snapshot) {
+                if (activation !== entry || entry.controller.signal.aborted) return;
+                const selected = snapshot.sessions.find(function sameSession(value) { return value.id === entry.id; });
+                // A failed run may leave ONNX loaded and its queued runs usable.
+                // Stopping revokes readiness before physical residency ends.
+                if (snapshot.closed || selected?.stopping || !selected?.loaded || ['unloading', 'unloaded'].includes(selected.state)) {
+                    const error = selected?.error ? new CoreError(selected.error) : cancellation('The native ONNX session was retired.');
+                    stop(entry, error, selected?.error ? 'error' : 'unloaded').catch(reportCleanupFailure);
+                }
+            });
+            publish();
+            return current();
+        });
+        entry.loading.catch(function activationFailed(error) {
+            if (activation === entry) stop(entry, error, entry.controller.signal.aborted ? 'unloaded' : 'error').catch(reportCleanupFailure);
+        });
+        publish();
+        return entry;
+    }
+
+    async function load({signal: operationSignal} = {}) {
+        assertOpen(operationSignal);
+        if (releaseTask && !activation) await releaseTask;
+        assertOpen(operationSignal);
+        const entry = activation ?? beginActivation();
+        const detach = observeCancellation(entry, operationSignal);
+        try {
+            await entry.loading;
+            entry.controller.signal.throwIfAborted();
+            return current();
+        } finally { detach(); }
+    }
+
+    async function evaluate(rows, {signal: operationSignal, runOptions} = {}) {
+        assertOpen(operationSignal);
+        const entry = activation;
+        if (!entry) throw new CoreError({code: 'ARCANE_DECISION_NOT_LOADED', message: 'Load the selected native decision model before evaluating.'});
+        const detach = observeCancellation(entry, operationSignal);
+        const task = Promise.resolve().then(async function evaluateCompleteRows() {
+            await entry.loading;
+            entry.controller.signal.throwIfAborted();
+            if (rows.length === 0) return {decisions: [], outputs: {}};
+            updateProgress(entry, {phase: 'tokenizing'});
+            const feeds = await entry.tokenizer.encode(rows);
+            entry.controller.signal.throwIfAborted();
+            updateProgress(entry, {phase: 'evaluating'});
+            const outputs = await onnx.run({id: entry.id, feeds, runOptions, signal: entry.controller.signal});
+            entry.controller.signal.throwIfAborted();
+            return decodeDecisionOutputs(rows, outputs);
+        });
+        entry.jobs.add(task);
+        publish();
+        let result;
+        try { result = await task; }
+        catch (error) {
+            if (activation === entry && !entry.controller.signal.aborted) {
+                lastError = error;
+                publish();
+            }
+            throw error;
+        } finally {
+            detach();
+            entry.jobs.delete(task);
+            if (activation === entry) {
+                progress = {phase: entry.jobs.size ? 'evaluating' : 'ready'};
+                publish();
+            }
+        }
+        entry.controller.signal.throwIfAborted();
+        if (activation !== entry) throw cancellation('The decision result belongs to a retired activation.');
+        return result;
+    }
+
+    function unload() {
+        return activation ? stop(activation, cancellation('The native decision model was unloaded.'))
+            : releaseTask ?? Promise.resolve(current());
+    }
+
+    function dispose() {
+        if (disposal) return disposal;
+        disposed = true;
+        signal?.removeEventListener('abort', lifetimeAborted);
+        let release;
+        disposal = Promise.resolve().then(async function disposeNativeModel() {
+            try { await release; }
+            finally { state = 'disposed'; publish(); events.dispose(); }
+            return current();
+        });
+        release = activation ? stop(activation, cancellation('The native decision model was disposed.')) : releaseTask;
+        if (!activation && !release) { state = 'disposed'; publish(); }
+        return disposal;
+    }
+
+    function lifetimeAborted() { dispose().catch(reportCleanupFailure); }
+    signal?.addEventListener('abort', lifetimeAborted, {once: true});
+    if (signal?.aborted) lifetimeAborted();
+    return {load, current, status: current, subscribe, evaluate, classify: evaluate, unload, dispose};
+}

package/src/local-ai/dev.mjs

@@ -40,10 +40,16 @@ export function createDevelopmentLocalAI({
     let modelAssets;
     let imageService;
     let speechService;
-    if (selected.runtimes.some(function selectedImageRuntime(requirement) {
+    const imageSelected = selected.runtimes.some(function selectedImageRuntime(requirement) {
         return requirement.id === 'stable-diffusion.cpp';
+    });
+    if (imageSelected || selected.runtimes.some(function selectedONNXRuntime(requirement) {
+        return requirement.id === 'onnx';
     })) {
         modelAssets = createModelAssetService({appRoot});
+        definitions.push(modelAssets);
+    }
+    if (imageSelected) {
         imageService = createLocalImageService(
             selected,
             {
@@ -56,7 +62,7 @@ export function createDevelopmentLocalAI({
                 }
             }
         );
-        definitions.push(modelAssets, imageService);
+        definitions.push(imageService);
     }
     const whisperRequirement = selected.runtimes.find(function selectedWhisperRuntime(requirement) {
         return requirement.id === 'whisper.cpp';

package/src/local-ai/onnx-worker.mjs

@@ -15,6 +15,71 @@ function describeError(error){
     return result;
 }
 
+async function createSession(request) {
+    const supplied = request.sessionOptions;
+    const selectProviders = supplied === undefined
+        || (supplied !== null && is.object(supplied) && supplied.executionProviders === undefined);
+    const options = selectProviders ? {...supplied, executionProviders: ['cpu']} : supplied;
+    if (request.executionPreference !== 'gpu' || !selectProviders) {
+        session = await ort.InferenceSession.create(request.model, options);
+        return undefined;
+    }
+
+    const execution = {
+        preference: 'gpu',
+        supportedBackends: [],
+        selectedProviders: [],
+        attempts: [],
+        fallback: false,
+        discoveryError: null
+    };
+    const failures = [];
+    try {
+        execution.supportedBackends = ort.listSupportedBackends();
+    } catch (error) {
+        execution.discoveryError = describeError(error);
+        failures.push(error);
+    }
+    // The inventory advertises compiled support. `bundled` describes packaging,
+    // not whether an installed provider library or physical device can load.
+    const candidates = ['cuda', 'tensorrt', 'dml', 'coreml', 'webgpu'].filter(
+        function advertisedProvider(name) {
+            return execution.supportedBackends.some(
+                function supportedBackend(backend) { return backend.name === name; }
+            );
+        }
+    );
+    candidates.push('cpu');
+    for (const provider of candidates) {
+        const executionProviders = provider === 'cpu' ? ['cpu'] : [provider, 'cpu'];
+        const selectedOptions = {...supplied, executionProviders};
+        if (provider === 'dml') {
+            // DirectML requires these session settings. Explicit caller values
+            // remain exact and can produce the native provider's own error.
+            if (selectedOptions.enableMemPattern === undefined) selectedOptions.enableMemPattern = false;
+            if (selectedOptions.executionMode === undefined) selectedOptions.executionMode = 'sequential';
+        }
+        const attempt = {executionProviders, status: 'loading', error: null};
+        execution.attempts.push(attempt);
+        execution.fallback = provider === 'cpu';
+        try {
+            session = await ort.InferenceSession.create(request.model, selectedOptions);
+            attempt.status = 'configured';
+            execution.selectedProviders = executionProviders;
+            // Successful creation proves this session configuration was accepted.
+            // ORT can assign graph nodes to CPU; it does not prove GPU execution.
+            return execution;
+        } catch (error) {
+            attempt.status = 'failed';
+            attempt.error = describeError(error);
+            failures.push(error);
+        }
+    }
+    const error = new AggregateError(failures, 'ONNX accelerator session creation and CPU fallback failed.');
+    error.execution = execution;
+    throw error;
+}
+
 function tensorMap(records,inputs=false){
     return Object.fromEntries(Object.entries(records).map(function createTensor([name,record]){
         // ORT Node 1.30.0 supplies string feeds to FillStringTensor through
@@ -33,19 +98,14 @@ async function handleRequest(request){
     try{
         let result;
         if(request.operation==='load'){
-            const supplied=request.sessionOptions;
-            const options=supplied===undefined
-                ?{executionProviders:['cpu']}
-                :supplied!==null&&is.object(supplied)&&supplied.executionProviders===undefined
-                    ?{...supplied,executionProviders:['cpu']}
-                    :supplied;
-            session=await ort.InferenceSession.create(request.model,options);
+            const execution = await createSession(request);
             result={
                 inputNames:session.inputNames,
                 outputNames:session.outputNames,
                 inputMetadata:session.inputMetadata,
                 outputMetadata:session.outputMetadata
             };
+            if (execution) result.execution = execution;
         }else if(request.operation==='run'){
             const feeds=tensorMap(request.feeds,true);
             const fetches=request.fetches===undefined||request.fetches===null||is.array(request.fetches)