arcane-os 0.83.0 → 0.83.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.83.1
+
+- Preserve complete failure-only native ONNX diagnostics in `error.onnxRun`,
+  including session and request identity, failure stage, graph metadata,
+  provider execution, run options and encoded feed/fetch tensors. Existing
+  rejected evaluations and retained decision error state carry the record.
+- Retain the device inventory already consumed by automatic physical selection
+  without another hardware query. Successful inference performs no diagnostic
+  tensor encoding; original errors and diagnostic-construction failures remain
+  observable without changing model inputs, device selection or cancellation.
+- These diagnostics expose evidence for a failed operation; they do not claim
+  to correct an application inference failure. No dependency changes.
+
 ## 0.83.0
 
 - Add optional `shadowPath` to native app-control inspection and actions. Follow

package/README.md

@@ -25,7 +25,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.83.0` SDK contract. Development applications declare
+This checkout defines the `0.83.1` 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/docs/reference/local-ai.md

@@ -420,9 +420,13 @@ unchanged, including on the final CPU attempt.
 Every loaded session includes an `execution` record in its ordinary state
 events: `preference`, `requestedTarget`, `resolvedDevice`, `resolution`,
 `reason`, `configuredTarget`, `observedTarget`, complete `supportedBackends`,
-`selectedProviders`, ordered `attempts` with their full errors, `fallback`, and
-`discoveryError`. Each attempt records provider names in `executionProviders`,
-its requested `configuredTarget`, `status` (`configured` or `failed`), and
+`selectedProviders`, ordered `attempts` with their full errors, `fallback`,
+`discoveryError`, and `deviceInventory`. The inventory retains the complete
+`{platform,state,devices,issues}` already obtained for that load's automatic
+physical selection. It is `null` when that load did not gather an inventory;
+retaining it performs no additional discovery. Each attempt records provider
+names in `executionProviders`, its requested `configuredTarget`, `status`
+(`configured` or `failed`), and
 `error`. The accepted top-level `configuredTarget` is
 `{source,executionProviders}`; it retains the complete provider options,
 including native numeric `deviceId` values. Its `source` is `cpu-default`,
@@ -531,6 +535,23 @@ String input containing U+0000 reports an incompatibility at the native tensor
 boundary: the Node binding uses null-terminated strings and cannot preserve
 that input completely. The SDK does not alter the supplied string.
 
+A failed run preserves the original error, stack, cause and additional fields,
+and adds the developer diagnostic `error.onnxRun`. It contains `sessionId`,
+`requestId`, `stage`, the original `model` path and `runtimeModulePath`, the
+session's complete `execution` record, `runOptions`, and input/output names and
+metadata. `stage` distinguishes `feed-conversion`, `fetch-conversion`,
+`session.run`, `output-conversion`, and `result-delivery`. `feeds` and `fetches`
+retain complete tensor types, dimensions and data through the existing Core tensor encoding;
+omitted options remain omitted at the JSON boundary. `feedsSource` and
+`fetchesSource` identify `request` records when conversion did not complete,
+or `converted` values prepared for `session.run`. No partial converted map is
+presented as the complete input. The actual input tensors are preserved without changes
+to inference, and successful runs create no diagnostic tensor copy. If building
+this diagnostic fails, its complete `diagnosticError` accompanies the fields
+obtained before that failure; the original run error remains the failure.
+Session metadata and feeds describe graph inputs, not internal node tensors
+that the native runtime has not reported.
+
 `current()` returns `{sessions,closed}`. `subscribe(listener)` replays current
 state synchronously and returns an unsubscribe function. Load, readiness,
 unload and failures remain observable. `unload({id,signal?})` releases that

package/docs/reference/native-decisions.md

@@ -336,6 +336,19 @@ progress includes model preparation, tokenization and evaluation; downloaded
 members report files, not byte progress. Complete technical errors belong in
 developer diagnostics, while the application owns its user-facing status.
 
+An ONNX run failure reaches the rejected evaluation and retained `error` in
+`current()`, `decisions.status`, and `decisions.state`, including the complete
+[`error.onnxRun` diagnostic](local-ai.md#native-onnx-sessions). This identifies
+the actual session, request, failure stage, model path, provider execution
+record, graph metadata and complete encoded feed tensors with their dimensions.
+The activation's `execution.execution.deviceInventory` retains the complete
+inventory consumed by automatic physical selection during its load, or `null`
+when that selection path did not gather one.
+Neither observation starts another hardware query or changes model execution.
+Retain these complete records in the selected developer inspection surface;
+ordinary user status remains application-owned. A retained error identifies
+that failed request and does not by itself establish that a later request failed.
+
 Concurrent callers selecting the same family, model, revision, dtype, source,
 mapping and target share one explicit activation.
 Cancelling a load or evaluation cancels that activation and its outstanding operations, because the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.83.0",
+  "version": "0.83.1",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",

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'),