arcane-os 0.84.0 → 0.86.0

package/docs/reference/sdk-api.md

@@ -55,6 +55,8 @@ runtime layouts.
 | `arcane-os/core/contracts` | Shared Core protocol, frame, method and diagnostic error contracts. |
 | `arcane-os/core/classic-source` | Node generator for the canonical classic-script Core client projection. |
 | `arcane-os/core/runtime` | App-neutral native Core dispatcher and service lifecycle. |
+| `arcane-os/core/model-observation` | Passive observation of an existing Core and its actual native model service owners. |
+| `arcane-os/ai/model-observation` | Attach existing renderer model owners and subscribe through an existing Core client. |
 | `arcane-os/core/development` | App-service composition and document-owned Core transport during source development, independently of local AI. |
 | `arcane-os/core/stdio` | Framed Node stdio transport with graceful runtime drain. |
 | `arcane-os/core/host` | Node-only reusable Core host lifecycle, app-selected native launch defaults and shared native location resolution. |
@@ -420,6 +422,9 @@ The remaining data-only subpaths are eight JSON Schemas and package metadata.
 | `McpProtocolError` | class | `arcane-os/mcp/stdio` | MCP STDIO | Node |
 | `createCoreClassicSource()` | function | `arcane-os/core/classic-source` | Core classic client projection | Node; generated source runs in browser and native WebView renderers |
 | `createCoreRuntime()` | function | `arcane-os/core/runtime` | Native Core runtime | Node on Windows, Linux and macOS native hosts; Android requires host adaptation |
+| `createModelObservationService()` | function | `arcane-os/core/model-observation` | Existing model observation | Node with an existing Core runtime and optional existing native model services |
+| `attachModelObservation()` | function | `arcane-os/ai/model-observation` | Existing model observation | JavaScript with an existing Core client and optional existing renderer owners |
+| `subscribeModelObservation()` | function | `arcane-os/ai/model-observation` | Existing model observation | JavaScript with an existing Core client and composed observation service |
 | `encodeCoreFrame()` | function | `arcane-os/core/stdio` | Native Core stdio transport | Node |
 | `createCoreFrameDecoder()` | function | `arcane-os/core/stdio` | Native Core stdio transport | Node |
 | `startCoreStdio()` | function | `arcane-os/core/stdio` | Native Core stdio transport | Node |
@@ -7395,13 +7400,17 @@ Import it from `arcane-os/core/runtime`. The runtime exposes `current()`,
 `subscribe()`, `onFrame()`, `emit()`, `registerService()`, `getService()`, `start()`, `handle()`
 and idempotent `close()`.
 
