arcane-os 0.80.0 → 0.82.0

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

@@ -0,0 +1,80 @@
+using System;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Arcane.Core.Hosts.Windows
+{
+    /// <summary>The shared native transport framing; callers own stream lifetime and ordered writes.</summary>
+    internal static class ArcaneFrameTransport
+    {
+        private static readonly Encoding Utf8 = new UTF8Encoding(false, true);
+        private static readonly Encoding Ascii = Encoding.GetEncoding(
+            "us-ascii", EncoderFallback.ExceptionFallback, DecoderFallback.ExceptionFallback);
+
+        internal static async Task WriteAsync(Stream stream, string json)
+        {
+            byte[] body = Utf8.GetBytes(json);
+            // Length belongs only to the Content-Length transport frame.
+            byte[] header = Ascii.GetBytes("Content-Length: " + body.Length.ToString(CultureInfo.InvariantCulture) + "\r\n\r\n");
+            await stream.WriteAsync(header, 0, header.Length).ConfigureAwait(false);
+            await stream.WriteAsync(body, 0, body.Length).ConfigureAwait(false);
+            await stream.FlushAsync().ConfigureAwait(false);
+        }
+
+        internal static async Task<string> ReadAsync(Stream stream)
+        {
+            using (MemoryStream header = new MemoryStream())
+            using (MemoryStream body = new MemoryStream())
+            {
+                try
+                {
+                    byte[] next = new byte[1];
+                    byte[] separator = new byte[] { 13, 10, 13, 10 };
+                    int matched = 0;
+                    while (matched != separator.Length)
+                    {
+                        int read = await stream.ReadAsync(next, 0, 1).ConfigureAwait(false);
+                        if (read == 0)
+                        {
+                            if (header.Length == 0) return null;
+                            throw new EndOfStreamException("Core transport ended during a frame header.");
+                        }
+                        header.WriteByte(next[0]);
+                        matched = next[0] == separator[matched] ? matched + 1 : next[0] == 13 ? 1 : 0;
+                    }
+                    byte[] headerBytes = header.ToArray();
+                    string headerText = Ascii.GetString(headerBytes, 0, headerBytes.Length - separator.Length);
+                    long? contentLength = null;
+                    foreach (string line in headerText.Split(new string[] { "\r\n" }, StringSplitOptions.None))
+                    {
+                        if (!line.StartsWith("Content-Length:", StringComparison.OrdinalIgnoreCase)) continue;
+                        long length;
+                        if (contentLength.HasValue || !Int64.TryParse(line.Substring(15).Trim(), NumberStyles.None,
+                            CultureInfo.InvariantCulture, out length))
+                            throw new InvalidDataException("Core frame Content-Length is invalid.");
+                        contentLength = length;
+                    }
+                    if (!contentLength.HasValue) throw new InvalidDataException("Core frame Content-Length is missing.");
+                    long remaining = contentLength.Value;
+                    byte[] buffer = new byte[8192];
+                    while (remaining != 0)
+                    {
+                        int read = await stream.ReadAsync(buffer, 0, (int)Math.Min(remaining, buffer.Length)).ConfigureAwait(false);
+                        if (read == 0) throw new EndOfStreamException("Core transport ended during a frame body.");
+                        body.Write(buffer, 0, read);
+                        remaining -= read;
+                    }
+                    return Utf8.GetString(body.ToArray());
+                }
+                catch (Exception error)
+                {
+                    error.Data["frameHeader"] = header.ToArray();
+                    error.Data["frameBody"] = body.ToArray();
+                    throw;
+                }
+            }
+        }
+    }
+}

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

