arcane-os 0.79.1 → 0.81.0

package/docs/reference/native-decisions.md

@@ -1,7 +1,7 @@
-# Native Laya typed decisions
+# Native typed decisions
 
 `arcane-os/local-ai/decisions` and `arcane-os/core/decisions` run the selected
-Laya FP32 graph through the SDK's existing native ONNX owner. Tokenization runs
+Laya FP32, Laya FP16 or Julia FP32 graph through the SDK's existing native ONNX owner. Tokenization runs
 in its own Node Worker. A Core service can load and evaluate decisions without
 a renderer, browser session, WebGPU browser context or chat provider.
 
@@ -58,7 +58,7 @@ name to `decisions`. It exposes `load`, `evaluate`, `classify` (an alias for
 | Method | Parameters and result |
 | --- | --- |
 | `decisions.status` | Current lifecycle snapshot; does not load anything. |
-| `decisions.load` | `{executionTarget?}`, where the target is `{deviceId:string}` or `null`; explicit activation or target replacement, returning the ready lifecycle snapshot. The request signal cancels activation. |
+| `decisions.load` | `{family?, model?, revision?, dtype?, assetProjectionId?, resourcePaths?, executionTarget?}`; explicit activation or model/source/device replacement, returning the ready lifecycle snapshot. The request signal cancels activation. A target is `{deviceId:string}` or `null`. |
 | `decisions.evaluate` | `{rows, runOptions?}`; returns `{decisions, outputs}`. The request signal cancels the active model operation. |
 | `decisions.unload` | Releases the activation. Service-lifetime cleanup continues after the caller disconnects. |
 
@@ -94,11 +94,89 @@ const decisions = createNativeDecisionModel({
 These direct paths are native filesystem paths. Keep the graph's external data
 beside it under the exact filename required by the graph. The Core service
 resolves configured `paths` relative to `appRoot`; it does not copy or remove
-caller-owned files. For SDK-prepared files, the default selected upstream is
-`onnx-community/laya-typed-decisions-ONNX`, revision `main`, with exactly:
+caller-owned files. Factory defaults remain `family:'laya'`,
+`model:'onnx-community/laya-typed-decisions-ONNX'`, `revision:'main'` and
+`dtype:'fp32'`. SDK upstream preparation selects these exact layouts:
 
-- `onnx/model.onnx` and `onnx/model.onnx_data`;
-- `tokenizer.json` and `tokenizer_config.json`.
+| Family and dtype | Graph | Complete external data |
+| --- | --- | --- |
+| `laya`, `fp32` | `onnx/model.onnx` | `onnx/model.onnx_data` |
+| `laya`, `fp16` | `onnx/model_fp16.onnx` | `onnx/model_fp16.onnx_data` |
+| `julia`, `fp32` | `model.onnx` | `model.onnx.data` |
+
+Each selection uses `tokenizer.json` and `tokenizer_config.json` from its own
+selected repository. Julia's public repository is `SupersonicLabs/Julia-1-ONNX`.
+
+## Load complete files already stored in DBOPFS
+
+Use the existing [model-assets projection](model-assets.md) for complete files
+already obtained through the application's DBOPFS model store. Pass every
+original member, including `onnx/model.onnx_data`, to `prepareCoreModelAssets`.
+The original relative paths and complete content remain unchanged:
+
+```js
+import {prepareCoreModelAssets} from 'arcane-os/ai/core-model-assets';
+
+const projection = await prepareCoreModelAssets({
+    client,
+    workingDirectory: selectedWorkingDirectory,
+    members: [
+        {path: 'onnx/model.onnx', file: storedGraph},
+        {path: 'onnx/model.onnx_data', file: storedGraphData},
+        {path: 'tokenizer.json', file: storedTokenizer},
+        {path: 'tokenizer_config.json', file: storedTokenizerConfig}
+    ],
+    signal
+});
+try {
+    await client.invoke('decisions.load', {
+        assetProjectionId: projection.id,
+        resourcePaths: {
+            model: 'onnx/model.onnx',
+            tokenizer: 'tokenizer.json',
+            tokenizerConfig: 'tokenizer_config.json'
+        },
+        executionTarget: {deviceId: 'cpu'}
+    }, {signal, timeoutMs: 0});
+} finally {
+    // The native activation owns a separate retain handle after loading.
+    await projection.release();
+}
+```
+
+Here the four `stored*` values are the complete original Blob/File members
+from the application's existing store. This projects those files; it performs
+no model download. The decision service must already be registered as above.
+After loading, invoke `decisions.evaluate` with the complete `rows`, then
+`decisions.unload` when that native activation is no longer needed.
+
+Direct model and service calls accept
+`load({family, model, revision, dtype, assetProjectionId, resourcePaths, executionTarget, signal})`; their
+factory configuration accepts the same source selection. A direct model needs
+the existing `modelAssets` owner when selecting a projection. `resourcePaths`
+maps all three roles (`model`, `tokenizer`, `tokenizerConfig`) to exact
+`member.path` values in a ready projection. Additional companion members stay
+in its retained directory; the graph finds its external data under the exact
+relative filename it references. The SDK does not rename or reconstruct them.
+
+A supplied projection is retained and used directly. It takes precedence over
+configured `paths` and upstream settings and never invokes upstream preparation
+or retries with downloaded files. Missing, unfinished or released projections,
+and missing mapped resources, report their actual failure.
+
+Omitted or `undefined` source fields retain the selected source and mappings.
+`assetProjectionId: null` returns to the factory's configured `paths`, or its
+existing upstream preparation when no paths were configured. Selecting another
+projection or changing any resource mapping replaces the activation even when
+the execution target stays the same. Equal family, model, revision, dtype,
+source, mapping and device selections
+coalesce. The incoming retain is acquired before the prior activation retires,
+so device replacement can reuse a projection after the caller has released its
+preparation ownership. Superseded pending retains are released as their cleanup
+settles. Unload ends the native use; if no preparation or other use remains,
+create a fresh projection from the stored originals before loading again.
+
+## Existing upstream preparation
 
 `model` selects the upstream Hugging Face repository and `revision` its
 revision. Native preparation performs normal upstream fetches only during
@@ -108,8 +186,12 @@ model store. The approved `@huggingface/tokenizers@0.2.0` dependency reads the
 selected tokenizer files in its Worker. No Transformers or second ONNX runtime
 is loaded by this API.
 
-This graph selection requires `dtype:'fp32'`, which is also the default; another
-dtype reports the incompatible selection rather than substituting a graph.
+Native graph selections support Laya `fp32` and `fp16`, and Julia `fp32`.
+Other family/precision combinations report an unsupported selection. Laya FP16
+uses the published mixed-precision graph, which retains selected operations
+and outputs in FP32; it does not claim every graph operation uses FP16. Julia
+uses its typed five-input ONNX graph and raw option logits, without the upstream
+display-rounded `predict()` wrapper or invented action outputs.
 `sessionOptions` and `runOptions` pass to the existing native ONNX API unchanged.
 With no `executionTarget` selection, `executionPreference` defaults to `gpu`
 here: actual advertised native GPU provider creation is attempted, followed by
@@ -119,6 +201,49 @@ continues to default to CPU. Accepted provider configuration is not evidence
 that GPU nodes executed. Full provider-attempt diagnostics remain in
 `execution`; see [native ONNX sessions](local-ai.md#native-onnx-sessions).
 
+## Select an activation's model
+
+Both factories and each direct/Core `load` accept `family`, `model`, `revision`
+and `dtype`. The same service persists while its selected activation changes:
+
+```js
+await client.invoke('decisions.load', {
+    family: 'julia',
+    model: 'SupersonicLabs/Julia-1-ONNX',
+    revision: 'main',
+    dtype: 'fp32',
+    assetProjectionId: juliaProjection.id,
+    resourcePaths: {
+        model: 'model.onnx',
+        tokenizer: 'tokenizer.json',
+        tokenizerConfig: 'tokenizer_config.json'
+    }
+}, {signal, timeoutMs: 0});
+```
+
+Here `juliaProjection` is the caller's ready projection containing Julia's
+complete graph, `model.onnx.data` and its own tokenizer files. The caller may
+release its preparation ownership after loading, as in the projection example.
+For upstream preparation without configured paths, select the same four model
+fields with `assetProjectionId: null`.
+
+Omitting a model field, or supplying `undefined`, retains its most recent
+selection, initially the factory default. The selection survives unload for a
+later explicit load. Changing any field replaces the activation; equal complete
+selections share it. Supply the complete new model selection when changing
+family, including its matching projection/mapping or configured native files.
+Changing `family` alone does not infer a repository, change precision, replace
+configured files, or rewrite a projection. Metadata describes the caller's
+selection; the SDK does not inspect weights to establish checkpoint identity.
+Configured `paths` and a selected projection keep their existing precedence
+over upstream preparation.
+
+Top-level `current().family`, `model`, `revision` and `dtype` follow the
+activation being loaded, used or retired. While replacement waits for prior
+cleanup, those fields and `execution` still describe the prior activation;
+`pendingActivation` carries the requested successor separately. The new
+selection takes ownership when its activation begins.
+
 ## Select an activation's execution device
 
 Both factories accept `executionTarget: {deviceId:string}` or `null` in their
@@ -158,15 +283,17 @@ resolution, accepted configuration and actual execution evidence. An unknown
 `observedTarget` remains `null`; successful configuration alone does not establish
 which device executed graph nodes.
 
-`pendingActivation` is separately `null` or `{executionTarget}` while a load or
-replacement is pending; its `executionTarget` property is omitted at JSON
-transport when the selection is `undefined`. A pending target never overwrites the previous
+`pendingActivation` is separately `null` or a selection containing `family`,
+`model`, `revision`, `dtype` and `executionTarget` while a load or replacement
+is pending; its `executionTarget` property is omitted at JSON
+transport when the selection is `undefined`. A projected selection also includes
+`assetProjectionId` and its complete `resourcePaths` mapping. A pending target never overwrites the previous
 activation's `execution` record. The old record remains attributable to the
 retiring activation until its cleanup completes, then the new activation owns
 its own record. A request is not a claim that the requested device is running.
 
-Concurrent loads for the same target share their pending activation. A
-different target supersedes the earlier pending request, which rejects with
+Concurrent loads for the same family, model, revision, dtype, source, resource mapping and target share their
+pending activation. A different selection supersedes the earlier pending request, which rejects with
 cancellation instead of returning another target's ready result. Replacement
 joins this model's actual tokenizer/native cleanup before creating its
 successor. Independent model owners retain their independent workers and
@@ -209,7 +336,8 @@ 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.
 
-Concurrent callers selecting the same target share one explicit activation.
+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
 native session and tokenizer have one owner. Use separately owned models when
 independent cancellation is required. The construction `signal` governs the
@@ -219,7 +347,8 @@ cleanup; `dispose()` is terminal. Readiness is revoked as disposal begins.
 Retained model files remain owned until the ONNX and tokenizer Workers really
 exit. A rejected load, inference or termination request alone does not permit
 file deletion. Cleanup joins active operations and native output delivery,
-preserves cleanup errors, then releases only its working projection. It never
+preserves cleanup errors, then releases its native-use handle. Preparation
+ownership of a supplied projection remains with its caller. It never
 deletes supplied `paths`. A failed ordinary row does not destroy a healthy
 loaded session or cancel sibling evaluations. The ONNX owner's `stopping:true`
 retires decision readiness immediately on terminal Worker failure or shutdown,
@@ -232,5 +361,6 @@ availability. Android requires the host's supported native adaptation. Static
 source review and synthetic authored fixtures are not model execution or a
 claim of tested platform, precision or accelerator behavior.
 
-Upstream selection: [Laya FP32 model files](https://huggingface.co/onnx-community/laya-typed-decisions-ONNX/tree/main),
+Upstream selection: [Laya model files](https://huggingface.co/onnx-community/laya-typed-decisions-ONNX/tree/main),
+[Julia-1 model files](https://huggingface.co/SupersonicLabs/Julia-1-ONNX/tree/main),
 [Tokenizer package](https://www.npmjs.com/package/@huggingface/tokenizers).

package/docs/reference/sdk-api.md

@@ -69,7 +69,7 @@ runtime layouts.
 | `arcane-os/core/local-ai` | Native llama.cpp, Ollama and ONNX Core service, model readiness, complete responses and owned lifecycle. See [local AI through Core](local-ai.md). |
 | `arcane-os/local-ai` | Official runtime installation and native artifact bundling for selected llama.cpp/Ollama/ONNX/image requirements and NeMo libraries. |
 | `arcane-os/local-ai/onnx` | Retained native ONNX worker sessions with explicit graph loading and complete tensor inference. |
-| `arcane-os/local-ai/decisions` | Explicit native Laya FP32 decisions using the existing ONNX owner and a tokenizer Worker. |
+| `arcane-os/local-ai/decisions` | Explicit native Laya FP32/FP16 and Julia FP32 decisions using the existing ONNX owner and a tokenizer Worker. |
 | `arcane-os/core/decisions` | Renderer-independent typed-decision service composed with existing local-AI and model-assets owners. |
 | `arcane-os/ai/core-onnx` | Optional browser access to system ONNX through an existing Core connection. |
 | `arcane-os/local-ai/image` | Retained native stable-diffusion.cpp context, complete PNG generation and owned worker lifetime. |
@@ -186,7 +186,7 @@ The remaining data-only subpaths are eight JSON Schemas and package metadata.
 | `acceptWebSocket()` | function | `arcane-os`, `arcane-os/websocket` | WebSocket protocol | Node; browser-native client interoperability |
 | `WS` | class | `arcane-os`, `arcane-os/websocket-client` | Shared WebSocket clients | Node and native-WebSocket browser hosts |
 | `createBrowserDecisionModel()` | function | `arcane-os/ai/browser-decisions` | Browser typed decisions | Browser module Workers and the caller-selected inference backend |
-| `createNativeDecisionModel()` | function | `arcane-os/local-ai/decisions` | Native typed decisions | Node with an existing native ONNX owner and selected Laya FP32 files |
+| `createNativeDecisionModel()` | function | `arcane-os/local-ai/decisions` | Native typed decisions | Node with an existing native ONNX owner and selected Laya FP32/FP16 or Julia FP32 files |
 | `createNativeDecisionService()` | function | `arcane-os/core/decisions` | Native typed decisions | Node Core with existing local-AI and model-assets services |
 | `createNativeDecisionService default export` | function | `arcane-os/core/decisions` | Native typed decisions | Same native decision service factory |
 | `fetchRequest()` | function | `arcane-os/ai/twin-cloud` | TWiN Cloud requests | Node and Browser; remote HTTPS provider |
@@ -9505,23 +9505,35 @@ native installation eligibility and URL-bar promotion.
 
 ### Overview
 
-Runs explicitly selected Laya FP32 option scoring through an existing native
+Runs explicitly selected Laya FP32/FP16 or Julia FP32 option scoring through an existing native
 ONNX owner, with tokenization in a Node Worker. It creates no second inference
 engine and starts no model download at construction.
 
 ### Signature and result
 
 ```text
-createNativeDecisionModel({onnx,modelAssets,workingDirectory,paths,model='onnx-community/laya-typed-decisions-ONNX',revision='main',dtype='fp32',sessionOptions,executionPreference='gpu',signal}={})
+createNativeDecisionModel({onnx,modelAssets,workingDirectory,paths,assetProjectionId,resourcePaths,family='laya',model='onnx-community/laya-typed-decisions-ONNX',revision='main',dtype='fp32',sessionOptions,executionPreference='gpu',executionTarget,signal}={})
 ```
 
 Import from `arcane-os/local-ai/decisions`. Supply the existing `onnx` owner and
 either `modelAssets` plus `workingDirectory`, or native `paths` for the model,
-tokenizer and tokenizer configuration. The selected graph requires FP32. The
+tokenizer and tokenizer configuration, or a ready `assetProjectionId` with
+`resourcePaths` for those three roles. Supported selections are Laya `fp32`,
+Laya `fp16` and Julia `fp32`; constructor defaults remain Laya FP32. The
 handle exposes `load`, `evaluate`, `classify`, `current`, `status`, `subscribe`,
 `unload` and terminal `dispose`; `classify` aliases `evaluate` and `status`
 aliases `current`.
 
+`load({family,model,revision,dtype,assetProjectionId,resourcePaths,executionTarget,signal})`
+selects each activation. Omitted or `undefined` fields retain their prior
+selection. A changed model field, source, mapping or device replaces the
+activation after actual cleanup; equal complete selections coalesce. Supply
+all matching model fields and files when changing family: metadata does not
+infer a repository or rewrite a supplied projection. Top-level model metadata
+continues to describe the retiring activation while `pendingActivation` records
+its successor. See [model selection](native-decisions.md#select-an-activations-model)
+for exact upstream graph/companion layouts and retained projection ownership.
+
 `evaluate(rows,{signal,runOptions})` preserves each complete `state`, `question`,
 `options` and optional `type` separately. It returns `{decisions,outputs}` with
 original rows, typed values, raw logits, unrounded probabilities and every
@@ -9574,7 +9586,11 @@ reacquires `getONNXRuntime()` after any recovery. Native members are `load`,
 `start(context)`.
 
 RPC exposes `decisions.status`, `decisions.load`, `decisions.evaluate` and
-`decisions.unload`. Evaluation accepts `{rows,runOptions?}` and returns complete
+`decisions.unload`. Load accepts optional `family`, `model`, `revision`, `dtype`,
+`assetProjectionId`, `resourcePaths` and `executionTarget`, with the same
+per-activation selection and omission behavior as direct native load; the Core
+request signal owns cancellation. The service persists across model changes.
+Evaluation accepts `{rows,runOptions?}` and returns complete
 `{decisions,outputs}` using the existing tensor codec at the JSON boundary.
 `decisions.state` and replaying `subscribe(listener,{emitCurrent:true,signal})`
 report lifecycle. Unload is accepted service-lifetime cleanup; host shutdown

package/package.json

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

package/runtime/arcane/modules/AI.js

@@ -5018,6 +5018,7 @@ class AI {
         model,
         structuredOutput=false,
         localOnly=false,
+        speech=true,
         onChunk=function ignoreStreamChunk(){},
         toolText,
         onToolText,
@@ -5062,6 +5063,9 @@ class AI {
         if(localOnly!==true&&localOnly!==false){
             throw new TypeError('AI localOnly must be a boolean.');
         }
+        if(speech!==true&&speech!==false){
+            throw new TypeError('AI speech must be a boolean.');
+        }
         if(localOnly&&!this.#hasLocalRoute('llm',this.llmService)){
             const error=new Error(
                 'This AI request requires a configured local model.'
@@ -5163,7 +5167,7 @@ class AI {
                 if(signal?.aborted){
                     throw normalizeAIRequestAbort();
                 }
-                this.#finishStreamingSpeech();
+                if(speech)this.#finishStreamingSpeech();
                 return result;
             }catch(error){
                 if(handle){
@@ -5171,7 +5175,7 @@ class AI {
                         function retainProviderStreamCleanupFailure() {}
                     );
                 }
-                this.stopAudio();
+                if(speech)this.stopAudio();
                 throw isAIRequestAbort(error,signal)
                     ?normalizeAIRequestAbort(error)
                     :error;
@@ -5223,10 +5227,10 @@ class AI {
             if(signal?.aborted){
                 throw normalizeAIRequestAbort();
             }
-            this.#finishStreamingSpeech();
+            if(speech)this.#finishStreamingSpeech();
             return result;
         }catch(error){
-            this.stopAudio();
+            if(speech)this.stopAudio();
             throw isAIRequestAbort(error,signal)
                 ?normalizeAIRequestAbort(error)
                 :error;
@@ -6026,7 +6030,8 @@ class AI {
             }
             throw error;
         }finally{
-            if(!speechTurnCompleted){
+            // Provider transports leave speech lifecycle to their public caller.
+            if(finishSpeech&&!speechTurnCompleted){
                 this.stopAudio();
             }
         }

package/src/core/hosts/windows/ArcaneHost.cs

@@ -124,6 +124,7 @@ namespace Arcane.Core.Hosts.Windows
         private bool started;
         private bool documentReady;
         private bool deliveryScheduled;
+        private bool browserProcessExited;
         private bool closing;
         private bool closeAllowed;
 
@@ -551,11 +552,26 @@ namespace Arcane.Core.Hosts.Windows
             {
                 error = new AggregateException("Reading WebView2 process-failure diagnostics failed.", error, diagnosticError);
             }
-            // Only loss of the browser or top-level renderer ends this bridge.
+            if (kind == CoreWebView2ProcessFailedKind.BrowserProcessExited)
+            {
+                // WebView2 has closed this browser. Complete the owned host
+                // lifetime without trying to notify its vanished document.
+                browserProcessExited = true;
+                lock (stateLock)
+                {
+                    if (transportFailure == null) transportFailure = error;
+                }
+                Report(error);
+                ready.TrySetException(error);
+                if (bridge != null) bridge.Stop(error);
+                if (activeBridge != null) activeBridge.Stop(error);
+                BeginClose();
+                return;
+            }
+            // Loss of the top-level renderer ends its bridge.
             // GPU/utility/plugin helpers recover independently; subframe loss,
             // unresponsiveness and unspecified failures remain full diagnostics.
-            if (kind == CoreWebView2ProcessFailedKind.BrowserProcessExited
-                || kind == CoreWebView2ProcessFailedKind.RenderProcessExited) CoreFailed(error);
+            if (kind == CoreWebView2ProcessFailedKind.RenderProcessExited) CoreFailed(error);
             else Report(error);
         }
 
@@ -665,7 +681,7 @@ namespace Arcane.Core.Hosts.Windows
 
         private void NotifyTransportFailure()
         {
-            if (!documentReady || webView.CoreWebView2 == null || transportFailure == null || closing) return;
+            if (closing || browserProcessExited || !documentReady || webView.CoreWebView2 == null || transportFailure == null) return;
             if (failureNotifiedGeneration == generation) return;
             failureNotifiedGeneration = generation;
             Task failureNotification = NotifyTransportFailureAsync(transportFailure);
@@ -761,7 +777,7 @@ namespace Arcane.Core.Hosts.Windows
             ready.TrySetCanceled();
             try
             {
-                if (webView.CoreWebView2 != null)
+                if (!browserProcessExited && webView.CoreWebView2 != null)
                 {
                     webView.CoreWebView2.RemoveHostObjectFromScript("arcaneBridge");
                     if (injectedScript != null) webView.CoreWebView2.RemoveScriptToExecuteOnDocumentCreated(injectedScript);