arcane-os 0.80.0 → 0.81.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.81.0
+
+- Add per-activation native decision `family`, `model`, `revision`, and `dtype`
+  selection through the direct runtime and Core service. Support Laya FP16 and
+  Julia 1 FP32 with their own model companions and tokenizer family, preserving
+  Laya FP32 defaults, complete input rows and actual output tensors. Keep
+  requested replacement metadata separate from the active model and retain
+  prepared files through actual worker exit.
+- Report cached model loading as real stored-part progress and preserve known
+  GGUF shard totals. Forward complete progress details and cancellation through
+  cache reads without presenting cached data as a download or inventing totals
+  for an unfinished network stream.
+- Add object-form `AI.streamRequest({speech:false})` for text-only operations.
+  Completion, failure and cancellation leave unrelated prepared, native and
+  buffered speech alone. Existing defaults, positional methods and explicit
+  speech APIs retain their behavior.
+- Close and drain the Windows host after WebView2 `BrowserProcessExited`,
+  preserving its full diagnostic instead of leaving a blank window awaiting
+  manual closure. Existing renderer/Core-only handling and saved profiles stay
+  unchanged. This source correction does not establish the cause of the browser
+  exit; executable consumers require the matching rebuilt host archive.
+- Keep dependencies, app-control, native GGUF activation and native Kokoro
+  routing unchanged. Source/package verification is separate from actual model,
+  audio or application execution.
+
 ## 0.80.0
 
 - Add `assetProjectionId` and `resourcePaths` to native decision factories and

package/README.md

