arcane-os 0.83.0 → 0.84.0

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

@@ -1,11 +1,13 @@
 import {parentPort,workerData} from 'node:worker_threads';
 import {pathToFileURL} from 'node:url';
 import Is from 'strong-type';
+import {encodeTensorMap,encodeTensorFetches} from '../../browser-runtime/ai/onnx-tensors.mjs';
 
 const is=new Is(false);
 const imported=await import(pathToFileURL(workerData.modulePath).href);
 const ort=imported.default??imported;
 let session;
+let sessionExecution;
 
 function describeError(error){
     if(!(error instanceof Error))return {name:'Error',message:String(error),cause:error};
@@ -27,6 +29,7 @@ async function createSession(request) {
         resolution: 'automatic',
         reason: selectProviders ? 'engine-default-required' : 'caller-session-options',
         ...request.targetResolution,
+        deviceInventory: request.deviceInventory ?? null,
         configuredTarget: null,
         observedTarget: null,
         supportedBackends: [],
@@ -225,28 +228,35 @@ function tensorMap(records,inputs=false){
 }
 
 async function handleRequest(request){
+    let runStage;
+    let feeds;
+    let fetches;
     try{
         let result;
         if(request.operation==='load'){
-            const execution = await createSession(request);
+            sessionExecution = await createSession(request);
             result={
                 inputNames:session.inputNames,
                 outputNames:session.outputNames,
                 inputMetadata:session.inputMetadata,
                 outputMetadata:session.outputMetadata
             };
-            if (execution) result.execution = execution;
+            if (sessionExecution) result.execution = sessionExecution;
         }else if(request.operation==='run'){
-            const feeds=tensorMap(request.feeds,true);
-            const fetches=request.fetches===undefined||request.fetches===null||is.array(request.fetches)
+            runStage='feed-conversion';
+            feeds=tensorMap(request.feeds,true);
+            runStage='fetch-conversion';
+            fetches=request.fetches===undefined||request.fetches===null||is.array(request.fetches)
                 ?request.fetches:tensorMap(request.fetches);
             // ORT treats an empty fetch map as its options overload and would
             // ignore the third argument. Both forms select every output.
             const allOutputs=fetches===undefined
                 ||(fetches!==null&&!is.array(fetches)&&Object.keys(fetches).length===0);
+            runStage='session.run';
             const outputs=allOutputs
                 ?await session.run(feeds,request.runOptions)
                 :await session.run(feeds,fetches,request.runOptions);
+            runStage='output-conversion';
             result=Object.fromEntries(Object.entries(outputs).map(function tensorRecord([name,tensor]){
                 return [name,{type:tensor.type,data:tensor.data,dims:tensor.dims}];
             }));
@@ -258,9 +268,33 @@ async function handleRequest(request){
         }
         // Structured cloning retains typed tensors and BigInt without taking
         // ownership of the caller's buffers or converting their contents.
+        if(request.operation==='run')runStage='result-delivery';
         parentPort.postMessage({requestId:request.requestId,operation:request.operation,result});
     }catch(error){
-        parentPort.postMessage({requestId:request.requestId,operation:request.operation,error:describeError(error)});
+        const record=describeError(error);
+        if(request.operation==='run'){
+            const diagnostic={
+                sessionId:workerData.sessionId,requestId:request.requestId,stage:runStage,
+                model:workerData.model,runtimeModulePath:workerData.modulePath,
+                execution:sessionExecution??null,runOptions:request.runOptions,
+                feedsSource:feeds===undefined?'request':'converted',
+                fetchesSource:runStage==='feed-conversion'||runStage==='fetch-conversion'?'request':'converted'
+            };
+            record.onnxRun=diagnostic;
+            try{
+                diagnostic.inputNames=session?.inputNames??null;
+                diagnostic.inputMetadata=session?.inputMetadata??null;
+                diagnostic.outputNames=session?.outputNames??null;
+                diagnostic.outputMetadata=session?.outputMetadata??null;
+                // Copy complete tensors only after failure. The same codec used
+                // by Core tensor transport preserves BigInt and typed values.
+                diagnostic.feeds=encodeTensorMap(feeds===undefined?request.feeds:feeds);
+                diagnostic.fetches=encodeTensorFetches(diagnostic.fetchesSource==='request'?request.fetches:fetches);
+            }catch(diagnosticError){
+                diagnostic.diagnosticError=describeError(diagnosticError);
+            }
+        }
+        parentPort.postMessage({requestId:request.requestId,operation:request.operation,error:record});
     }finally{
         if(request.operation==='unload')parentPort.close();
     }

package/src/local-ai/onnx.mjs

@@ -216,7 +216,7 @@ export function createONNXRuntime({modulePath,onEvent,signal,executionDevices:su
         operationSignal.throwIfAborted();
         if (entry.stopping || entry.exited || entry.active !== operation) return;
         operation.payload = {...operation.payload, targetResolution, deviceInventory};
-        entry.state.execution = {...entry.state.execution, ...targetResolution};
+        entry.state.execution = {...entry.state.execution, ...targetResolution, deviceInventory: deviceInventory ?? null};
         publish(entry);
         postOperation(entry, operation);
     }
@@ -348,7 +348,7 @@ export function createONNXRuntime({modulePath,onEvent,signal,executionDevices:su
             state:{id,model,state:'loading',loaded:false,error:null,inputNames:[],outputNames:[],inputMetadata:[],outputMetadata:[],
                 execution: {requestedTarget: executionTarget ?? null, resolvedDevice: null,
                     resolution: executionTarget === undefined || executionTarget === null ? 'automatic' : null,
-                    reason: 'session-loading', configuredTarget: null, observedTarget: null}},
+                    reason: 'session-loading', configuredTarget: null, observedTarget: null, deviceInventory: null}},
             controller: new AbortController(), preparation: null,
             worker:null,active:null,queue:[],stopping:false,exited:false,stopTask:null,terminalError:null,releaseError:null,terminationRequested:false,outputTasks:[]
         };
@@ -356,7 +356,7 @@ export function createONNXRuntime({modulePath,onEvent,signal,executionDevices:su
         sessions.set(id,entry);
         try{
             entry.worker=new Worker(new URL('./onnx-worker.mjs',import.meta.url),{
-                workerData:{modulePath},stdout:true,stderr:true
+                workerData:{modulePath,sessionId:id,model},stdout:true,stderr:true
             });
             entry.outputTasks.push(
                 captureOutput(entry,entry.worker.stdout,'local-ai.onnx.stdout'),

package/src/native/portable-layout.mjs

@@ -203,7 +203,7 @@ export function coreEntrySource(application, version, services, {localAI, runtim
         "import path from 'node:path';",
         "import {isSea} from 'node:sea';",
         ...(launchDefaults === undefined ? [] : ["import {mkdir} from 'node:fs/promises';"]),
-        "import {readCoreLaunchContext, startCoreHost, runSharedCoreHost, startSharedCoreBridge} from 'arcane-os/core/host';",
+        "import {readCoreLaunchContext, startCoreHost, startCoreListener, runSharedCoreHost, startSharedCoreBridge} from 'arcane-os/core/host';",
         '',
         ...(localAI === undefined ? [] : [
             '// Bundled runtime paths are artifact-root-relative POSIX paths.',
@@ -249,6 +249,10 @@ export function coreEntrySource(application, version, services, {localAI, runtim
             : `    ...await readCoreLaunchContext({appId: ${JSON.stringify(application.id)}, defaults: JSON.parse(${JSON.stringify(JSON.stringify(launchDefaults))})})`,
         '};',
         '',
+        'if (context.coreListener !== undefined && context.sharedHost !== undefined) {',
+        "    throw new TypeError('coreListener attaches to the window-owned Core; sharedHost selects its separate owning host.');",
+        '}',
+        '',
         ...(launchDefaults === undefined ? [] : [
             '// The shared endpoint and diagnostic log require their selected state directory.',
             'if (context.sharedHost !== undefined) await mkdir(context.stateRoot, {recursive: true});',
@@ -284,10 +288,29 @@ export function coreEntrySource(application, version, services, {localAI, runtim
         `const application = JSON.parse(${JSON.stringify(JSON.stringify(application))});`,
         `const version = ${JSON.stringify(version)};`,
         'let host;',
+        'let listener;',
         'if (context.sharedHost === undefined) {',
         '    const services = [];',
         '    await createServices(function register(service) { services.push(service); });',
         '    host = startCoreHost({application, version, services});',
+        '    if (context.coreListener !== undefined) {',
+        "        process.on('SIGINT', closeCore);",
+        "        process.on('SIGTERM', closeCore);",
+        '        try {',
+        '            listener = await startCoreListener({runtime: host.runtime, endpoint: context.coreListener?.endpoint});',
+        '            listener.closed.catch(function listenerFailed() { process.exitCode = 1; });',
+        '        } catch (error) {',
+        '            try {',
+        '                await host.close();',
+        '            } catch (closeError) {',
+        "                throw new AggregateError([error, closeError], 'Core listener startup and host drain failed.');",
+        '            }',
+        '            throw error;',
+        '        } finally {',
+        "            process.off('SIGINT', closeCore);",
+        "            process.off('SIGTERM', closeCore);",
+        '        }',
+        '    }',
         "} else if (process.argv.includes('--arcane-core-headless')) {",
         '    host = await runSharedCoreHost({',
         '        endpoint: context.sharedHost.endpoint, application, version,',
@@ -319,6 +342,12 @@ export function coreEntrySource(application, version, services, {localAI, runtim
         "    console.error('Arcane Core host failed:', error);",
         '    process.exitCode = 1;',
         '} finally {',
+        '    try {',
+        '        await listener?.close();',
+        '    } catch {',
+        '        // The listener reports its complete failure through onError.',
+        '        process.exitCode = 1;',
+        '    }',
         "    process.off('SIGINT', closeCore);",
         "    process.off('SIGTERM', closeCore);",
         '}',