arcane-os 0.79.1 → 0.81.0

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # 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
+  direct, service and Core `decisions.load` calls. A supplied ready projection
+  uses complete already-prepared model/tokenizer files through the existing
+  model-assets owner, without upstream preparation or another download.
+- Retain projected files through actual native ONNX and tokenizer exit, including
+  failure and cancellation. Acquire incoming ownership before retiring a prior
+  activation; coalesce only equal source, complete mapping and device selections.
+  Surface provisional cleanup failures through load, unload and disposal.
+- Preserve caller preparation ownership, original companion-file paths, complete
+  rows and outputs, configured native paths and ordinary explicit upstream
+  loading. Explicit `assetProjectionId:null` returns to that configured source.
+  Missing projections or mapped members report their actual errors.
+- Keep native Laya FP32 selection and existing runtime dependencies unchanged.
+  This release adds no model variant, GGUF route, driver, model download on
+  startup or automatic preference change.
+
 ## 0.79.1
 
 - Classify generic speech-model progress callbacks as loading, reserving

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.79.1` 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,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. Explicit load prepares selected upstream files or uses caller-owned paths. load({executionTarget,signal}) retains the latest selected target when omitted or undefined, initially the factory selection; 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. Same-target loads share activation; a changed target cancels the earlier request and joins its actual ONNX/tokenizer cleanup before replacement. pendingActivation reports the requested replacement 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; files remain retained through actual ONNX and tokenizer Worker exit. 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 executionTarget; direct load({executionTarget,signal}) and Core decisions.load({executionTarget}) preserve omitted/undefined selection and explicit null automatic selection. Same-target loads coalesce; changed targets cancel pending work and join the prior model's disposal before replacement. pendingActivation remains separate 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/model-assets.md

@@ -168,6 +168,39 @@ Closing a browser accessor does not by itself establish native unload.
 Explicitly release unused prepared projections. Core disposal also releases
 preparation ownership and cleans up after retained engine uses end.
 
+### Native Laya decisions
+
+The existing native decision owner also consumes ready projections through
+`decisions.load({assetProjectionId, resourcePaths, executionTarget?})` over Core,
+or the direct/service `load` method with an optional `signal`. Supply all three
+resource roles with exact projection member paths:
+
+```js
+try {
+    await client.invoke('decisions.load', {
+        assetProjectionId: projection.id,
+        resourcePaths: {
+            model: 'onnx/model.onnx',
+            tokenizer: 'tokenizer.json',
+            tokenizerConfig: 'tokenizer_config.json'
+        }
+    }, {signal, timeoutMs: 0});
+} finally {
+    await projection.release();
+}
+```
+
+The complete projection must also retain the graph's companion files, including
+`onnx/model.onnx_data` for the selected Laya FP32 graph. The native owner resolves
+the three roles from `retain(id).members` and uses those files directly without
+calling `prepare` or downloading again. It releases its native use only after
+actual ONNX and tokenizer exit; it never releases the caller's preparation
+ownership. Replacement acquires incoming ownership before retiring the prior
+activation, including when only its device changes. Unavailable or incomplete
+selections report their errors without an upstream fallback. See
+[native decisions](native-decisions.md#load-complete-files-already-stored-in-dbopfs)
+for source selection, cancellation and complete row/output contracts.
+
 `current()` returns `{closing,projections}`. Each projection reports its `id`,
 `directory`, `state`, ordered `members`, `preparationOwned`, number of native
 `uses`, and `error`. Core emits `modelAssets.state` for lifecycle changes.