@@ -20,7 +20,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.80.0` SDK contract. Development applications declare
+This checkout defines the `0.81.0` 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/browser-runtime/ai/browser-wasm-llm-provider.mjs

@@ -667,19 +667,21 @@ export function createDbopfsModelStore({
     }
   }
 
-  function createDownloadProgressReporter(members, onProgress, retainFailure) {
+  function createModelProgressReporter(members, onProgress, retainFailure) {
     const shards = members.map(function initialMemberProgress(member) {
       return {name: member.name, completed: 0, total: null, unit: 'shards'};
     });
     let completed = 0;
+    let phase = "cache-check";
     let activeTransfers = 0;
     let transferMode = members.length === 1 ? "probing" : "files";
     let timer = null;
     let lastPublishedAt = 0;
+    let progressFailure = null;
 
     function progressRecord() {
       return completeValue({
-        phase: "download",
+        phase,
         completed,
         total: members.length,
         unit: "files",
@@ -713,18 +715,28 @@ export function createDbopfsModelStore({
         return true;
       } catch (error) {
         stopTimer();
+        progressFailure ??= error;
         retainFailure(error);
         return false;
       }
     }
 
+    function assertProgress() {
+      if (progressFailure !== null) throw progressFailure;
+    }
+
     return completeValue({
       reportShards(memberIndex, value) {
+        assertProgress();
         shards[memberIndex] = {...value, name: members[memberIndex].name};
+        if (value.phase === "download" || activeTransfers > 0) phase = "download";
+        else if (value.phase === "load") phase = "load";
         publishSafely({force: true});
+        if (value.phase === "load") assertProgress();
       },
       beginTransfer() {
         activeTransfers += 1;
+        phase = "download";
         publishSafely({ force: true });
       },
       completeMember() {
@@ -745,14 +757,17 @@ export function createDbopfsModelStore({
         publishSafely({ force: true });
       },
       restoreMember(memberIndex) {
-        shards[memberIndex] = {...shards[memberIndex], state: 'cached'};
+        assertProgress();
+        shards[memberIndex] = {...shards[memberIndex], phase: 'load', cached: true, state: 'cached'};
+        if (activeTransfers === 0) phase = "load";
         completed += 1;
         publishSafely({ force: true });
+        assertProgress();
       },
       start() {
         if (!publishSafely({ force: true })) return;
         if (onProgress !== null && timer === null) {
-          timer = setInterval(function publishDownloadProgressTick() {
+          timer = setInterval(function publishModelProgressTick() {
             publishSafely();
           }, MODEL_DOWNLOAD_PROGRESS_INTERVAL_MS);
         }
@@ -795,6 +810,9 @@ export function createDbopfsModelStore({
     const partFiles = new Array(ranges.length);
     const pendingRangeIndexes = [];
     let completedParts = 0;
+    progress?.reportShards(memberIndex, {
+      phase: 'load', completed: 0, total: ranges.length, unit: 'shards', cached: true,
+    });
     for (let rangeIndex = 0; rangeIndex < ranges.length; rangeIndex += 1) {
       throwIfAborted(signal, "install");
       const range = ranges[rangeIndex];
@@ -804,15 +822,20 @@ export function createDbopfsModelStore({
       if (partFile?.size === expected) {
         partFiles[rangeIndex] = partFile;
         completedParts += 1;
+        progress?.reportShards(memberIndex, {
+          phase: 'load', completed: completedParts, total: ranges.length, unit: 'shards', cached: true,
+        });
       } else {
         if (partFile) await removeEntry(partName);
         pendingRangeIndexes.push(rangeIndex);
       }
     }
     progress?.reportShards(memberIndex, {
+      phase: 'load',
       completed: completedParts,
       total: ranges.length,
-      unit: 'shards'
+      unit: 'shards',
+      cached: true,
     });
     const linked = linkAbortSignal(signal);
     const downloadSignal = linked.controller.signal;
@@ -868,6 +891,7 @@ export function createDbopfsModelStore({
           throwIfAborted(downloadSignal, "install");
           completedParts += 1;
           progress?.reportShards(memberIndex, {
+            phase: 'download',
             completed: completedParts,
             total: ranges.length,
             unit: 'shards'
@@ -1120,13 +1144,27 @@ export function createDbopfsModelStore({
     });
   }
 
-  async function availableModelFiles(names, signal) {
+  async function availableModelFiles(names, signal, progress) {
     const modelFiles = [];
-    for (const entry of names.models) {
+    for (let memberIndex = 0; memberIndex < names.models.length; memberIndex += 1) {
+      const entry = names.models[memberIndex];
       throwIfAborted(signal, "install");
       // Existing whole-file caches remain readable; new downloads use parts.
-      const modelFile = await parts.read(entry.name, {signal}) ?? await file(entry.name);
+      let modelFile = await parts.read(entry.name, {
+        signal,
+        onProgress: function reportStoredShards(value) {
+          progress?.reportShards(memberIndex, value);
+        },
+      });
+      if (!modelFile) {
+        modelFile = await file(entry.name);
+        if (modelFile) progress?.reportShards(memberIndex, {
+          phase: 'load', completed: 1, total: 1, unit: 'shards', cached: true,
+        });
+      }
       modelFiles.push(modelFile);
+      if (modelFile) progress?.restoreMember(memberIndex);
+      throwIfAborted(signal, "install");
     }
     return modelFiles;
   }
@@ -1136,9 +1174,16 @@ export function createDbopfsModelStore({
     ranges,
     signal,
     availableNames = null,
+    onProgress = null,
   ) {
     const partFiles = [];
     let lastModified = 0;
+    function reportStoredRange() {
+      throwIfAborted(signal, "install");
+      onProgress?.({phase: 'load', completed: partFiles.length,
+        total: ranges.length, unit: 'shards', cached: true});
+    }
+    reportStoredRange();
     for (const range of ranges) {
       throwIfAborted(signal, "install");
       const partName = rangePartName(modelName, range);
@@ -1151,10 +1196,12 @@ export function createDbopfsModelStore({
         return null;
       }
       partFiles.push(partFile);
+      reportStoredRange();
       if (is.finite(partFile.lastModified)) {
         lastModified = Math.max(lastModified, partFile.lastModified);
       }
     }
+    throwIfAborted(signal, "install");
     return completeValue({
       file: new Blob(partFiles, { type: "application/octet-stream" }),
       lastModified,
@@ -1168,6 +1215,7 @@ export function createDbopfsModelStore({
     total,
     signal,
     availableNames = null,
+    onProgress = null,
   ) {
     const ranges = rangePlanForInstall(total, signal);
     return storedRangeCandidateForPlan(
@@ -1175,10 +1223,11 @@ export function createDbopfsModelStore({
       ranges,
       signal,
       availableNames,
+      onProgress,
     );
   }
 
-  async function storedRangeMember(member, modelName, signal) {
+  async function storedRangeMember(member, modelName, signal, onProgress) {
     const names = await memberRangePartNames(modelName);
     const availableNames = names === null ? null : new Set(names);
     const declaredTotal = is.safeInteger(member.bytes) && member.bytes > 0
@@ -1190,6 +1239,7 @@ export function createDbopfsModelStore({
         declaredTotal,
         signal,
         availableNames,
+        onProgress,
       );
       if (declared) {
         await removeStaleRangePartsAfterCompletion(
@@ -1214,6 +1264,7 @@ export function createDbopfsModelStore({
         total,
         signal,
         availableNames,
+        onProgress,
       );
       if (
         candidate
@@ -1224,16 +1275,20 @@ export function createDbopfsModelStore({
       ) selected = candidate;
     }
     if (selected === null) return null;
+    throwIfAborted(signal, "install");
     await removeStaleRangePartsAfterCompletion(
       modelName,
       selected.ranges,
     );
+    onProgress?.({phase: 'load', completed: selected.ranges.length,
+      total: selected.ranges.length, unit: 'shards', cached: true});
+    throwIfAborted(signal, "install");
     return selected.file;
   }
 
-  async function availableResumableModelFiles(source, names, signal) {
+  async function availableResumableModelFiles(source, names, signal, progress) {
     const members = sourceMetadata(source).files;
-    const modelFiles = await availableModelFiles(names, signal);
+    const modelFiles = await availableModelFiles(names, signal, progress);
     await removeRangePartsBehindWholeFiles(members, names, modelFiles);
     for (let memberIndex = 0; memberIndex < modelFiles.length; memberIndex += 1) {
       if (modelFiles[memberIndex]) continue;
@@ -1241,20 +1296,40 @@ export function createDbopfsModelStore({
         members[memberIndex],
         names.models[memberIndex].name,
         signal,
+        function reportStoredRangeShards(value) {
+          progress?.reportShards(memberIndex, value);
+        },
       );
+      if (modelFiles[memberIndex]) progress?.restoreMember(memberIndex);
+      throwIfAborted(signal, "install");
     }
     return modelFiles;
   }
 
   async function openCached(source, {
     signal,
+    onProgress = null,
   } = {}) {
     const names = storageName(source);
-    const modelFiles = await availableResumableModelFiles(source, names, signal);
-    if (!modelFiles.every(Boolean)) return null;
-    return completeValue({
-      files: completeValue(modelFiles),
+    let failure = null;
+    const progress = createModelProgressReporter(sourceMetadata(source).files, onProgress, function retainProgressFailure(error) {
+      failure ??= error;
     });
+    try {
+      progress.start();
+      if (failure !== null) throw failure;
+      const modelFiles = await availableResumableModelFiles(source, names, signal, progress);
+      if (failure !== null) throw failure;
+      if (!modelFiles.every(Boolean)) return null;
+      progress.finish();
+      if (failure !== null) throw failure;
+      throwIfAborted(signal, "install");
+      return completeValue({files: completeValue(modelFiles)});
+    } catch (error) {
+      throw failure ?? error;
+    } finally {
+      progress.dispose();
+    }
   }
 
   async function install(source, { signal, onProgress = null } = {}) {
@@ -1263,7 +1338,7 @@ export function createDbopfsModelStore({
     }
     const names = storageName(source);
     const members = sourceMetadata(source).files;
-    const modelFiles = await availableResumableModelFiles(source, names, signal);
+    let modelFiles;
     const linked = linkAbortSignal(signal);
     const downloadSignal = linked.controller.signal;
     let nextMemberIndex = 0;
@@ -1273,7 +1348,7 @@ export function createDbopfsModelStore({
       if (failure === null) failure = error;
     }
 
-    const progress = createDownloadProgressReporter(members, onProgress, retainFailure);
+    const progress = createModelProgressReporter(members, onProgress, retainFailure);
 
     async function installMember(memberIndex) {
       let modelFile = null;
@@ -1338,12 +1413,14 @@ export function createDbopfsModelStore({
 
     try {
       progress.start();
+      if (failure !== null) throw failure;
+      modelFiles = await availableResumableModelFiles(source, names, downloadSignal, progress);
+      if (failure !== null) throw failure;
       let pendingMembers = members.length;
       for (let memberIndex = 0; memberIndex < modelFiles.length; memberIndex += 1) {
         const modelFile = modelFiles[memberIndex];
         if (!modelFile) continue;
         pendingMembers -= 1;
-        progress.restoreMember(memberIndex);
       }
       const workers = [];
       const workerCount = Math.min(workerLimit, pendingMembers);
@@ -1392,10 +1469,11 @@ export function createDbopfsModelStore({
       unit: "files",
       heartbeat: false,
     }));
-    const cached = await openCached(source, { signal });
+    const cached = await openCached(source, { signal, onProgress });
     if (cached) {
       const storage = await storagePolicy({ cached: true });
       onCapabilityPolicy?.(storage);
+      throwIfAborted(signal, "install");
       return completeValue({ ...cached, cache: "cached", storage });
     }
     if (offline) {

package/browser-runtime/ai/dbopfs-model-parts.mjs

@@ -178,13 +178,20 @@ export function createDbopfsModelPartStore({dbopfs, tableName}) {
             throw error;
         }
     }
-    async function assemble(record, signal) {
+    async function assemble(record, signal, onProgress) {
         const parts = [];
+        function reportStoredPart() {
+            throwIfModelAborted(signal);
+            onProgress?.({phase: 'load', message: 'Reading stored model resource',
+                completed: parts.length, total: record.parts.length, unit: 'shards', cached: true});
+        }
+        reportStoredPart();
         for (const name of record.parts) {
             throwIfModelAborted(signal);
             const part = await file(name);
             if (!part) return null;
             parts.push(part);
+            reportStoredPart();
         }
         throwIfModelAborted(signal);
         return new Blob(parts);
@@ -209,18 +216,18 @@ export function createDbopfsModelPartStore({dbopfs, tableName}) {
             return readState(name);
         }, signal);
     }
-    function read(name, {signal} = {}) {
+    function read(name, {signal, onProgress} = {}) {
         return locked(name, async function readCompleteModelParts() {
             throwIfModelAborted(signal);
             const record = await readState(name);
-            return record?.complete ? assemble(record, signal) : null;
+            return record?.complete ? assemble(record, signal, onProgress) : null;
         }, signal);
     }
-    function readPartial(name, {signal} = {}) {
+    function readPartial(name, {signal, onProgress} = {}) {
         return locked(name, async function readClosedModelParts() {
             throwIfModelAborted(signal);
             const record = await readState(name);
-            return record ? assemble(record, signal) : null;
+            return record ? assemble(record, signal, onProgress) : null;
         }, signal);
     }
     function remove(name, {signal} = {}) {

package/browser-runtime/ai/dbopfs-model-resources.mjs

@@ -93,11 +93,8 @@ export function createDbopfsResourceStore({dbopfs, tableName, fetchImpl = global
             const reusable = request.method === 'GET' && !request.headers.has('range')
                 && !['reload', 'no-cache', 'no-store'].includes(request.cache);
             if (reusable && entry.metadata?.status === 200) {
-                const file = await parts.read(entry.name, {signal});
+                const file = await parts.read(entry.name, {signal, onProgress: reportResourceProgress});
                 if (file) {
-                    const state = await parts.state(entry.name, {signal});
-                    onProgress?.({phase: 'load', message: 'Reading stored model resource', completed: state.parts.length,
-                        total: state.parts.length, unit: 'shards', cached: true, url: request.url});
                     return {...entry.metadata, file};
                 }
             }
@@ -111,7 +108,7 @@ export function createDbopfsResourceStore({dbopfs, tableName, fetchImpl = global
             const encoding = previousHeaders.get('content-encoding');
             const partial = reusable && entry.metadata?.status === 200
                 && (!encoding || encoding === 'identity')
-                ? await parts.readPartial(entry.name, {signal}) : null;
+                ? await parts.readPartial(entry.name, {signal, onProgress: reportResourceProgress}) : null;
             try {
                 if (partial?.size) {
                     const headers = new Headers(request.headers);

package/docs/reference/ai/browser-speech.md

@@ -1116,6 +1116,17 @@ prepared playback without invoking `finishTTS()` or `streamTTS()`. Unmuted
 completion keeps its ordinary speech flush. Explicit calls to either public
 speech method retain their existing behavior.
 
+For a text-only request, pass `speech:false` to the object-form
+`ai.streamRequest({messages, speech:false, onChunk, signal})`. Its completion,
+failure, and cancellation leave buffered speech, prepared playback, and native
+playback alone. The option controls only the request's automatic speech
+finalization and stopping; it is not sent to the language provider and does not
+mute or unload TTS. Explicit speech calls made by your callbacks still run with
+their ordinary behavior. Omitted `speech` or `speech:true` preserves the
+automatic lifecycle above, and positional `streamMessage(...)` is unchanged.
+Explicit `streamTTS()`, `finishTTS()`, and global `stopAudio()` keep their existing
+scope.
+
 ## Automatic speech-input formatting cleanup
 
 The shared streaming, audio-file, and `SpeechPlayback` paths remove repeated

package/docs/reference/ai/browser-wasm.md

@@ -115,13 +115,17 @@ The controller emits `statechange` and `progress` through
 current mutable status snapshot. Provider states are `unloaded`, `loading`, `ready`,
 `unloading`, and `error`.
 
-Browser-WASM model loads report `cache-check`, `download`, and `initialize`
-phases. Download records preserve the ordered model-file fields `completed`,
+Browser-WASM model loads report `cache-check`, `load`, `download`, and `initialize`
+phases. Cache-read and download records preserve the ordered model-file fields `completed`,
 `total`, and `unit:'files'`. Their ordered `members` records contain each file's
 `name`, committed-part `completed`, `total`, and `unit:'shards'`. A streaming
 response has `total:null` until its end is observed; completion then supplies
-the actual committed-part count. Previously complete members identify
-`state:'cached'`. `activeTransfers` is the current transfer-worker count,
+the actual committed-part count. Reading saved parts reports `phase:'load'`,
+`cached:true`, and the known saved-part total before the first read and after
+each part is opened. An existing HTTP Range plan likewise supplies its actual
+shard total. Previously complete members identify `state:'cached'`; their
+per-member records remain cache reads even if another member is downloading.
+A fully cached activation emits no download phase. `activeTransfers` is the current transfer-worker count,
 `transferLimit` is the selected concurrency, and `transferMode` identifies
 `probing`, `files`, `ranges`, or `single`. No byte progress, rate, or estimated
 completion time is produced. Closed-part and lifecycle changes publish promptly;
@@ -136,7 +140,7 @@ These messages do not change the runtime's log level or replace its complete
 diagnostic output.
 
 Initialization has `total:null` and omits `completed` and `unit`, so its progress
-bar is indeterminate. Downloaded-file completion is not activation completion.
+bar is indeterminate. Cached or downloaded file completion is not activation completion.
 The metadata tensor count and GPU layer assignment are descriptive only:
 upstream reports assigned layers before model-weight loading has finished.
 The pinned runtime does not expose a measured overall initialization fraction
@@ -658,10 +662,13 @@ contains `kind`, `tableName`, `downloadConcurrency`, the original `adapter`,
 and `ready`, `install`, `ensure`, `remove`, and `fetchResource`. `ensure()` preserves the complete
 ordered model set and reports whether it was cached or installed.
 `install(source,{signal,onProgress})` and
-`ensure(source,{signal,onProgress,offline})` publish `cache-check` and
-`download` records using ordered file counts and per-member closed-part progress
+`ensure(source,{signal,onProgress,offline})` publish `cache-check`, cache-reading
+`load`, and actual network `download` records using ordered file counts and per-member closed-part progress
 when `onProgress` is supplied. Each member reports `completed`, `total`, and
-`unit:'shards'`; streaming totals remain `null` until completion. Records retain
+`unit:'shards'`; streaming totals remain `null` until completion. Cache reads
+publish the known stored-part plan from zero through each opened part, with
+`cached:true`; the existing Range plan supplies known totals during resume.
+No model length is converted into product progress. Records retain
 `activeTransfers`, `transferLimit`, and `transferMode`, with prompt part/lifecycle
 updates and an existing 250 ms heartbeat. They contain no transfer rate or ETA.
 Multi-file sources use up to that many concurrent member workers
@@ -693,8 +700,12 @@ loaders share this owner for actual configuration, tokenizer, graph,
 external-data and support-file requests. Complete successful GET resources may
 be reused. Cancellation joins reader/writer cleanup and preserves closed parts
 for supported HTTP resume; a full response restarts that resource without
-duplicating its saved prefix. Resource progress uses `unit:'shards'` with
-`total:null` until completion. Independent resource requests remain concurrent.
+duplicating its saved prefix. Resource progress uses `unit:'shards'`. A network
+response without a known shard plan retains `total:null` until completion;
+opening a saved complete or partial resource reports `phase:'load'`,
+`cached:true`, and the known number of stored parts before and during the read.
+The resource URL accompanies every update. These counts describe resource
+preparation, never engine activation. Independent resource requests remain concurrent.
 
 ### Availability and normalization
 

package/docs/reference/core-native-packaging.md

@@ -592,6 +592,15 @@ before the window closes; complete engineering errors go to the supplied
 diagnostic/error callbacks. Callbacks must not synchronously wait for the
 window's lifetime promises.
 
+A WebView2 `BrowserProcessExited` failure retains its complete diagnostic,
+fails a pending `Ready`, and begins the existing Core drain and window close.
+It does not wait for a user to close a blank window or invoke document callbacks
+and script cleanup in the closed browser. The launcher reports the failure
+after that drain. Main-renderer exits and Core-only transport failures retain
+their existing handling. This terminal-flow correction does not identify or
+prevent the underlying browser-process exit, restart the application, or change
+its profile and saved data.
+
 `ArcaneLauncher.cs` supplies the executable entry point for that composition.
 `tools/build-core-windows-host.mjs` builds the selected SDK host output from the
 approved WebView2 package, existing .NET Framework compiler and selected Node

package/docs/reference/inventory/package-api.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "sdkVersion": "0.79.0",
+  "sdkVersion": "0.80.0",
   "environment": {
     "runtime": "Node.js for Node entrypoints; browser for browser-only entrypoints",
     "minimumVersion": "22.23.2 for Node entrypoints",
@@ -45,14 +45,14 @@
       "name": "createNativeDecisionModel",
       "displayName": "createNativeDecisionModel()",
       "kind": "function",
-      "signature": "createNativeDecisionModel({onnx,modelAssets,workingDirectory,paths,assetProjectionId,resourcePaths,model='onnx-community/laya-typed-decisions-ONNX',revision='main',dtype='fp32',sessionOptions,executionPreference='gpu',executionTarget,signal}={})",
+      "signature": "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}={})",
       "entrypoints": ["arcane-os/local-ai/decisions"],
       "primaryImport": "arcane-os/local-ai/decisions",
       "group": "Native typed decisions",
-      "summary": "Explicit native Laya FP32 option scoring through an existing ONNX owner and a tokenizer Worker.",
+      "summary": "Explicit native Laya FP32/FP16 or Julia FP32 option scoring through an existing ONNX owner and a tokenizer Worker.",
       "availability": "Node on Windows/Linux/macOS with selected ONNX Runtime and model files; Android needs host adaptation",
-      "protocol": "Shared browser/native decision encoding with native named tensor results",
-      "normalization": "Returns load/evaluate/classify/current/status/subscribe/unload/dispose; preserves complete separate state/question/options/type and original rows, raw scores and every graph output. load({assetProjectionId,resourcePaths,executionTarget,signal}) retains omitted or undefined source, mapping and target fields from the latest selection, initially the factory configuration. A supplied ready projection takes precedence over configured paths and upstream settings; the existing modelAssets owner retains it directly without upstream preparation or fetching. resourcePaths maps model, tokenizer and tokenizerConfig to exact projection member.path values; complete companion files remain at their original relative paths. Missing projections or mapped members report their actual failure. assetProjectionId:null returns to configured paths or existing upstream preparation when no paths were configured. Separately, executionTarget:null requests automatic resolution, while {deviceId} forwards the saved physical selection to the existing ONNX owner. With no target selection, GPU preference still attempts advertised providers then CPU and explicit session providers retain precedence. Equal source, complete mapping and target selections share activation; a changed selection cancels the earlier request and joins its actual ONNX/tokenizer cleanup before replacement. Incoming projection use is retained before retiring the previous activation; caller preparation ownership is independent, and native files remain retained through actual ONNX and tokenizer Worker exit. Unload ends native use; loading again after all ownership is released requires a fresh projection. pendingActivation reports the requested replacement and projected source/mapping separately; current().execution remains the complete ONNX load record, with requested/resolved/configured/observed target diagnostics in current().execution.execution. Configuration alone does not prove physical execution. Cancellation retires the shared activation. No preference writes, chat history or duplicate inference engine."
+      "protocol": "Shared browser/native decision encoding with native named tensor results. Factory and each load accept family/model/revision/dtype; omission or undefined retains the selected value. Laya FP32 defaults remain. Laya FP16 selects onnx/model_fp16.onnx and onnx/model_fp16.onnx_data; Julia FP32 selects model.onnx and model.onnx.data, with its own tokenizer files. Complete new-family selection and matching files are caller-owned. All model fields participate in activation equality; top-level metadata stays attributable to the retiring activation while pendingActivation records its requested successor. Decoder preserves raw probabilities, every original row and every actual output without inventing Julia action logits.",
+      "normalization": "Returns load/evaluate/classify/current/status/subscribe/unload/dispose; preserves complete separate state/question/options/type and original rows, raw scores and every graph output. load({family,model,revision,dtype,assetProjectionId,resourcePaths,executionTarget,signal}) retains omitted or undefined family, model, revision, dtype, source, mapping and target fields from the latest selection, initially the factory configuration. A supplied ready projection takes precedence over configured paths and upstream settings; the existing modelAssets owner retains it directly without upstream preparation or fetching. resourcePaths maps model, tokenizer and tokenizerConfig to exact projection member.path values; complete companion files remain at their original relative paths. Missing projections or mapped members report their actual failure. assetProjectionId:null returns to configured paths or existing upstream preparation when no paths were configured. Separately, executionTarget:null requests automatic resolution, while {deviceId} forwards the saved physical selection to the existing ONNX owner. With no target selection, GPU preference still attempts advertised providers then CPU and explicit session providers retain precedence. Equal family, model, revision, dtype, source, complete mapping and target selections share activation; a changed selection cancels the earlier request and joins its actual ONNX/tokenizer cleanup before replacement. Incoming projection use is retained before retiring the previous activation; caller preparation ownership is independent, and native files remain retained through actual ONNX and tokenizer Worker exit. Unload ends native use; loading again after all ownership is released requires a fresh projection. pendingActivation reports the requested replacement and projected source/mapping separately; current().execution remains the complete ONNX load record, with requested/resolved/configured/observed target diagnostics in current().execution.execution. Configuration alone does not prove physical execution. Cancellation retires the shared activation. No preference writes, chat history or duplicate inference engine."
     },
     {
       "id": "core-decisions:createNativeDecisionService",
@@ -63,10 +63,10 @@
       "entrypoints": ["arcane-os/core/decisions"],
       "primaryImport": "arcane-os/core/decisions",
       "group": "Native typed decisions",
-      "summary": "Renderer-independent native Laya service reusing the registered local-AI and model-assets owners.",
+      "summary": "Renderer-independent native Laya/Julia service reusing the registered local-AI and model-assets owners.",
       "availability": "Node Core with selected native ONNX and model files",
-      "protocol": "arcane/1 decisions.status/load/evaluate/unload and decisions.state",
-      "normalization": "Registration starts no model or tokenizer. Explicit load obtains dependency-ready same-process owners and reacquires getONNXRuntime after recovery. Factory configuration accepts assetProjectionId, resourcePaths and executionTarget; direct load({assetProjectionId,resourcePaths,executionTarget,signal}) and Core decisions.load({assetProjectionId,resourcePaths,executionTarget}) preserve omitted/undefined selections, with the Core request signal forwarded separately. resourcePaths maps model, tokenizer and tokenizerConfig to exact ready projection member.path values; complete companion members retain their relative paths. Supplied projections take precedence over configured paths/upstream settings, are retained through the existing model-assets owner, and never invoke upstream preparation or fetching; unavailable projections or mapped members fail directly. assetProjectionId:null returns to configured paths or existing upstream preparation, independently of executionTarget:null requesting automatic device selection. Equal source, complete mapping and target selections coalesce; changed selections cancel pending work and join the prior model's disposal before replacement. Incoming retained ownership protects projection files while the previous activation retires; caller preparation ownership remains independent, and native use retains files through actual ONNX/tokenizer exit. pendingActivation includes a projected source/mapping separately from the full activation execution record and its nested execution diagnostics. Native load/evaluate/classify/current/subscribe/unload/dispose preserve complete results; RPC uses the existing tensor codec. Unload has accepted service lifetime; host shutdown cancels request-lifetime load/evaluation."
+      "protocol": "arcane/1 decisions.status/load/evaluate/unload and decisions.state. Factory, direct load and decisions.load accept family/model/revision/dtype with the direct model's exact variant, omission and replacement semantics. The service persists across explicit model changes; top-level activation metadata and pendingActivation distinguish the retiring and requested selections.",
+      "normalization": "Registration starts no model or tokenizer. Explicit load obtains dependency-ready same-process owners and reacquires getONNXRuntime after recovery. Factory configuration accepts family, model, revision, dtype, assetProjectionId, resourcePaths and executionTarget; direct load({family,model,revision,dtype,assetProjectionId,resourcePaths,executionTarget,signal}) and Core decisions.load({family,model,revision,dtype,assetProjectionId,resourcePaths,executionTarget}) preserve omitted/undefined selections, with the Core request signal forwarded separately. resourcePaths maps model, tokenizer and tokenizerConfig to exact ready projection member.path values; complete companion members retain their relative paths. Supplied projections take precedence over configured paths/upstream settings, are retained through the existing model-assets owner, and never invoke upstream preparation or fetching; unavailable projections or mapped members fail directly. assetProjectionId:null returns to configured paths or existing upstream preparation, independently of executionTarget:null requesting automatic device selection. Equal family, model, revision, dtype, source, complete mapping and target selections coalesce; changed selections cancel pending work and join the prior model's disposal before replacement. Incoming retained ownership protects projection files while the previous activation retires; caller preparation ownership remains independent, and native use retains files through actual ONNX/tokenizer exit. pendingActivation includes a projected source/mapping separately from the full activation execution record and its nested execution diagnostics. Native load/evaluate/classify/current/subscribe/unload/dispose preserve complete results; RPC uses the existing tensor codec. Unload has accepted service lifetime; host shutdown cancels request-lifetime load/evaluation."
     },
     {
       "id": "core-decisions:default",

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` | `{assetProjectionId?, resourcePaths?, executionTarget?}`; explicit activation or source/device replacement, returning the ready lifecycle snapshot. The request signal cancels activation. A target is `{deviceId:string}` or `null`. |
+| `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,18 @@ 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
 
@@ -144,7 +151,7 @@ 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({assetProjectionId, resourcePaths, executionTarget, signal})`; their
+`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
@@ -161,7 +168,8 @@ 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 source, mapping and device selections
+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
@@ -178,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
@@ -189,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
@@ -228,15 +283,16 @@ 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
+`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 source, resource mapping and target share their
+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
@@ -280,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 source, mapping and 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
@@ -304,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.80.0",
+  "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);