-`runtime.handle(frame, {contextRequestId})` optionally preserves a transport's
-original client ID in handler `context.requestId`, while `context.coreRequestId`
-always exposes the actual internal `frame.id`. Active requests, cancellation,
-response IDs and request-event envelopes retain that internal ID. Ordinary
-`handle(frame)` exposes both context IDs equal to `frame.id`. This metadata
-does not change parameters or event data; transports own client-facing protocol
-correlation. See [the runtime contract](core-runtime.md#state-and-frames).
+`runtime.handle(frame, {contextRequestId, contextClientRequestId})` accepts
+optional nonempty transport metadata strings. Handler `requestId` remains
+`contextRequestId ?? frame.id`; additive `clientRequestId` is
+`contextClientRequestId ?? contextRequestId ?? frame.id`; `coreRequestId` always
+exposes the actual internal `frame.id`. Direct `handle(frame)` exposes all three
+equal. Stdio and both IPC paths supply the actual client identity separately,
+preserving the owning shared-host adapter's established internal `requestId`.
+Active requests, cancellation, response IDs and request-event envelopes retain
+the internal ID. Parameters, results and event data stay unchanged; transports
+own client-facing protocol correlation. See
+[the runtime contract](core-runtime.md#state-and-frames).
 
 `await runtime.getService(name)` and service `context.getService(name)` return
 the actual registered service after its shared startup. They wait for that
@@ -7588,6 +7597,80 @@ const transport = startCoreStdio({runtime});
 await transport.closed;
 ```
 
+## createModelObservationService()
+
+```text
+createModelObservationService({runtime,localAI=null,image=null,decisions=null}={})
+```
+
+Import from `arcane-os/core/model-observation`. Supply the existing Core runtime
+and actual native service definitions, including their `current()` and `methods`.
+Returns `{name:'model-observation',current,dispose,methods}`. Register it on that
+runtime after ordinary host creation and before opening an additional listener.
+Construction starts no service, model, worker or readiness wait.
+
+The four methods are `model.observation.current`, `model.observation.watch`,
+`model.observation.renderer.attach` and `model.observation.renderer.publish`.
+`current()` returns `{core,native:{localAI,image,decisions},renderers}` from the
+supplied owners. Absent model owners are `null`; absent attachments produce `[]`.
+The watch replays current state and remains pending until cancellation. Its
+`diagnostics:false` default excludes live failure frames; explicit `true`
+observes complete failed Core responses for the supplied owners' method keys.
+It retains no failure history and invents no model-operation identities.
+
+Renderer attachment and watch acknowledgements use actual `clientRequestId`;
+attachments are keyed by the actual `coreRequestId` to distinguish clients with
+equal local IDs. `dispose()` retires observation requests/subscriptions only.
+Core still owns model services and shutdown. See
+[complete methods, events and evidence limits](model-observation.md).
+
+## attachModelObservation()
+
+```text
+attachModelObservation({client,aiRuntimeState=null,imageRuntime=null,decisionModel=null,modelController=null,signal,onError}={})
+```
+
+Import from `arcane-os/ai/model-observation`. Pass the existing Core client and
+the application-owned instances already doing the work. Supported owner methods
+are AIRuntimeState's `getAIRuntimeState/subscribeAIRuntimeState`, image runtime's
+`current/subscribe`, decision model's `status/subscribe`, and ModelController's
+`status/on`. It creates no replacement owner or transport.
+
+Returns `{ready,closed,current,close}`. `ready` resolves with the Core-supplied
+`{attachmentRequestId,coreRequestId}` acknowledgement. Subscriptions then publish
+complete current owner snapshots, including a fresh read after acknowledgement.
+`current()` returns the latest renderer snapshot, initially `null`. The existing
+Core error serializer represents owner `Error` fields at the JSON boundary;
+other fields remain unchanged.
+
+Caller abort, page retirement, retirement of the exact installed client,
+transport failure or `close()` retires only observation RPCs/subscriptions.
+`close()` returns `closed`; it never closes the supplied client or unloads models.
+Normal cancellation closes cleanly; cancellation before acknowledgement rejects
+`ready`. Other errors reject public promises and reach `onError`, defaulting to
+complete console diagnostics. A replacement client requires a new explicit
+attachment. Keep attachment readiness independent of page rendering. See
+[renderer ownership and lifecycle](model-observation.md#attach-existing-renderer-owners).
+
+## subscribeModelObservation()
+
+```text
+subscribeModelObservation({client,signal,onState,onDiagnostic,onError}={})
+```
+
+Import from `arcane-os/ai/model-observation`. Requires an existing client and
+`onState`; returns `{ready,closed,current,close}`. `ready` resolves with the first
+current-state snapshot and `current()` retains the latest snapshot, initially
+`null`. Providing `onDiagnostic` explicitly selects live complete correlated Core
+model failure frames; omission selects state only. These are developer
+diagnostics, not ordinary user status or saved conversation content.
+
+The observer uses the same observation-only cancellation/error lifecycle as
+the attachment. Callback failures retire it and reach `onError`; callback
+promises may await `close()` without becoming its completion barrier. It starts
+no model, refresh, polling, endpoint discovery, host or reconnect. See
+[observation records and limits](model-observation.md#read-or-subscribe-from-an-existing-client).
+
 ## createPortableNativeProvider()
 
 ### Overview
@@ -7621,6 +7704,13 @@ published SDK/runtime dependencies and the canonical Core entry/client into a
 fresh output directory. Service factories are imported only when a real native
 host later launches the generated Core entry, never during packaging.
 
+Explicit `native.launchContext.coreListener:{endpoint}` also composes one passive
+model observation service after `startCoreHost()` and before listener binding,
+using that runtime and existing services exposing `localai.status`, `image.status`
+and `decisions.status`. Missing owners remain `null`; renderer attachment stays
+application-owned. Ordinary stdio and shared/headless branches gain no model
+startup or readiness barrier. See [native observation composition](core-native-packaging.md#launch-time-locations).
+
 An optional `appDescriptor.native.window` record carries `width`, `height` and
 `resizable` into `manifest.window`. Dimensions are positive integral logical
 client units; `resizable` is an optional boolean. Omitted fields remain omitted.
@@ -8848,7 +8938,7 @@ borrowed listener implements no `core.host.shutdown` operation; use client
 `close()` for disconnection and the existing runtime's owner for host shutdown.
 
 Each connection owns response/event correlation and request cancellation.
-Handler `requestId` preserves the client ID; `coreRequestId` is the distinct
+Handler `requestId` and `clientRequestId` preserve the client ID; `coreRequestId` is the distinct
 internal dispatch ID. Parameters, results and event data, including
 `data.requestId`, remain unchanged. Runtime-state snapshots retain internal
 active IDs; no service event is invented or retained for later replay.
@@ -8867,6 +8957,9 @@ try {
 `host` is the application's existing stdio host. Generated native entries
 select this attachment with `native.launchContext.coreListener:{endpoint}`,
 preserving their actual runtime, service set, profile, origin and state root.
+That generated opt-in registers the passive observation service from existing
+native model owners before binding; direct `startCoreListener()` itself never
+registers services. Renderer owners are attached separately by the application.
 Omit `sharedHost`; the two options describe alternative lifetimes. Full
 contract: [existing-runtime listener](core-shared-host.md#attach-to-an-existing-window-owned-core).
 
@@ -8894,6 +8987,11 @@ service-owned. The supplied signal begins the same shutdown. `closed` rejects
 on shutdown failure; `onError` observes transport/background failures, with
 complete console diagnostics by default.
 
+The owning adapter preserves its existing internal handler `requestId`, equal
+to `coreRequestId`, and its matching `data.requestId` compatibility mapping.
+Additive `clientRequestId` exposes the original client ID independently; other
+parameters, results and event data remain unchanged.
+
 ### Availability and example
 
 Node supports app-selected named pipes on Windows and Unix-domain sockets on

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.84.0",
+  "version": "0.86.0",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",
@@ -43,6 +43,7 @@
     "./ai/core-onnx": "./browser-runtime/ai/core-onnx.mjs",
     "./ai/core-image": "./browser-runtime/ai/core-image.mjs",
     "./ai/core-model-assets": "./browser-runtime/ai/core-model-assets.mjs",
+    "./ai/model-observation": "./browser-runtime/ai/model-observation.mjs",
     "./ai/browser-decisions": "./browser-runtime/ai/browser-decisions.mjs",
     "./ai/tool-text-stream": "./browser-runtime/ai/tool-text-stream.mjs",
     "./ai/twin-cloud": "./browser-runtime/ai/twin-cloud.mjs",
@@ -75,6 +76,7 @@
     "./core/image": "./src/core/services/image.mjs",
     "./core/speech": "./src/core/services/speech.mjs",
     "./core/model-assets": "./src/core/services/model-assets.mjs",
+    "./core/model-observation": "./src/core/services/model-observation.mjs",
     "./diarization": "./src/diarization/index.mjs",
     "./diarization/build": "./src/diarization/build.mjs",
     "./local-ai": "./src/local-ai/install.mjs",

package/src/cli/app-control.mjs

@@ -8,6 +8,8 @@ const HELP_TEXT=`Usage:
   arcane app-control inspect --endpoint <pipe-or-socket> [--selector <css-selector> | --request <json-file>]
   arcane app-control capture --endpoint <pipe-or-socket> --output <png-file>
   arcane app-control act --endpoint <pipe-or-socket> --request <json-file>
+  arcane app-control key --endpoint <pipe-or-socket> --request <json-file>
+  arcane app-control resize --endpoint <pipe-or-socket> --request <json-file>
 
 Connects to the selected running native window. Results are complete JSON.
 Capture writes the PNG to --output and prints its metadata. Request and output
@@ -16,6 +18,9 @@ an application or change its profile. --output selects the capture filename;
 the other Arcane commands retain their existing output-format option.
 Inspect --request reads the complete parameter object, including shadowPath and
 optional documentGeneration. It cannot be combined with --selector.
+Key --request selects Tab (optionally shiftKey:true), Enter, or Space and the
+observed documentGeneration. Resize --request supplies native client width and
+height for a Normal window; its result includes the previous dimensions.
 `;
 
 function usage(message) {
@@ -29,9 +34,11 @@ function parseArguments(argv) {
         status: ['endpoint'],
         inspect: ['endpoint', 'selector', 'request'],
         capture: ['endpoint', 'output'],
-        act: ['endpoint', 'request']
+        act: ['endpoint', 'request'],
+        key: ['endpoint', 'request'],
+        resize: ['endpoint', 'request']
     }[action];
-    if (!Array.isArray(allowed)) usage('Expected app-control status, inspect, capture, or act.');
+    if (!Array.isArray(allowed)) usage('Expected app-control status, inspect, capture, act, key, or resize.');
     const values = {};
     for (let index = 1; index < argv.length; index += 1) {
         const argument = argv[index];
@@ -48,7 +55,9 @@ function parseArguments(argv) {
     }
     if (!values.endpoint) usage('App control requires --endpoint <pipe-or-socket>.');
     if (action === 'capture' && !values.output) usage('App-control capture requires --output <png-file>.');
-    if (action === 'act' && !values.request) usage('App-control act requires --request <json-file>.');
+    if (['act', 'key', 'resize'].includes(action) && !values.request) {
+        usage(`App-control ${action} requires --request <json-file>.`);
+    }
     if (action === 'inspect' && values.request !== undefined && values.selector !== undefined) {
         usage('App-control inspect accepts --selector or --request, not both.');
     }
@@ -83,6 +92,8 @@ export async function runAppControlCli(argv, {cwd = process.cwd(), stdout = proc
         if (selection.action === 'status') result = await connection.status({signal});
         else if (selection.action === 'inspect') result = await connection.inspect(parameters, {signal});
         else if (selection.action === 'act') result = await connection.act(parameters, {signal});
+        else if (selection.action === 'key') result = await connection.key(parameters, {signal});
+        else if (selection.action === 'resize') result = await connection.resize(parameters, {signal});
         else {
             result = await connection.capture(parameters, {signal});
             const output = path.resolve(cwd, selection.output);

package/src/core/app-control.mjs

@@ -18,6 +18,8 @@ export async function connectAppControl({endpoint, signal, onError = reportAppCo
         inspect(parameters = {}, options) { return client.invoke('app.control.inspect', parameters, options); },
         capture(parameters = {}, options) { return client.invoke('app.control.capture', parameters, options); },
         act(parameters, options) { return client.invoke('app.control.act', parameters, options); },
+        key(parameters, options) { return client.invoke('app.control.key', parameters, options); },
+        resize(parameters, options) { return client.invoke('app.control.resize', parameters, options); },
         close() { return connection.close(); }
     };
 }

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

@@ -453,7 +453,8 @@ namespace Arcane.Core.Hosts.Windows
                         {
                             cancellation.Token.ThrowIfCancellationRequested();
                             if (method != "app.control.status" && method != "app.control.inspect"
-                                && method != "app.control.capture" && method != "app.control.act")
+                                && method != "app.control.capture" && method != "app.control.act"
+                                && method != "app.control.key" && method != "app.control.resize")
                                 throw new NotSupportedException("The app does not expose " + method + ".");
                             Dictionary<string, object> arguments = parameters as Dictionary<string, object>;
                             if (arguments == null)

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

@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
+using System.Drawing;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Windows.Forms;
 using Microsoft.Web.WebView2.Core;
 
 namespace Arcane.Core.Hosts.Windows
@@ -13,6 +15,7 @@ namespace Arcane.Core.Hosts.Windows
     {
         private const string AppControlDocumentKey = "Symbol.for('arcane-os.app-control.document')";
         private readonly HashSet<Task> appControlDocumentTasks = new HashSet<Task>();
+        private readonly SemaphoreSlim appControlKeyOwner = new SemaphoreSlim(1, 1);
         private ArcaneAppControl appControl;
         private Task appControlClosing;
         private string appControlScript;
@@ -59,6 +62,7 @@ namespace Arcane.Core.Hosts.Windows
             Task documents = Task.WhenAll(appControlDocumentTasks);
             try { await documents; }
             catch (Exception error) { ReportTaskFailure(documents, error); }
+            appControlKeyOwner.Dispose();
         }
 
         private void AppControlNavigationStarting(object sender, CoreWebView2NavigationStartingEventArgs args)
@@ -135,10 +139,17 @@ namespace Arcane.Core.Hosts.Windows
                 { "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" } }
+                { "window", AppControlWindow() },
+                { "operations", new string[] { "status", "inspect", "capture", "act", "key", "resize" } }
+            };
+        }
+
+        private Dictionary<string, object> AppControlWindow()
+        {
+            return new Dictionary<string, object>
+            {
+                { "title", Text }, { "state", WindowState.ToString() },
+                { "width", ClientSize.Width }, { "height", ClientSize.Height }
             };
         }
 
@@ -147,14 +158,16 @@ namespace Arcane.Core.Hosts.Windows
         {
             cancellation.ThrowIfCancellationRequested();
             if (method == "app.control.status") return AppControlStatus();
-            if (method != "app.control.inspect" && method != "app.control.capture" && method != "app.control.act")
+            if (method != "app.control.inspect" && method != "app.control.capture" && method != "app.control.act"
+                && method != "app.control.key" && method != "app.control.resize")
                 throw new ArgumentException("Unknown app-control method: " + method);
+            if (method == "app.control.resize") RequireAppControlNormalWindow();
             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"))
+            if ((method == "app.control.act" || method == "app.control.key") && !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)
@@ -173,34 +186,14 @@ namespace Arcane.Core.Hosts.Windows
                     };
                 }
             }
+            else if (method == "app.control.key")
+                result = await AppControlKeyAsync(parameters, cancellation, selectedGeneration, selectedDocument);
+            else if (method == "app.control.resize")
+                result = await AppControlResizeAsync(parameters, selectedGeneration, selectedDocument);
             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.");
+                result = await ReadAppControlDocumentAsync(operation, parameters, selectedDocument);
             }
             // Completion is observed after dispatch even if a caller cancelled.
             // A document change is reported with the actual returned result; it
@@ -220,6 +213,198 @@ namespace Arcane.Core.Hosts.Windows
             return record;
         }
 
+        private async Task<Dictionary<string, object>> ReadAppControlDocumentAsync(string operation,
+            Dictionary<string, object> parameters, string selectedDocument)
+        {
+            // 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;
+            }
+            object result;
+            if (!envelope.TryGetValue("result", out result))
+                throw new InvalidDataException("The document omitted the app-control result.");
+            Dictionary<string, object> record = result as Dictionary<string, object>;
+            if (record == null) throw new InvalidDataException("The app-control result must be an object.");
+            return record;
+        }
+
+        private async Task<object> AppControlKeyAsync(Dictionary<string, object> parameters,
+            CancellationToken cancellation, long selectedGeneration, string selectedDocument)
+        {
+            object value;
+            string key = parameters.TryGetValue("key", out value) ? value as string : null;
+            if (key != "Tab" && key != "Enter" && key != "Space")
+                throw new ArgumentException("key must be Tab, Enter, or Space.");
+            bool shiftKey = false;
+            if (parameters.TryGetValue("shiftKey", out value))
+            {
+                if (!(value is bool)) throw new ArgumentException("shiftKey must be a boolean.");
+                shiftKey = (bool)value;
+            }
+            if (shiftKey && key != "Tab") throw new ArgumentException("shiftKey is supported only with Tab.");
+            Dictionary<string, object> down = new Dictionary<string, object>
+            {
+                { "type", key == "Tab" ? "rawKeyDown" : "keyDown" },
+                { "key", key == "Space" ? " " : key }, { "code", key },
+                { "windowsVirtualKeyCode", key == "Tab" ? 9 : key == "Enter" ? 13 : 32 },
+                { "modifiers", shiftKey ? 8 : 0 }
+            };
+            Dictionary<string, object> up = new Dictionary<string, object>(down);
+            up["type"] = "keyUp";
+            if (key != "Tab")
+            {
+                down["text"] = key == "Enter" ? "\r" : " ";
+                down["unmodifiedText"] = down["text"];
+            }
+            Dictionary<string, object> press = new Dictionary<string, object>
+                { { "parameters", down }, { "attempted", false }, { "completed", false } };
+            Dictionary<string, object> release = new Dictionary<string, object>
+                { { "parameters", up }, { "attempted", false }, { "completed", false } };
+            Dictionary<string, object> result = new Dictionary<string, object>
+            {
+                { "key", key }, { "shiftKey", shiftKey }, { "press", press }, { "release", release },
+                { "documentGeneration", selectedGeneration },
+                { "url", webView.Source == null ? null : webView.Source.AbsoluteUri }
+            };
+            // Only keyboard pairs share this owner: an awaited down must not
+            // allow another accepted key to interleave before its owned up.
+            await appControlKeyOwner.WaitAsync(cancellation);
+            try
+            {
+                cancellation.ThrowIfCancellationRequested();
+                RequireAppControlDocument(selectedGeneration, selectedDocument);
+                result["previous"] = await ReadAppControlDocumentAsync("view", new Dictionary<string, object>(), selectedDocument);
+                cancellation.ThrowIfCancellationRequested();
+                RequireAppControlDocument(selectedGeneration, selectedDocument);
+                CoreWebView2 browser = webView.CoreWebView2;
+                string downJson = ArcaneHost.Serializer().Serialize(down);
+                string upJson = ArcaneHost.Serializer().Serialize(up);
+                Exception pressError = null;
+                Exception releaseError = null;
+                press["attempted"] = true;
+                try
+                {
+                    press["response"] = await browser.CallDevToolsProtocolMethodAsync("Input.dispatchKeyEvent", downJson);
+                    press["completed"] = true;
+                }
+                catch (Exception error) { pressError = error; }
+                // C# 5 cannot await in finally. This unconditional phase follows
+                // the observed down task, including failure/cancellation/navigation.
+                // Release can itself activate Space; it cannot undo the press.
+                release["attempted"] = true;
+                try
+                {
+                    release["response"] = await browser.CallDevToolsProtocolMethodAsync("Input.dispatchKeyEvent", upJson);
+                    release["completed"] = true;
+                }
+                catch (Exception error) { releaseError = error; }
+                try
+                {
+                    if (pressError != null) press["error"] = ArcaneHost.ErrorRecord(pressError, "ARCANE_APP_CONTROL_FAILED");
+                    if (releaseError != null) release["error"] = ArcaneHost.ErrorRecord(releaseError, "ARCANE_APP_CONTROL_FAILED");
+                    if (pressError != null && releaseError != null)
+                        throw new AggregateException("The key press and release failed.", pressError, releaseError);
+                    if (pressError != null) throw new IOException("The key press failed.", pressError);
+                    if (releaseError != null) throw new IOException("The key release failed.", releaseError);
+                    RequireAppControlDocument(selectedGeneration, selectedDocument);
+                    result["actual"] = await ReadAppControlDocumentAsync("view", new Dictionary<string, object>(), selectedDocument);
+                    return result;
+                }
+                catch (Exception error)
+                {
+                    throw AppControlOutcomeError("The app key operation did not complete normally.", error, result);
+                }
+            }
+            finally { appControlKeyOwner.Release(); }
+        }
+
+        private void RequireAppControlDocument(long selectedGeneration, string selectedDocument)
+        {
+            if (!AppControlDocumentReady() || appControlGeneration != selectedGeneration || appControlDocument != selectedDocument)
+                throw new InvalidOperationException("The selected app document has been replaced or is no longer ready.");
+        }
+
+        private void RequireAppControlNormalWindow()
+        {
+            if (WindowState == FormWindowState.Normal) return;
+            InvalidOperationException error = new InvalidOperationException("App-control resize requires a Normal window.");
+            error.Data["reason"] = "unsupported-window-state";
+            error.Data["supportedWindowState"] = "Normal";
+            error.Data["window"] = AppControlWindow();
+            throw error;
+        }
+
+        private static int AppControlDimension(Dictionary<string, object> parameters, string name)
+        {
+            object value;
+            if (!parameters.TryGetValue(name, out value)
+                || !(value is int || value is long || value is decimal || value is double))
+                throw new ArgumentException(name + " must be a positive integral native client dimension.");
+            double dimension = Convert.ToDouble(value);
+            if (Double.IsNaN(dimension) || dimension < 1 || dimension > Int32.MaxValue || dimension != Math.Truncate(dimension)
+                || (value is decimal && (decimal)value != Decimal.Truncate((decimal)value)))
+                throw new ArgumentException(name + " must be a positive integral native client dimension.");
+            return (int)dimension;
+        }
+
+        private async Task<object> AppControlResizeAsync(Dictionary<string, object> parameters,
+            long selectedGeneration, string selectedDocument)
+        {
+            int width = AppControlDimension(parameters, "width");
+            int height = AppControlDimension(parameters, "height");
+            // This check and immediate previous snapshot run in the same UI turn
+            // as the setter. Never normalize a maximized/minimized window.
+            RequireAppControlNormalWindow();
+            Dictionary<string, object> result = new Dictionary<string, object>
+            {
+                { "requested", new Dictionary<string, object> { { "width", width }, { "height", height } } },
+                { "previous", AppControlWindow() }, { "resizeAttempted", false }, { "resizeCompleted", false },
+                { "documentGeneration", selectedGeneration },
+                { "url", webView.Source == null ? null : webView.Source.AbsoluteUri }
+            };
+            try
+            {
+                result["resizeAttempted"] = true;
+                ClientSize = new Size(width, height);
+                result["resizeCompleted"] = true;
+                result["actual"] = AppControlWindow();
+                Dictionary<string, object> view = await ReadAppControlDocumentAsync("view", new Dictionary<string, object>(), selectedDocument);
+                result["viewport"] = view["viewport"];
+                return result;
+            }
+            catch (Exception error)
+            {
+                if (!result.ContainsKey("actual")) result["actual"] = AppControlWindow();
+                throw AppControlOutcomeError("The app resize operation did not complete normally.", error, result);
+            }
+        }
+
+        private static IOException AppControlOutcomeError(string message, Exception cause, Dictionary<string, object> result)
+        {
+            IOException error = new IOException(message, cause);
+            error.Data["result"] = result;
+            return error;
+        }
+
         private sealed class AppControlRequest
         {
             private readonly ArcaneHostForm window;

package/src/core/runtime-connection.mjs

@@ -137,7 +137,10 @@ export function createCoreRuntimeConnection({
         try {
             return await runtime.handle(
                 {...frame, id: record.internalId},
-                preserveContextRequestId ? {contextRequestId: record.id} : undefined
+                {
+                    contextRequestId: preserveContextRequestId ? record.id : undefined,
+                    contextClientRequestId: record.id
+                }
             );
         } finally {
             releaseRequest();