arcane-os 0.81.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;
@@ -213,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,
@@ -228,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;
@@ -244,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;
@@ -571,7 +586,11 @@ namespace Arcane.Core.Hosts.Windows
             // 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.RenderProcessExited) CoreFailed(error);
+            if (kind == CoreWebView2ProcessFailedKind.RenderProcessExited)
+            {
+                AppControlRendererExited();
+                CoreFailed(error);
+            }
             else Report(error);
         }
 
@@ -727,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);
         }
@@ -753,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)
@@ -781,6 +802,7 @@ namespace Arcane.Core.Hosts.Windows
                 {
                     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/shared-host.mjs

@@ -1,11 +1,11 @@
 import {spawn} from 'node:child_process';
 import {open} from 'node:fs/promises';
-import {createConnection, createServer} from 'node:net';
+import {createServer} from 'node:net';
 import {randomUUID} from 'node:crypto';
-import {createCoreClient} from '../../browser-runtime/core/client.mjs';
 import {CORE_PROTOCOL, CoreError, serializeCoreError} from '../../browser-runtime/core/contracts.mjs';
 import {createCoreRuntime} from './runtime.mjs';
 import {createCoreFrameDecoder, encodeCoreFrame} from './stdio.mjs';
+import {connectCoreSocket, createCoreSocketConnection, writeCoreSocket as write} from './socket-connection.mjs';
 
 function failure(code, message) { return new CoreError({code, message}); }
 function reportError(error) { console.error('Shared Arcane Core failed:', error); }
@@ -23,29 +23,6 @@ function response(id, result, error) {
         time: new Date().toISOString()};
 }
 
-// A stream write owns terminal events as well as its callback. Some destroyed
-// streams never deliver that callback; retirement must still settle the write.
-function write(output, content) {
-    return new Promise(function writeFrame(resolve, reject) {
-        let settled = false;
-        function finish(error) {
-            if (settled) return;
-            settled = true;
-            output.off('error', finish);
-            output.off('close', closed);
-            output.off('finish', closed);
-            if (error) reject(error);
-            else resolve();
-        }
-        function closed() { finish(failure('CORE_CONNECTION_CLOSED', 'The Core output closed during a write.')); }
-        output.once('error', finish);
-        output.once('close', closed);
-        output.once('finish', closed);
-        if (output.destroyed || output.writableEnded) { closed(); return; }
-        try { output.write(content, finish); } catch (error) { finish(error); }
-    });
-}
-
 /** Claim one app-selected pipe/socket before importing or creating services. */
 export async function startSharedCoreHost({
     endpoint, application, version, configure, getReplayEvents, signal, onError = reportError
@@ -268,29 +245,7 @@ export async function startSharedCoreHost({
 }
 
 function connectSocket(endpoint, signal) {
-    signal?.throwIfAborted();
-    if (typeof endpoint !== 'string' || !endpoint) throw new TypeError('A shared Core endpoint must be a nonempty local pipe/socket path.');
-    return new Promise(function connect(resolve, reject) {
-        const socket = createConnection({path: endpoint});
-        socket.pause();
-        function cleanup() {
-            signal?.removeEventListener('abort', abort);
-            socket.off('connect', connected);
-            socket.off('error', failed);
-        }
-        function failed(error) {
-            cleanup();
-            socket.on('error', reportError);
-            socket.destroy();
-            reject(error);
-        }
-        function abort() { failed(signal.reason); }
-        function connected() { cleanup(); resolve(socket); }
-        socket.once('connect', connected);
-        socket.once('error', failed);
-        signal?.addEventListener('abort', abort, {once: true});
-        if (signal?.aborted) abort();
-    });
+    return connectCoreSocket(endpoint, signal, reportError);
 }
 
 // The child retains its own listener and complete diagnostic file after the
@@ -354,49 +309,10 @@ function launchSelection(start) {
 /** Connect/reuse, optionally starting an explicit independent headless entry. */
 export async function connectSharedCoreHost({endpoint, start, signal, onError = reportError} = {}) {
     const socket = await discover({endpoint, start: launchSelection(start), signal});
-    let client;
-    let receive;
-    let closing = false;
-    let writes = Promise.resolve();
-    let resolveClosed;
-    let rejectClosed;
-    const closed = new Promise(function ownConnection(resolve, reject) { resolveClosed = resolve; rejectClosed = reject; });
-    closed.catch(function observeConnectionFailure() {});
-    function diagnostic(error) { report(onError, error); }
-    function failed(error) { client?.failTransport(error); socket.destroy(); rejectClosed(error); }
-    const decoder = createCoreFrameDecoder(function frame(value) { receive(value); });
-    socket.on('data', function data(chunk) { try { decoder.push(chunk); } catch (error) { failed(error); } });
-    socket.on('error', failed);
-    socket.on('end', function ended() {
-        try { decoder.finish(); } catch (error) { failed(error); }
-    });
-    socket.on('close', function disconnected() {
-        signal?.removeEventListener('abort', abort);
-        if (!closing) client?.failTransport(failure('CORE_CONNECTION_CLOSED', 'The shared Core connection closed.'));
-        resolveClosed();
-    });
-    const transport = {
-        name: 'shared-core',
-        subscribe(listener) {
-            receive = listener;
-            return function disconnect() {
-                closing = true;
-                writes.finally(function retireSocket() { socket.end(); }).catch(diagnostic);
-            };
-        },
-        send(frame) {
-            const content = encodeCoreFrame(frame);
-            writes = writes.then(function sendFrame() { return write(socket, content); });
-            writes.catch(failed);
-            return writes;
-        }
-    };
-    client = createCoreClient({transport, replayRuntimeState: true, onError: diagnostic});
-    function abort() { client.close(); }
-    signal?.addEventListener('abort', abort, {once: true});
-    if (signal?.aborted) abort();
-    socket.resume();
-    return {client, endpoint, closed, close: function close() { client.close(); return closed; },
+    const connection = createCoreSocketConnection({socket, endpoint, signal, onError,
+        replayRuntimeState: true, name: 'shared-core', closedMessage: 'The shared Core connection closed.'});
+    const {client, closed} = connection;
+    return {...connection,
         async shutdown(options) {
             const result = await client.invoke('core.host.shutdown', {}, options);
             client.close();