package/src/core/services/decisions.mjs

@@ -10,6 +10,7 @@ function sameExecutionTarget(left, right) {
 
 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);
@@ -32,6 +33,10 @@ export function createNativeDecisionService(configuration = {}, {appRoot = proce
     let closing;
     let unsubscribe;
     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}})
     };
@@ -40,7 +45,7 @@ export function createNativeDecisionService(configuration = {}, {appRoot = proce
 
     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
@@ -66,12 +71,19 @@ export function createNativeDecisionService(configuration = {}, {appRoot = proce
 
     function operationSignal(signal) { return signal ? AbortSignal.any([signal, lifetime.signal]) : lifetime.signal; }
 
-    function load({signal, executionTarget: requestedTarget, assetProjectionId: requestedProjection, resourcePaths: requestedPaths} = {}) {
+    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 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})
         };
@@ -116,6 +128,7 @@ export function createNativeDecisionService(configuration = {}, {appRoot = proce
                 );
                 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
                 });
@@ -221,6 +234,7 @@ export function createNativeDecisionService(configuration = {}, {appRoot = proce
             'decisions.status': current,
             '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
                 });

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});
@@ -18,6 +24,7 @@ function sameExecutionTarget(left, right) {
 }
 
 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;
@@ -27,15 +34,15 @@ function sameActivation(left, right) {
 }
 
 /**
- * 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, assetProjectionId, resourcePaths,
-    model = 'onnx-community/laya-typed-decisions-ONNX', revision = 'main',
+    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();
@@ -49,15 +56,17 @@ export function createNativeDecisionModel({
     let lastError = null;
     let execution = null;
     let selectedActivation = {
-        executionTarget,
+        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,
@@ -163,10 +172,14 @@ export function createNativeDecisionModel({
         }
         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); }
         });
@@ -176,7 +189,7 @@ 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(request) {
@@ -187,6 +200,7 @@ export function createNativeDecisionModel({
         request.retained = undefined;
         request.entry = entry;
         activation = entry;
+        activeSelection = entry.selection;
         state = 'loading';
         progress = {phase: 'preparing-model'};
         lastError = null;
@@ -196,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) {
@@ -258,14 +273,22 @@ export function createNativeDecisionModel({
         }).finally(function detachLoadCaller() { operationSignal?.removeEventListener('abort', abort); });
     }
 
-    async function load({signal: operationSignal, executionTarget: requestedTarget, assetProjectionId: requestedProjection, resourcePaths: requestedPaths} = {}) {
+    async function load({
+        family: requestedFamily, model: requestedModel, revision: requestedRevision, dtype: requestedDtype,
+        signal: operationSignal, executionTarget: requestedTarget, assetProjectionId: requestedProjection, resourcePaths: requestedPaths
+    } = {}) {
         assertOpen(operationSignal);
         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);
         }