@@ -16,6 +16,7 @@ namespace Arcane.Core.Hosts.Windows
     /// <summary>Selected by the application launcher; no OS layout is inferred.</summary>
     public sealed class ArcaneHostOptions
     {
+        public string ApplicationId { get; set; }
         public string ApplicationRoot { get; set; }
         public string StartPath { get; set; }
         public string OriginHost { get; set; }
@@ -23,6 +24,8 @@ namespace Arcane.Core.Hosts.Windows
         public string Title { get; set; }
         public string IconPath { get; set; }
         public string ClassicClientSource { get; set; }
+        public string AppControlEndpoint { get; set; }
+        public string AppControlSource { get; set; }
         public string CoreExecutable { get; set; }
         public string CoreArguments { get; set; }
         public string CoreWorkingDirectory { get; set; }
@@ -91,7 +94,7 @@ namespace Arcane.Core.Hosts.Windows
     /// to retired documents; errors stay outside ordinary application content.
     /// Callbacks must not synchronously wait for Ready, Completion or CloseAsync.
     /// </summary>
-    public sealed class ArcaneHostForm : Form
+    public sealed partial class ArcaneHostForm : Form
     {
         private const string CancelRendererRequests = "{\"protocol\":\"arcane/1\",\"type\":\"control\",\"control\":\"requests.cancelAll\"}";
         private readonly ArcaneHostOptions options;
@@ -124,6 +127,7 @@ namespace Arcane.Core.Hosts.Windows
         private bool started;
         private bool documentReady;
         private bool deliveryScheduled;
+        private bool browserProcessExited;
         private bool closing;
         private bool closeAllowed;
 
@@ -212,6 +216,7 @@ namespace Arcane.Core.Hosts.Windows
                 string profile = Path.GetFullPath(options.ProfileDirectory);
                 Uri origin = new UriBuilder(Uri.UriSchemeHttps, options.OriginHost).Uri;
                 Uri start = new Uri(origin, options.StartPath);
+                StartAppControl();
                 iconLoading = LoadApplicationIconAsync();
                 iconLoading.ContinueWith(ObserveUnexpectedFailure, TaskContinuationOptions.OnlyOnFaulted);
                 core = ArcaneCoreProcess.Start(options.CoreExecutable, options.CoreArguments,
@@ -227,7 +232,13 @@ namespace Arcane.Core.Hosts.Windows
                 InstallDocumentBridge(generation);
                 // The selected generator uses replayRuntimeState:true. Both RPC
                 // installation and the shared event owner remain SDK-owned.
-                injectedScript = await browser.AddScriptToExecuteOnDocumentCreatedAsync(options.ClassicClientSource);
+                Task scripts = Task.WhenAll(InstallClassicClientAsync(browser), InstallAppControlAsync(browser));
+                try { await scripts; }
+                catch
+                {
+                    if (scripts.Exception != null) throw scripts.Exception;
+                    throw;
+                }
                 if (closing) return;
                 browser.NavigationStarting += NavigationStarting;
                 browser.NavigationCompleted += NavigationCompleted;
@@ -243,6 +254,11 @@ namespace Arcane.Core.Hosts.Windows
             finally { initialized.TrySetResult(null); }
         }
 
+        private async Task InstallClassicClientAsync(CoreWebView2 browser)
+        {
+            injectedScript = await browser.AddScriptToExecuteOnDocumentCreatedAsync(options.ClassicClientSource);
+        }
+
         private void NavigationStarting(object sender, CoreWebView2NavigationStartingEventArgs args)
         {
             if (nextGeneration != 0 && navigationId == args.NavigationId) return;
@@ -551,11 +567,30 @@ 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)
+            {
+                AppControlRendererExited();
+                CoreFailed(error);
+            }
             else Report(error);
         }
 
@@ -665,7 +700,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);
@@ -711,6 +746,7 @@ namespace Arcane.Core.Hosts.Windows
             if (!started) initialized.TrySetResult(null);
             if (bridge != null) bridge.Stop(new InvalidOperationException("The application window is closing."));
             if (activeBridge != null) activeBridge.Stop(new InvalidOperationException("The application window is closing."));
+            StopAppControl();
             shutdown = DrainAndCloseAsync();
             shutdown.ContinueWith(ObserveUnexpectedFailure, TaskContinuationOptions.OnlyOnFaulted);
         }
@@ -737,6 +773,7 @@ namespace Arcane.Core.Hosts.Windows
                     catch (Exception error) { ReportTaskFailure(coreLifetime, error); }
                 }
             }
+            await DrainAppControlAsync();
             // Joining the independent image owner belongs after Core input has
             // closed; image I/O must never delay accepted service work draining.
             if (iconLoading != null)
@@ -761,10 +798,11 @@ 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);
+                    if (appControlScript != null) webView.CoreWebView2.RemoveScriptToExecuteOnDocumentCreated(appControlScript);
                 }
             }
             catch (Exception error) { Report(error); }

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

