arcane-os 0.68.0 → 0.70.0

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

@@ -48,6 +48,7 @@ namespace Arcane.Core.Hosts.Windows
                 Dictionary<string, object> manifest = ReadRecord(Path.Combine(directory, "arcane-native.json"));
                 Dictionary<string, object> app = RequiredRecord(manifest, "app");
                 Dictionary<string, object> client = RequiredRecord(manifest, "client");
+                Dictionary<string, object> windowOptions = manifest.ContainsKey("window") ? RequiredRecord(manifest, "window") : null;
                 string appId = RequiredString(app, "id");
                 object title;
                 string name = app.TryGetValue("displayName", out title) && title is string ? (string)title : appId;
@@ -71,6 +72,9 @@ namespace Arcane.Core.Hosts.Windows
                     OriginHost = "arcane.local",
                     ProfileDirectory = Path.Combine(profileParent, "WebView2"),
                     Title = name,
+                    InitialClientWidth = OptionalWindowDimension(windowOptions, "width"),
+                    InitialClientHeight = OptionalWindowDimension(windowOptions, "height"),
+                    Resizable = OptionalWindowResizable(windowOptions),
                     IconPath = String.IsNullOrEmpty(icon) ? null : Path.Combine(directory, icon),
                     ClassicClientSource = File.ReadAllText(Path.Combine(directory, RequiredString(client, "source"))),
                     CoreExecutable = Path.Combine(directory, "runtime", "ArcaneCore.exe"),
@@ -164,6 +168,23 @@ namespace Arcane.Core.Hosts.Windows
             return text;
         }
 
+        private static double? OptionalWindowDimension(Dictionary<string, object> window, string name)
+        {
+            object value;
+            if (window == null || !window.TryGetValue(name, out value)) return null;
+            if (value is int || value is long || value is decimal || value is double)
+                return Convert.ToDouble(value, System.Globalization.CultureInfo.InvariantCulture);
+            throw new FormatException("The native manifest needs a number at window." + name + ".");
+        }
+
+        private static bool? OptionalWindowResizable(Dictionary<string, object> window)
+        {
+            object value;
+            if (window == null || !window.TryGetValue("resizable", out value)) return null;
+            if (value is bool) return (bool)value;
+            throw new FormatException("The native manifest needs a boolean at window.resizable.");
+        }
+
         private static string QuoteArgument(string value)
         {
             // Windows command-line escaping is transport-local. The child

package/src/core/runtime.mjs

@@ -109,7 +109,12 @@ class CoreRuntime {
     }
 
     emit(event, data) {
-        const frame = {protocol: CORE_PROTOCOL, type: 'event', event, data, time: new Date().toISOString()};
+        return this.#emit(event, data);
+    }
+
+    #emit(event, data, requestId) {
+        const frame = {protocol: CORE_PROTOCOL, type: 'event', event, data,
+            ...(requestId === undefined ? {} : {requestId}), time: new Date().toISOString()};
         this.#events.dispatch(FRAME_EVENT, frame);
         return frame;
     }
@@ -158,7 +163,7 @@ class CoreRuntime {
         return service.definition;
     }
 
-    #serviceContext(service) {
+    #serviceContext(service, requestId) {
         const runtime = this;
         return {
             application: this.#application,
@@ -167,7 +172,7 @@ class CoreRuntime {
                 return runtime.getService(name);
             },
             emit(event, data) {
-                return runtime.emit(event, data);
+                return runtime.#emit(event, data, requestId);
             }
         };
     }
@@ -295,7 +300,7 @@ class CoreRuntime {
                     const result = await handle.call(
                         service.definition,
                         frame.parameters,
-                        {...runtime.#serviceContext(service), requestId: frame.id, signal: controller.signal}
+                        {...runtime.#serviceContext(service, frame.id), requestId: frame.id, signal: controller.signal}
                     );
                     aborted(controller);
                     return result;

package/src/core/services/packaged-web.mjs

@@ -8,8 +8,10 @@ export function createPackagedWebService({artifactRoot}, context = {}) {
     let server;
     let closing = false;
     let lifetime;
+    let current = null;
     return {
         name: 'packaged-web',
+        current() { return current === null ? null : {...current}; },
         async start(runtime) {
             const manifest = JSON.parse(await readFile(path.join(artifactRoot, 'arcane-native.json'), 'utf8'));
             // The launcher chooses app state independently of its installation.
@@ -48,9 +50,11 @@ export function createPackagedWebService({artifactRoot}, context = {}) {
                     await writeFile(originFile, JSON.stringify({host: '127.0.0.1', port: server.port}) + '\n', {flag: 'wx'});
                 }
                 const url = new URL(manifest.start, server.origin).href;
-                runtime.emit('core.web.ready', {origin: server.origin, url, port: server.port});
+                current = {origin: server.origin, url, port: server.port};
+                runtime.emit('core.web.ready', {...current});
                 lifetime = server.lifecycle.then(
                     function packagedServerEnded() {
+                        current = null;
                         if (!closing) {
                             runtime.emit('core.web.failed', serializeCoreError(
                                 new Error('The packaged application listener closed unexpectedly.')
@@ -58,6 +62,7 @@ export function createPackagedWebService({artifactRoot}, context = {}) {
                         }
                     },
                     function packagedServerFailed(error) {
+                        current = null;
                         if (!closing) runtime.emit('core.web.failed', serializeCoreError(error));
                         throw error;
                     }
@@ -66,6 +71,7 @@ export function createPackagedWebService({artifactRoot}, context = {}) {
                 // now; the native diagnostic event owns immediate reporting.
                 lifetime.catch(function observePackagedServerFailure() {});
             } catch (error) {
+                current = null;
                 closing = true;
                 if (server) {
                     try { await server.close(); }
@@ -78,6 +84,7 @@ export function createPackagedWebService({artifactRoot}, context = {}) {
         },
         async drain() {
             closing = true;
+            current = null;
             if (!server) return;
             const results = await Promise.allSettled([server.close(), server.closed, lifetime]);
             const failures = [...new Set(results.filter(function rejected(result) {

package/src/core/shared-host.mjs

@@ -0,0 +1,500 @@
+import {spawn} from 'node:child_process';
+import {open} from 'node:fs/promises';
+import {createConnection, 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';
+
+function failure(code, message) { return new CoreError({code, message}); }
+function reportError(error) { console.error('Shared Arcane Core failed:', error); }
+function report(observer, error) {
+    try {
+        Promise.resolve(observer(error)).catch(function observerFailed(cause) { console.error(cause, error); });
+    } catch (cause) { console.error(cause, error); }
+}
+function event(event, data) {
+    return {protocol: CORE_PROTOCOL, type: 'event', event, data, time: new Date().toISOString()};
+}
+function response(id, result, error) {
+    return {protocol: CORE_PROTOCOL, type: 'response', id,
+        ...(error ? {ok: false, error: serializeCoreError(error)} : {ok: true, result}),
+        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
+} = {}) {
+    signal?.throwIfAborted();
+    if (typeof endpoint !== 'string' || !endpoint) throw new TypeError('A shared Core endpoint must be a nonempty local pipe/socket path.');
+    const peers = new Set();
+    const requests = new Map();
+    const incoming = new Set();
+    const lifetime = new AbortController();
+    const prefix = `shared-${randomUUID()}:`;
+    let sequence = 0;
+    let runtime;
+    let unsubscribe;
+    let closing;
+    let preparation = Promise.resolve();
+    let ready = false;
+    let terminalError;
+    let resolveClosed;
+    let rejectClosed;
+    const closed = new Promise(function ownHost(resolve, reject) { resolveClosed = resolve; rejectClosed = reject; });
+    closed.catch(function observeHostFailure() {});
+    function diagnostic(error) {
+        report(onError, error);
+    }
+    function observe(task) {
+        incoming.add(task);
+        task.then(function completed() { incoming.delete(task); }, function failed(error) {
+            incoming.delete(task);
+            diagnostic(error);
+        });
+        return task;
+    }
+    function send(peer, frame) {
+        if (peer.closed) return;
+        let content;
+        try { content = encodeCoreFrame(frame); }
+        catch (error) { diagnostic(error); peer.socket.destroy(); return; }
+        peer.writes = peer.writes.then(function writeNext() {
+            if (!peer.closed) return write(peer.socket, content);
+        }).catch(function outputFailed(error) { diagnostic(error); peer.socket.destroy(); });
+    }
+    function cancel(record) {
+        observe(runtime.handle({protocol: CORE_PROTOCOL, type: 'control',
+            control: 'request.cancel', requestId: record.internalId}));
+    }
+    function disconnect(peer) {
+        if (peer.closed) return;
+        peer.closed = true;
+        peers.delete(peer);
+        for (const record of peer.requests.values()) cancel(record);
+    }
+    function stateFor(peer, state) {
+        return {...state, activeRequests: state.activeRequests.map(function requestState(record) {
+            const owned = requests.get(record.id);
+            return owned?.peer === peer ? {...record, id: owned.id} : record;
+        })};
+    }
+    function replay(peer) {
+        const state = runtime.current();
+        if (state.state === 'ready') send(peer, event('core.ready', {version: state.version, app: state.application}));
+        send(peer, event('core.state', stateFor(peer, state)));
+        for (const service of state.services) send(peer, event('core.service.state', service));
+        // Domain snapshots belong to the app/service owner, never event history.
+        for (const snapshot of getReplayEvents?.() ?? []) send(peer, event(snapshot.event, snapshot.data));
+    }
+    function route(frame) {
+        if (frame.type === 'response') {
+            const record = requests.get(frame.id);
+            if (record) send(record.peer, {...frame, id: record.id});
+            return;
+        }
+        if (frame.type !== 'event') return;
+        if (Object.hasOwn(frame, 'requestId')) {
+            const owned = requests.get(frame.requestId);
+            if (owned) send(owned.peer, {...frame, requestId: owned.id,
+                data: frame.data?.requestId === owned.internalId ? {...frame.data, requestId: owned.id} : frame.data});
+            return;
+        }
+        const id = frame.data?.requestId;
+        const record = requests.get(id);
+        if (record) {
+            send(record.peer, {...frame, data: {...frame.data, requestId: record.id}});
+            return;
+        }
+        // A retired transport correlation is not a new app-wide event.
+        if (typeof id === 'string' && id.startsWith(prefix)) return;
+        for (const peer of peers) send(peer, frame.event === 'core.state'
+            ? {...frame, data: stateFor(peer, frame.data)} : frame);
+    }
+    async function dispatch(peer, frame) {
+        if (frame?.protocol !== CORE_PROTOCOL) throw failure('INVALID_RPC_REQUEST', 'Unknown Core protocol.');
+        if (frame.type === 'control') {
+            if (frame.control === 'runtime.replay') { replay(peer); return; }
+            if (frame.control === 'request.cancel') {
+                const record = peer.requests.get(frame.requestId);
+                if (record) cancel(record);
+                return;
+            }
+            if (frame.control === 'requests.cancelAll') {
+                for (const record of peer.requests.values()) cancel(record);
+                return;
+            }
+            throw failure('INVALID_RPC_CONTROL', 'Unknown Core control.');
+        }
+        if (frame.type !== 'request' || typeof frame.id !== 'string' || !frame.id || typeof frame.method !== 'string') {
+            throw failure('INVALID_RPC_REQUEST', 'A Core request requires an id and method.');
+        }
+        if (peer.requests.has(frame.id)) throw failure('RPC_REQUEST_ID_ACTIVE', 'The request id is already active on this connection.');
+        if (frame.method === 'core.host.shutdown') {
+            peer.shutdownIds.push(frame.id);
+            close();
+            return;
+        }
+        if (closing) throw failure('CORE_CLOSING', 'Core is closing.');
+        const record = {peer, id: frame.id, internalId: `${prefix}${++sequence}`};
+        peer.requests.set(record.id, record);
+        requests.set(record.internalId, record);
+        try {
+            // Only protocol correlation changes; parameters remain untouched.
+            await runtime.handle({...frame, id: record.internalId});
+        } finally {
+            peer.requests.delete(record.id);
+            requests.delete(record.internalId);
+        }
+    }
+    function receive(peer, frame) {
+        if (peer.closed) return;
+        observe(dispatch(peer, frame).catch(function dispatchFailed(error) {
+            if (frame?.type === 'request') send(peer, response(frame.id, undefined, error));
+            else send(peer, event('core.error', serializeCoreError(error)));
+        }));
+    }
+    function accept(socket) {
+        const peer = {socket, requests: new Map(), shutdownIds: [], closed: false, writes: Promise.resolve()};
+        peers.add(peer);
+        const decoder = createCoreFrameDecoder(function receiveFrame(frame) { receive(peer, frame); });
+        socket.on('data', function data(chunk) {
+            try { decoder.push(chunk); } catch (error) { diagnostic(error); socket.destroy(); }
+        });
+        socket.on('error', diagnostic);
+        socket.on('end', function ended() {
+            try { decoder.finish(); } catch (error) { diagnostic(error); }
+            disconnect(peer);
+        });
+        socket.on('close', function connectionClosed() { disconnect(peer); });
+        if (ready) socket.resume();
+    }
+    const server = createServer({pauseOnConnect: true}, accept);
+    function close() {
+        if (closing) return closing;
+        closing = Promise.resolve().then(async function drainHost() {
+            try { await preparation; } catch {}
+            let error = terminalError;
+            try { await runtime?.close(); } catch (cause) {
+                error = error ? new AggregateError([error, cause], 'Core host shutdown failed.') : cause;
+            }
+            await Promise.allSettled([...incoming]);
+            // Keep the endpoint claim through service drain/disposal. Releasing
+            // a Unix socket sooner could start a second owner during a save.
+            const stopped = new Promise(function stopListening(resolve, reject) {
+                server.close(function listenerClosed(error) {
+                    if (error && error.code !== 'ERR_SERVER_NOT_RUNNING') reject(error);
+                    else resolve();
+                });
+            });
+            stopped.catch(function observeListenerFailure() {});
+            for (const peer of peers) {
+                for (const id of peer.shutdownIds) send(peer, response(id, {state: 'closed'}, error));
+            }
+            await Promise.all([...peers].map(function drainWrites(peer) { return peer.writes; }));
+            for (const peer of peers) { peer.socket.resume(); peer.socket.end(); }
+            await stopped;
+            unsubscribe?.();
+            signal?.removeEventListener('abort', abortHost);
+            if (error) throw error;
+            return runtime?.current() ?? {state: 'closed'};
+        });
+        closing.then(resolveClosed, function failed(error) { diagnostic(error); rejectClosed(error); });
+        lifetime.abort(failure('CORE_CLOSING', 'The shared Core host is closing.'));
+        return closing;
+    }
+    function abortHost() { close(); }
+    await new Promise(function claimEndpoint(resolve, reject) {
+        function failed(error) {
+            server.off('listening', listening);
+            error.coreHostPhase = 'listen';
+            reject(error);
+        }
+        function listening() { server.off('error', failed); resolve(); }
+        server.once('error', failed);
+        server.once('listening', listening);
+        server.listen({path: endpoint});
+    });
+    server.on('error', function listenerFailed(error) { terminalError = error; diagnostic(error); close(); });
+    try {
+        // The endpoint is already owned. A losing launcher never calls configure.
+        signal?.throwIfAborted();
+        runtime = createCoreRuntime({application, version});
+        unsubscribe = runtime.onFrame(route);
+        signal?.addEventListener('abort', abortHost, {once: true});
+        preparation = Promise.resolve().then(function configureClaimedHost() {
+            lifetime.signal.throwIfAborted();
+            return configure?.(runtime, {signal: lifetime.signal});
+        });
+        if (signal?.aborted) close();
+        await preparation;
+        signal?.throwIfAborted();
+        lifetime.signal.throwIfAborted();
+        runtime.start();
+        ready = true;
+        for (const peer of peers) peer.socket.resume();
+        if (signal?.aborted) close();
+        return {runtime, endpoint, closed, close};
+    } catch (error) {
+        for (const peer of peers) send(peer, event('core.error', serializeCoreError(error)));
+        try { await close(); } catch (closeError) { throw new AggregateError([error, closeError], 'Core startup and cleanup failed.'); }
+        throw error;
+    }
+}
+
+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();
+    });
+}
+
+// The child retains its own listener and complete diagnostic file after the
+// launching client leaves. Aborting discovery never kills a shared service.
+async function launch({command, args = [], cwd, env, logFile}, signal) {
+    signal?.throwIfAborted();
+    if (typeof logFile !== 'string' || !logFile) throw new TypeError('Headless Core launch requires a diagnostic logFile.');
+    const log = await open(logFile, 'a');
+    let child;
+    try {
+        signal?.throwIfAborted();
+        child = spawn(command, args, {cwd, env, detached: true, windowsHide: true, stdio: ['ignore', log.fd, log.fd, 'ipc']});
+        await new Promise(function awaitOwner(resolve, reject) {
+            let settled = false;
+            function finish(error) {
+                if (settled) return;
+                settled = true;
+                child.off('message', message);
+                child.off('error', failed);
+                child.off('exit', exited);
+                signal?.removeEventListener('abort', aborted);
+                // Retain an error observer after relinquishing the child: a
+                // startup abort can precede Node's asynchronous spawn error.
+                child.on('error', reportError);
+                if (child.connected) child.disconnect();
+                child.unref();
+                if (error) reject(error);
+                else resolve();
+            }
+            function message(value) {
+                if (value?.type !== 'arcane.shared-host.started') return;
+                finish(value.error ? new CoreError(value.error) : null);
+            }
+            function failed(error) { finish(error); }
+            function exited(code, exitSignal) {
+                finish(new CoreError({code: 'CORE_HOST_START_FAILED', message: 'The headless Core exited before startup completed.', exitCode: code, signal: exitSignal, logFile}));
+            }
+            function aborted() { finish(signal.reason); }
+            child.on('message', message);
+            child.once('error', failed);
+            child.once('exit', exited);
+            signal?.addEventListener('abort', aborted, {once: true});
+            if (signal?.aborted) aborted();
+        });
+    } finally { await log.close(); }
+}
+
+async function discover({endpoint, start, signal}) {
+    try { return await connectSocket(endpoint, signal); }
+    catch (error) {
+        if (!start || !['ENOENT', 'ECONNREFUSED'].includes(error.code)) throw error;
+    }
+    await launch(start, signal);
+    return connectSocket(endpoint, signal);
+}
+
+function launchSelection(start) {
+    return start ? {...start, args: [...(start.args ?? [])], ...(start.env ? {env: {...start.env}} : {})} : undefined;
+}
+
+/** 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; },
+        async shutdown(options) {
+            const result = await client.invoke('core.host.shutdown', {}, options);
+            client.close();
+            await closed;
+            return result;
+        }};
+}
+
+/** Headless entry hook: report startup to the explicit launcher, never exit. */
+export async function runSharedCoreHost(options) {
+    function announce(error) {
+        if (!process.connected || typeof process.send !== 'function') return;
+        process.send({type: 'arcane.shared-host.started', ...(error ? {error: serializeCoreError(error)} : {})},
+            function sent(cause) { if (cause) report(options.onError ?? reportError, cause); });
+    }
+    try {
+        let host;
+        try { host = await startSharedCoreHost(options); }
+        catch (error) {
+            if (error.code !== 'EADDRINUSE' || error.coreHostPhase !== 'listen') throw error;
+            const connection = await connectSharedCoreHost({endpoint: options.endpoint, onError: options.onError});
+            try { await connection.client.invoke('system.ping'); }
+            finally { await connection.close(); }
+            announce();
+            return null;
+        }
+        announce();
+        return host;
+    } catch (error) { announce(error); throw error; }
+}
+
+/** Native stdio child acts only as a connection, never as the shared owner. */
+export async function startSharedCoreBridge({endpoint, start, input = process.stdin, output = process.stdout,
+    signal, onError = reportError} = {}) {
+    const socket = await discover({endpoint, start: launchSelection(start), signal});
+    let closing;
+    let outbound = Promise.resolve();
+    let inbound = Promise.resolve();
+    let resolveClosed;
+    let rejectClosed;
+    let failure;
+    const closed = new Promise(function ownBridge(resolve, reject) { resolveClosed = resolve; rejectClosed = reject; });
+    closed.catch(function observeBridgeFailure() {});
+    function failed(error) {
+        failure ??= error;
+        report(onError, error);
+        socket.destroy();
+        close();
+    }
+    const fromCore = createCoreFrameDecoder(function frame(value) {
+        const content = encodeCoreFrame(value);
+        inbound = inbound.then(function outputFrame() { return write(output, content); });
+        inbound.catch(failed);
+    });
+    const fromInput = createCoreFrameDecoder(function frame(value) {
+        const content = encodeCoreFrame(value);
+        outbound = outbound.then(function inputFrame() { return write(socket, content); });
+        outbound.catch(failed);
+    });
+    function inputData(chunk) { try { fromInput.push(chunk); } catch (error) { failed(error); } }
+    function inputEnded() { try { fromInput.finish(); } catch (error) { failed(error); } close(); }
+    function outputClosed() { failed(failure ?? new CoreError({code: 'CORE_CONNECTION_CLOSED', message: 'The Core bridge output closed.'})); }
+    function close() {
+        if (closing) return closing;
+        input.off('data', inputData);
+        input.off('end', inputEnded);
+        input.off('close', inputEnded);
+        input.pause();
+        signal?.removeEventListener('abort', close);
+        closing = Promise.resolve().then(async function drainBridge() {
+            await Promise.allSettled([outbound]);
+            socket.end();
+            if (!socket.closed) await new Promise(function waitForClose(resolve) { socket.once('close', resolve); });
+            await Promise.allSettled([inbound]);
+            input.off('error', failed);
+            output.off('error', failed);
+            output.off('close', outputClosed);
+            output.off('finish', outputClosed);
+            if (failure) throw failure;
+        });
+        closing.then(resolveClosed, rejectClosed);
+        return closing;
+    }
+    socket.on('data', function coreData(chunk) { try { fromCore.push(chunk); } catch (error) { failed(error); } });
+    socket.on('error', failed);
+    socket.on('end', function coreEnded() { try { fromCore.finish(); } catch (error) { failed(error); } close(); });
+    socket.on('close', close);
+    input.on('data', inputData);
+    input.on('error', failed);
+    input.on('end', inputEnded);
+    input.on('close', inputEnded);
+    output.on('error', failed);
+    output.on('close', outputClosed);
+    output.on('finish', outputClosed);
+    signal?.addEventListener('abort', close, {once: true});
+    outbound = write(socket, encodeCoreFrame({protocol: CORE_PROTOCOL, type: 'control', control: 'runtime.replay'}));
+    outbound.catch(failed);
+    socket.resume();
+    if (signal?.aborted || input.readableEnded || input.destroyed) close();
+    return {endpoint, closed, close};
+}