@@ -85,8 +85,11 @@ namespace Arcane.Core.Hosts.Windows
                     ? Path.GetFullPath((string)stateRoot)
                     : Path.Combine(defaultStateBase, "Arcane", appId);
                 OpenDiagnostics(Path.Combine(profileParent, "Diagnostics"));
+                Dictionary<string, object> appControl = launchContext.ContainsKey("appControl")
+                    ? RequiredRecord(launchContext, "appControl") : null;
                 ArcaneHostOptions options = new ArcaneHostOptions
                 {
+                    ApplicationId = appId,
                     ApplicationRoot = Path.GetFullPath(Path.Combine(directory, RequiredString(manifest, "webRoot"))),
                     StartPath = RequiredString(manifest, "start"),
                     OriginHost = "arcane.local",
@@ -97,6 +100,8 @@ namespace Arcane.Core.Hosts.Windows
                     Resizable = OptionalWindowResizable(windowOptions),
                     IconPath = String.IsNullOrEmpty(icon) ? null : Path.Combine(directory, icon),
                     ClassicClientSource = File.ReadAllText(Path.Combine(directory, RequiredString(client, "source"))),
+                    AppControlEndpoint = appControl == null ? null : RequiredString(appControl, "endpoint"),
+                    AppControlSource = appControl == null ? null : File.ReadAllText(Path.Combine(directory, "arcane-app-control.js")),
                     CoreExecutable = Path.Combine(directory, "runtime", "ArcaneCore.exe"),
                     // Forward the actual host selection separately; Core keeps
                     // every explicit launch-record field unchanged.

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

@@ -0,0 +1,248 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Web.WebView2.Core;
+
+namespace Arcane.Core.Hosts.Windows
+{
+    // The form owns UI-thread dispatch and document lifetime. The pipe owner
+    // handles only connections and framed requests, never another Core child.
+    public sealed partial class ArcaneHostForm
+    {
+        private const string AppControlDocumentKey = "Symbol.for('arcane-os.app-control.document')";
+        private readonly HashSet<Task> appControlDocumentTasks = new HashSet<Task>();
+        private ArcaneAppControl appControl;
+        private Task appControlClosing;
+        private string appControlScript;
+        private string appControlDocument;
+        private long appControlGeneration;
+        private long appControlDocumentEpoch;
+        private ulong appControlNavigationId;
+        private bool appControlNavigating;
+
+        private void StartAppControl()
+        {
+            if (options.AppControlEndpoint == null) return;
+            if (String.IsNullOrEmpty(options.AppControlSource))
+                throw new ArgumentException("Supply the SDK-generated app-control source for the selected endpoint.");
+            appControl = new ArcaneAppControl(options.AppControlEndpoint, DispatchAppControl, DeliverDiagnostic, Report);
+            appControl.Completion.ContinueWith(ObserveUnexpectedFailure, TaskContinuationOptions.OnlyOnFaulted);
+        }
+
+        private async Task InstallAppControlAsync(CoreWebView2 browser)
+        {
+            if (appControl == null) return;
+            appControlScript = await browser.AddScriptToExecuteOnDocumentCreatedAsync(
+                "globalThis[" + AppControlDocumentKey + "] = globalThis.crypto.randomUUID();");
+            if (closing) return;
+            browser.NavigationStarting += AppControlNavigationStarting;
+            browser.NavigationCompleted += AppControlNavigationCompleted;
+        }
+
+        private void StopAppControl()
+        {
+            if (appControl == null || appControlClosing != null) return;
+            appControlClosing = appControl.CloseAsync();
+        }
+
+        private async Task DrainAppControlAsync()
+        {
+            // Ingress stops in BeginClose. Join only after the existing Core
+            // cancellation/close has started, with the UI pump still alive.
+            if (appControlClosing != null)
+            {
+                try { await appControlClosing; }
+                catch (Exception error) { ReportTaskFailure(appControlClosing, error); }
+            }
+            Task documents = Task.WhenAll(appControlDocumentTasks);
+            try { await documents; }
+            catch (Exception error) { ReportTaskFailure(documents, error); }
+        }
+
+        private void AppControlNavigationStarting(object sender, CoreWebView2NavigationStartingEventArgs args)
+        {
+            appControlNavigationId = args.NavigationId;
+            appControlDocumentEpoch++;
+            appControlNavigating = true;
+        }
+
+        private void AppControlNavigationCompleted(object sender, CoreWebView2NavigationCompletedEventArgs args)
+        {
+            if (closing || browserProcessExited || args.NavigationId != appControlNavigationId) return;
+            // A cancelled navigation may leave the old document alive. Read its
+            // actual creation marker instead of treating every attempt as new.
+            Task task = RefreshAppControlDocumentAsync(args.NavigationId, appControlDocumentEpoch);
+            appControlDocumentTasks.Add(task);
+            task.ContinueWith(AppControlDocumentSettled, CancellationToken.None,
+                TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext());
+        }
+
+        private void AppControlRendererExited()
+        {
+            appControlDocumentEpoch++;
+            appControlDocument = null;
+            appControlNavigating = true;
+        }
+
+        private async Task RefreshAppControlDocumentAsync(ulong selectedNavigation, long selectedEpoch)
+        {
+            string json = await webView.CoreWebView2.ExecuteScriptAsync("globalThis[" + AppControlDocumentKey + "]");
+            if (closing || browserProcessExited || selectedNavigation != appControlNavigationId
+                || selectedEpoch != appControlDocumentEpoch) return;
+            string current = ArcaneHost.Serializer().DeserializeObject(json) as string;
+            if (current == null) throw new InvalidOperationException("The current document has no app-control lifecycle marker.");
+            if (current != appControlDocument)
+            {
+                appControlDocument = current;
+                appControlGeneration++;
+            }
+            appControlNavigating = false;
+        }
+
+        private void AppControlDocumentSettled(Task task)
+        {
+            appControlDocumentTasks.Remove(task);
+            if (task.IsFaulted) ReportTaskFailure(task, task.Exception);
+        }
+
+        private Task<object> DispatchAppControl(string method, Dictionary<string, object> parameters,
+            CancellationToken cancellation)
+        {
+            AppControlRequest request = new AppControlRequest(this, method, parameters, cancellation);
+            try
+            {
+                // The form's owned message pump stays alive through control and
+                // Core drain. No foreground window or desktop input is selected.
+                BeginInvoke(new Action(request.Run));
+            }
+            catch (Exception error) { request.Completion.TrySetException(error); }
+            return request.Completion.Task;
+        }
+
+        private bool AppControlDocumentReady()
+        {
+            return !closing && !browserProcessExited && !appControlNavigating
+                && appControlDocument != null && webView.CoreWebView2 != null;
+        }
+
+        private Dictionary<string, object> AppControlStatus()
+        {
+            return new Dictionary<string, object>
+            {
+                { "app", new Dictionary<string, object> { { "id", options.ApplicationId }, { "name", options.Title } } },
+                { "platform", "windows" }, { "host", "webview2" },
+                { "url", webView.Source == null ? null : webView.Source.AbsoluteUri },
+                { "documentGeneration", appControlGeneration }, { "ready", AppControlDocumentReady() },
+                { "window", new Dictionary<string, object>
+                    { { "title", Text }, { "state", WindowState.ToString() },
+                      { "width", ClientSize.Width }, { "height", ClientSize.Height } } },
+                { "operations", new string[] { "status", "inspect", "capture", "act" } }
+            };
+        }
+
+        private async Task<object> ExecuteAppControlAsync(string method, Dictionary<string, object> parameters,
+            CancellationToken cancellation)
+        {
+            cancellation.ThrowIfCancellationRequested();
+            if (method == "app.control.status") return AppControlStatus();
+            if (method != "app.control.inspect" && method != "app.control.capture" && method != "app.control.act")
+                throw new ArgumentException("Unknown app-control method: " + method);
+            if (!AppControlDocumentReady()) throw new InvalidOperationException("The app document is not ready for control.");
+            long selectedGeneration = appControlGeneration;
+            string selectedDocument = appControlDocument;
+            string selectedUrl = webView.Source == null ? null : webView.Source.AbsoluteUri;
+            object expected;
+            if (method == "app.control.act" && !parameters.ContainsKey("documentGeneration"))
+                throw new ArgumentException("An action requires the documentGeneration returned by status or inspect.");
+            if (parameters.TryGetValue("documentGeneration", out expected)
+                && (!(expected is int || expected is long || expected is decimal || expected is double)
+                    || Convert.ToDouble(expected) != selectedGeneration))
+                throw new InvalidOperationException("The selected app document has been replaced.");
+
+            object result;
+            if (method == "app.control.capture")
+            {
+                using (MemoryStream image = new MemoryStream())
+                {
+                    await webView.CoreWebView2.CapturePreviewAsync(CoreWebView2CapturePreviewImageFormat.Png, image);
+                    result = new Dictionary<string, object>
+                    {
+                        { "mimeType", "image/png" }, { "data", Convert.ToBase64String(image.ToArray()) }
+                    };
+                }
+            }
+            else
+            {
+                string operation = method == "app.control.inspect" ? "inspect" : "act";
+                // The creation marker is checked inside the executing document.
+                // Native generation checks alone cannot stop a queued script
+                // from reaching a successor document during navigation.
+                string script = "(function(expected,operation,parameters){"
+                    + "if(globalThis[" + AppControlDocumentKey + "]!==expected)"
+                    + "return {ok:false,error:{code:'APP_CONTROL_DOCUMENT_REPLACED',message:'The selected app document has been replaced.'}};"
+                    + "return (" + options.AppControlSource + ")(operation,parameters);})("
+                    + ArcaneHost.Serializer().Serialize(selectedDocument) + ","
+                    + ArcaneHost.Serializer().Serialize(operation) + ","
+                    + ArcaneHost.Serializer().Serialize(parameters) + ")";
+                string json = await webView.CoreWebView2.ExecuteScriptAsync(script);
+                Dictionary<string, object> envelope = ArcaneHost.Serializer().DeserializeObject(json) as Dictionary<string, object>;
+                object ok;
+                if (envelope == null || !envelope.TryGetValue("ok", out ok) || !(ok is bool))
+                    throw new InvalidDataException("The document returned no app-control result.");
+                if (!(bool)ok)
+                {
+                    object detail;
+                    envelope.TryGetValue("error", out detail);
+                    IOException error = new IOException("The document app-control operation failed.");
+                    error.Data["documentError"] = detail;
+                    throw error;
+                }
+                if (!envelope.TryGetValue("result", out result))
+                    throw new InvalidDataException("The document omitted the app-control result.");
+            }
+            // Completion is observed after dispatch even if a caller cancelled.
+            // A document change is reported with the actual returned result; it
+            // neither retries an action nor claims its effects were reversed.
+            if (!AppControlDocumentReady() || appControlGeneration != selectedGeneration || appControlDocument != selectedDocument)
+            {
+                IOException error = new IOException("The app document changed while the operation was completing.");
+                error.Data["result"] = result;
+                error.Data["documentGeneration"] = selectedGeneration;
+                error.Data["url"] = selectedUrl;
+                throw error;
+            }
+            Dictionary<string, object> record = result as Dictionary<string, object>;
+            if (record == null) throw new InvalidDataException("The app-control result must be an object.");
+            record["documentGeneration"] = selectedGeneration;
+            record["url"] = webView.Source == null ? null : webView.Source.AbsoluteUri;
+            return record;
+        }
+
+        private sealed class AppControlRequest
+        {
+            private readonly ArcaneHostForm window;
+            private readonly string method;
+            private readonly Dictionary<string, object> parameters;
+            private readonly CancellationToken cancellation;
+            internal readonly TaskCompletionSource<object> Completion = new TaskCompletionSource<object>();
+
+            internal AppControlRequest(ArcaneHostForm window, string method,
+                Dictionary<string, object> parameters, CancellationToken cancellation)
+            {
+                this.window = window;
+                this.method = method;
+                this.parameters = parameters;
+                this.cancellation = cancellation;
+            }
+
+            internal async void Run()
+            {
+                try { Completion.TrySetResult(await window.ExecuteAppControlAsync(method, parameters, cancellation)); }
+                catch (OperationCanceledException) { Completion.TrySetCanceled(); }
+                catch (Exception error) { Completion.TrySetException(error); }
+            }
+        }
+    }
+}

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
                 });