@rynx-ai/daemon 0.1.0 → 0.1.9

package/dist/remote-runtime-connection-manager.js

@@ -0,0 +1,1409 @@
+import { randomUUID } from "node:crypto";
+import { RUNTIME_BROWSER_SURFACE_SEMANTIC_CAPABILITY, } from "@rynx-ai/protocol/runtime-browser-surface";
+import { RUNTIME_EMULATOR_SURFACE_SEMANTIC_CAPABILITY, } from "@rynx-ai/protocol/runtime-emulator-surface";
+import { assertRemoteRuntimeRpcMethodSupported, assertRemoteRuntimeSessionEventsSupported, assertRemoteRuntimeSessionTerminalSupported, parseRemoteRuntimeRpcRequest, REMOTE_RUNTIME_RPC_METHOD_METADATA, } from "@rynx-ai/protocol/remote-runtime-rpc";
+import { REMOTE_RUNTIME_CORE_PROTOCOL, } from "@rynx-ai/protocol/remote-runtime";
+import { connectDirectRuntime, openDirectRuntimeBrowserSurface, DirectRuntimeCallTransportError, DirectRuntimeClientCapacityError, DirectRuntimeClientError, DirectRuntimeRpcError, DirectRuntimeSessionEventsError, DirectRuntimeSessionTerminalError, } from "@rynx-ai/remote-runtime-client";
+import { SessionTerminalOpenError } from "@rynx-ai/server";
+const LOCAL_SELECTOR = "local";
+const TARGET_SELECTOR_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._~-]{0,255}$/;
+const DEFAULT_IDLE_TTL_MS = 15_000;
+const DEFAULT_MAX_IDLE_CONNECTIONS = 8;
+const LOCAL_SESSION_MAX_QUEUED_EVENTS = 128;
+const LOCAL_SESSION_MAX_QUEUED_EVENT_BYTES = 256 * 1024;
+const MIN_CALL_TIMEOUT_MS = 100;
+const MAX_CALL_TIMEOUT_MS = 120_000;
+const LOCAL_SUBJECT = Object.freeze({
+    subjectId: "local-control-plane",
+    effectiveAuthorities: Object.freeze(["daemon.full"]),
+});
+export class RuntimeConnectionManagerError extends Error {
+    code;
+    outcome;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = "RuntimeConnectionManagerError";
+        this.outcome = options?.outcome ?? (code === "outcome_unknown" ? "unknown" : undefined);
+    }
+}
+/**
+ * Daemon-owned Local/Direct Runtime resolver.
+ *
+ * Application callers receive only a logical target and a typed call surface;
+ * target routes and client credentials never cross this boundary. Direct
+ * connections are reused while healthy, but a failed call is never retried.
+ */
+export class DaemonRuntimeConnectionManager {
+    options;
+    client;
+    idleTtlMs;
+    maxIdleConnections;
+    slots = new Map();
+    generations = new Map();
+    localStatusSnapshot;
+    closed = false;
+    managerClosePromise;
+    constructor(options) {
+        this.options = options;
+        this.client = options.client ?? {
+            connect: (credential) => connectDirectRuntime(credential),
+            openBrowserSurface: (credential, frame, surfaceOptions) => openDirectRuntimeBrowserSurface(credential, frame, surfaceOptions),
+        };
+        this.idleTtlMs = nonNegativeInteger(options.idleTtlMs, DEFAULT_IDLE_TTL_MS, "idleTtlMs");
+        this.maxIdleConnections = nonNegativeInteger(options.maxIdleConnections, DEFAULT_MAX_IDLE_CONNECTIONS, "maxIdleConnections");
+    }
+    async acquire(selector, options = {}) {
+        this.assertOpen();
+        throwIfAborted(options.signal);
+        if (selector === LOCAL_SELECTOR)
+            return this.localLease();
+        if (!TARGET_SELECTOR_PATTERN.test(selector)) {
+            throw managerError("invalid_target", "Runtime target selector is invalid");
+        }
+        const target = this.options.targets.get(selector);
+        if (!target)
+            throw managerError("not_found", "Runtime target was not found");
+        const slot = this.slotFor(target);
+        slot.waiters += 1;
+        try {
+            await waitFor(slot.connecting, options.signal);
+            this.assertSlotCurrent(slot);
+            throwIfAborted(options.signal);
+            this.cancelIdleTimer(slot);
+            slot.refs += 1;
+            slot.lastUsedAt = Date.now();
+            return this.directLease(slot);
+        }
+        finally {
+            slot.waiters = Math.max(0, slot.waiters - 1);
+            if (this.isSlotCurrent(slot) && slot.refs === 0 && slot.waiters === 0) {
+                this.scheduleIdleClose(slot);
+            }
+        }
+    }
+    /** Synchronously detaches the generation, then closes it asynchronously. */
+    invalidate(daemonId) {
+        if (daemonId === LOCAL_SELECTOR || daemonId === this.options.localDaemonId) {
+            return Promise.reject(managerError("invalid_target", "the local Runtime connection cannot be invalidated"));
+        }
+        this.bumpGeneration(daemonId);
+        const slot = this.slots.get(daemonId);
+        if (!slot)
+            return Promise.resolve();
+        this.slots.delete(daemonId);
+        this.cancelIdleTimer(slot);
+        return this.closeSlot(slot);
+    }
+    close() {
+        if (this.managerClosePromise)
+            return this.managerClosePromise;
+        this.closed = true;
+        const slots = [...this.slots.values()];
+        this.slots.clear();
+        for (const slot of slots) {
+            this.bumpGeneration(slot.daemonId);
+            this.cancelIdleTimer(slot);
+        }
+        this.managerClosePromise = closeAll(slots.map((slot) => this.closeSlot(slot)));
+        return this.managerClosePromise;
+    }
+    localLease() {
+        let released = false;
+        return {
+            target: {
+                selector: LOCAL_SELECTOR,
+                daemonId: this.options.localDaemonId,
+            },
+            call: async (method, params, callOptions = {}) => {
+                if (released)
+                    throw managerError("closed", "Runtime connection lease was released");
+                this.assertOpen();
+                throwIfAborted(callOptions.signal);
+                return await this.callLocal(method, params, callOptions);
+            },
+            subscribeSessionEvents: async (sessionId, subscriptionOptions = {}) => {
+                if (released)
+                    throw managerError("closed", "Runtime connection lease was released");
+                this.assertOpen();
+                throwIfAborted(subscriptionOptions.signal);
+                let status;
+                try {
+                    status = this.localStatusSnapshot ?? await this.readLocalStatus(subscriptionOptions);
+                }
+                catch (error) {
+                    throw managerPreflightError(error, "Local Runtime Session events capability preflight failed");
+                }
+                this.assertSessionEventsSupported(status, status.coreProtocolVersion);
+                const timeoutMs = parseCallTimeout(subscriptionOptions.timeoutMs);
+                const deadlineController = timeoutMs === undefined ? undefined : new AbortController();
+                const signal = combinedSignal(subscriptionOptions.signal, deadlineController?.signal);
+                const opening = Promise.resolve(this.options.dispatcher.openSessionEvents(sessionId, {
+                    subject: LOCAL_SUBJECT,
+                    ...(signal ? { signal } : {}),
+                }));
+                let opened;
+                try {
+                    opened = timeoutMs === undefined
+                        ? await opening
+                        : await withDeadline(opening, timeoutMs, () => deadlineController.abort());
+                }
+                catch (error) {
+                    if (error instanceof LocalRuntimeDeadlineError) {
+                        throw managerError("deadline_exceeded", "Local Runtime Session subscription exceeded its ready deadline", error);
+                    }
+                    throw error;
+                }
+                return boundedLocalSessionSubscription(opened);
+            },
+            openSessionTerminal: async (sessionId, terminalOptions) => {
+                if (released)
+                    throw managerError("closed", "Runtime connection lease was released");
+                this.assertOpen();
+                throwIfAborted(terminalOptions.signal);
+                let status;
+                try {
+                    status = this.localStatusSnapshot ?? await this.readLocalStatus(terminalOptions);
+                }
+                catch (error) {
+                    throw managerPreflightError(error, "Local Runtime Session Terminal capability preflight failed");
+                }
+                this.assertSessionTerminalSupported(status, status.coreProtocolVersion);
+                const timeoutMs = parseCallTimeout(terminalOptions.timeoutMs);
+                const deadlineController = timeoutMs === undefined ? undefined : new AbortController();
+                const signal = combinedSignal(terminalOptions.signal, deadlineController?.signal);
+                const opening = this.options.dispatcher.openSessionTerminal(sessionId, {
+                    role: terminalOptions.role,
+                    cols: terminalOptions.cols,
+                    rows: terminalOptions.rows,
+                }, { subject: LOCAL_SUBJECT, ...(signal ? { signal } : {}) });
+                try {
+                    return timeoutMs === undefined
+                        ? await opening
+                        : await withDeadline(opening, timeoutMs, () => deadlineController.abort());
+                }
+                catch (error) {
+                    if (error instanceof LocalRuntimeDeadlineError) {
+                        void opening.then((opened) => opened.close()).catch(() => undefined);
+                        throw managerError("deadline_exceeded", "Local Runtime Session Terminal exceeded its ready deadline", error);
+                    }
+                    throw error;
+                }
+            },
+            openBrowserSurface: async (frame, surfaceOptions = {}) => {
+                if (released)
+                    throw managerError("closed", "Runtime connection lease was released");
+                this.assertOpen();
+                throwIfAborted(surfaceOptions.signal);
+                const host = this.options.localBrowserSurface;
+                if (!host) {
+                    throw managerError("incompatible", "Local Runtime Browser Surface is unavailable");
+                }
+                const timeoutMs = parseCallTimeout(surfaceOptions.timeoutMs);
+                const deadlineController = timeoutMs === undefined ? undefined : new AbortController();
+                const signal = combinedSignal(surfaceOptions.signal, deadlineController?.signal)
+                    ?? new AbortController().signal;
+                const opening = Promise.resolve(host.open(frame, {
+                    peer: {
+                        subject: LOCAL_SUBJECT,
+                        clientId: "local-control-plane",
+                        grantId: "local-control-plane",
+                    },
+                    signal,
+                }));
+                try {
+                    const attachment = timeoutMs === undefined
+                        ? await opening
+                        : await withDeadline(opening, timeoutMs, () => deadlineController.abort());
+                    return localBrowserSurfaceConnection(attachment);
+                }
+                catch (error) {
+                    if (error instanceof LocalRuntimeDeadlineError) {
+                        void opening.then((attachment) => attachment.close("transport_error"))
+                            .catch(() => undefined);
+                        throw managerError("deadline_exceeded", "Local Runtime Browser Surface exceeded its ready deadline", error);
+                    }
+                    throw error;
+                }
+            },
+            openEmulatorSurface: async (sessionId, bindingId, surfaceOptions = {}) => {
+                if (released)
+                    throw managerError("closed", "Runtime connection lease was released");
+                this.assertOpen();
+                throwIfAborted(surfaceOptions.signal);
+                const host = this.options.localEmulatorSurface;
+                if (!host)
+                    throw managerError("incompatible", "Local Runtime Emulator Surface is unavailable");
+                const timeoutMs = parseCallTimeout(surfaceOptions.timeoutMs);
+                const deadlineController = timeoutMs === undefined ? undefined : new AbortController();
+                const signal = combinedSignal(surfaceOptions.signal, deadlineController?.signal)
+                    ?? new AbortController().signal;
+                const opening = Promise.resolve(host.open({
+                    type: "emulator.surface.open",
+                    surfaceId: randomUUID(),
+                    sessionId,
+                    bindingId,
+                    maximumFrameRate: surfaceOptions.maximumFrameRate ?? 3,
+                }, {
+                    peer: {
+                        subject: LOCAL_SUBJECT,
+                        clientId: "local-control-plane",
+                        grantId: "local-control-plane",
+                    },
+                    signal,
+                }));
+                try {
+                    const attachment = timeoutMs === undefined
+                        ? await opening
+                        : await withDeadline(opening, timeoutMs, () => deadlineController.abort());
+                    return localEmulatorSurfaceConnection(attachment, surfaceOptions.maximumFrameRate ?? 3);
+                }
+                catch (error) {
+                    if (error instanceof LocalRuntimeDeadlineError) {
+                        void opening.then((attachment) => attachment.close()).catch(() => undefined);
+                        throw managerError("deadline_exceeded", "Local Runtime Emulator Surface exceeded its ready deadline", error);
+                    }
+                    throw error;
+                }
+            },
+            release: () => {
+                released = true;
+            },
+        };
+    }
+    async callLocal(method, params, callOptions) {
+        const request = parseRemoteRuntimeRpcRequest({
+            type: "rpc.request",
+            id: randomUUID(),
+            method,
+            params,
+        });
+        if (method !== "status.get") {
+            let status;
+            try {
+                status = this.localStatusSnapshot ?? await this.readLocalStatus(callOptions);
+            }
+            catch (error) {
+                throw managerPreflightError(error, `Local Runtime ${method} capability preflight failed`);
+            }
+            this.assertMethodSupported(method, status, status.coreProtocolVersion);
+        }
+        const result = await this.dispatchLocalRequest(method, request, callOptions);
+        if (method === "status.get") {
+            this.rememberLocalStatus(result);
+        }
+        return result;
+    }
+    async readLocalStatus(callOptions) {
+        if (this.localStatusSnapshot)
+            return this.localStatusSnapshot;
+        const request = parseRemoteRuntimeRpcRequest({
+            type: "rpc.request",
+            id: randomUUID(),
+            method: "status.get",
+            params: {},
+        });
+        const status = await this.dispatchLocalRequest("status.get", request, callOptions);
+        this.rememberLocalStatus(status);
+        return this.localStatusSnapshot;
+    }
+    async dispatchLocalRequest(method, request, callOptions) {
+        const timeoutMs = parseCallTimeout(callOptions.timeoutMs);
+        const deadlineController = timeoutMs === undefined ? undefined : new AbortController();
+        const signal = combinedSignal(callOptions.signal, deadlineController?.signal);
+        const dispatch = this.options.dispatcher.dispatch(request, {
+            subject: LOCAL_SUBJECT,
+            ...(signal ? { signal } : {}),
+        });
+        let response;
+        try {
+            response = timeoutMs === undefined
+                ? await dispatch
+                : await withDeadline(dispatch, timeoutMs, () => deadlineController.abort());
+        }
+        catch (error) {
+            if (error instanceof LocalRuntimeDeadlineError) {
+                if (REMOTE_RUNTIME_RPC_METHOD_METADATA[method].retryPolicy === "never") {
+                    throw managerError("outcome_unknown", `Local Runtime may have applied ${method} before its deadline`, error);
+                }
+                throw managerError("deadline_exceeded", `Local Runtime ${method} exceeded its deadline`, error);
+            }
+            throw error;
+        }
+        if (response.type === "rpc.error") {
+            throw new DirectRuntimeRpcError(response.error.code, method, response.id, response.error.message);
+        }
+        return response.result;
+    }
+    rememberLocalStatus(status) {
+        if (status.daemonId !== this.options.localDaemonId) {
+            throw managerError("identity_mismatch", "Local Runtime status belongs to a different daemon");
+        }
+        this.localStatusSnapshot = {
+            ...status,
+            semanticCapabilities: [...status.semanticCapabilities],
+        };
+    }
+    assertMethodSupported(method, status, negotiatedCoreVersion) {
+        try {
+            assertRemoteRuntimeRpcMethodSupported(method, negotiatedCoreVersion, status.semanticCapabilities);
+        }
+        catch (error) {
+            throw managerError("incompatible", error instanceof Error ? error.message : `Remote Runtime method ${method} is unavailable`, error, "not_started");
+        }
+    }
+    assertSessionEventsSupported(status, negotiatedCoreVersion) {
+        try {
+            assertRemoteRuntimeSessionEventsSupported(negotiatedCoreVersion, status.semanticCapabilities);
+        }
+        catch (error) {
+            throw managerError("incompatible", error instanceof Error ? error.message : "Remote Runtime Session events are unavailable", error, "not_started");
+        }
+    }
+    assertSessionTerminalSupported(status, negotiatedCoreVersion) {
+        try {
+            assertRemoteRuntimeSessionTerminalSupported(negotiatedCoreVersion, status.semanticCapabilities);
+        }
+        catch (error) {
+            throw managerError("incompatible", error instanceof Error ? error.message : "Remote Runtime Session Terminal is unavailable", error, "not_started");
+        }
+    }
+    directLease(slot) {
+        let released = false;
+        return {
+            target: {
+                selector: slot.daemonId,
+                daemonId: slot.daemonId,
+            },
+            call: async (method, params, callOptions = {}) => {
+                if (released)
+                    throw managerError("closed", "Runtime connection lease was released");
+                this.assertOpen();
+                this.assertSlotCurrent(slot);
+                throwIfAborted(callOptions.signal);
+                const connection = slot.connection;
+                if (!connection)
+                    throw managerError("closed", "Runtime connection is not available");
+                const status = slot.status;
+                if (!status)
+                    throw managerError("closed", "Runtime status is not available");
+                this.assertMethodSupported(method, status, Math.min(status.coreProtocolVersion, REMOTE_RUNTIME_CORE_PROTOCOL.currentVersion));
+                try {
+                    const result = callOptions.timeoutMs === undefined
+                        ? await connection.call(method, params)
+                        : await connection.call(method, params, { timeoutMs: callOptions.timeoutMs });
+                    throwIfAborted(callOptions.signal);
+                    slot.lastUsedAt = Date.now();
+                    return result;
+                }
+                catch (error) {
+                    if (isAbort(error))
+                        throw error;
+                    if (error instanceof DirectRuntimeClientCapacityError)
+                        throw error;
+                    if (error instanceof DirectRuntimeClientError && error.code === "incompatible") {
+                        throw managerError("incompatible", error.message, error, "not_started");
+                    }
+                    if (error instanceof DirectRuntimeRpcError) {
+                        // The client closes an authorization-revoked channel. Detach it
+                        // immediately instead of handing the next caller a known-dead slot.
+                        if (error.code === "unauthorized") {
+                            await this.evict(slot).catch(() => undefined);
+                        }
+                        throw error;
+                    }
+                    // The failed channel is already detached synchronously by evict(). A
+                    // secondary socket-close error must not hide the original call's
+                    // delivery semantics, especially outcome_unknown for mutations.
+                    await this.evict(slot).catch(() => undefined);
+                    if (error instanceof DirectRuntimeCallTransportError &&
+                        error.outcome === "unknown" &&
+                        REMOTE_RUNTIME_RPC_METHOD_METADATA[method].retryPolicy === "never") {
+                        throw managerError("outcome_unknown", `Remote Runtime may have applied ${method} before the connection was lost`, error);
+                    }
+                    if (error instanceof DirectRuntimeCallTransportError &&
+                        error.code === "deadline_exceeded") {
+                        throw managerError("deadline_exceeded", `Remote Runtime ${method} exceeded its deadline`, error);
+                    }
+                    throw error;
+                }
+            },
+            subscribeSessionEvents: async (sessionId, subscriptionOptions = {}) => {
+                if (released)
+                    throw managerError("closed", "Runtime connection lease was released");
+                this.assertOpen();
+                this.assertSlotCurrent(slot);
+                throwIfAborted(subscriptionOptions.signal);
+                const connection = slot.connection;
+                if (!connection)
+                    throw managerError("closed", "Runtime connection is not available");
+                const status = slot.status;
+                if (!status)
+                    throw managerError("closed", "Runtime status is not available");
+                this.assertSessionEventsSupported(status, Math.min(status.coreProtocolVersion, REMOTE_RUNTIME_CORE_PROTOCOL.currentVersion));
+                const timeoutMs = parseCallTimeout(subscriptionOptions.timeoutMs);
+                const opening = connection.subscribeSessionEvents(sessionId, timeoutMs === undefined ? undefined : { timeoutMs });
+                let subscription;
+                try {
+                    subscription = await waitFor(opening, subscriptionOptions.signal);
+                }
+                catch (error) {
+                    if (isAbort(error)) {
+                        void opening.then((opened) => opened.close()).catch(() => undefined);
+                        throw error;
+                    }
+                    if (!(error instanceof DirectRuntimeClientCapacityError) &&
+                        shouldEvictAfterSubscriptionError(error)) {
+                        await this.evict(slot).catch(() => undefined);
+                    }
+                    throw error;
+                }
+                slot.lastUsedAt = Date.now();
+                return this.wrapDirectSessionSubscription(slot, subscription, subscriptionOptions.signal);
+            },
+            openSessionTerminal: async (sessionId, terminalOptions) => {
+                if (released)
+                    throw managerError("closed", "Runtime connection lease was released");
+                this.assertOpen();
+                this.assertSlotCurrent(slot);
+                throwIfAborted(terminalOptions.signal);
+                const status = slot.status;
+                if (!status)
+                    throw managerError("closed", "Runtime status is not available");
+                this.assertSessionTerminalSupported(status, Math.min(status.coreProtocolVersion, REMOTE_RUNTIME_CORE_PROTOCOL.currentVersion));
+                return await this.openDedicatedDirectTerminal(slot, sessionId, terminalOptions);
+            },
+            openBrowserSurface: async (frame, surfaceOptions = {}) => {
+                if (released)
+                    throw managerError("closed", "Runtime connection lease was released");
+                this.assertOpen();
+                this.assertSlotCurrent(slot);
+                throwIfAborted(surfaceOptions.signal);
+                const status = slot.status;
+                if (!status)
+                    throw managerError("closed", "Runtime status is not available");
+                if (!status.semanticCapabilities.includes(RUNTIME_BROWSER_SURFACE_SEMANTIC_CAPABILITY)) {
+                    throw managerError("incompatible", "Remote Runtime Browser Surface is unavailable", undefined, "not_started");
+                }
+                return await this.openDedicatedDirectBrowserSurface(slot, frame, surfaceOptions);
+            },
+            openEmulatorSurface: async (sessionId, bindingId, surfaceOptions = {}) => {
+                if (released)
+                    throw managerError("closed", "Runtime connection lease was released");
+                this.assertOpen();
+                this.assertSlotCurrent(slot);
+                throwIfAborted(surfaceOptions.signal);
+                const status = slot.status;
+                if (!status)
+                    throw managerError("closed", "Runtime status is not available");
+                if (!status.semanticCapabilities.includes(RUNTIME_EMULATOR_SURFACE_SEMANTIC_CAPABILITY)) {
+                    throw managerError("incompatible", "Remote Runtime Emulator Surface is unavailable", undefined, "not_started");
+                }
+                return await this.openDedicatedDirectEmulatorSurface(slot, sessionId, bindingId, surfaceOptions);
+            },
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                slot.refs = Math.max(0, slot.refs - 1);
+                slot.lastUsedAt = Date.now();
+                if (this.isSlotCurrent(slot) && slot.refs === 0 && slot.waiters === 0) {
+                    this.scheduleIdleClose(slot);
+                }
+            },
+        };
+    }
+    wrapDirectSessionSubscription(slot, subscription, signal) {
+        let closed = false;
+        const onAbort = () => {
+            void close().catch(() => undefined);
+        };
+        const close = async () => {
+            if (closed)
+                return;
+            closed = true;
+            signal?.removeEventListener("abort", onAbort);
+            try {
+                await subscription.close();
+            }
+            catch (error) {
+                if (shouldEvictAfterSubscriptionError(error)) {
+                    await this.evict(slot).catch(() => undefined);
+                }
+                throw error;
+            }
+        };
+        if (signal?.aborted)
+            void close().catch(() => undefined);
+        else
+            signal?.addEventListener("abort", onAbort, { once: true });
+        return {
+            sessionId: subscription.sessionId,
+            daemonInstanceId: subscription.daemonInstanceId,
+            [Symbol.asyncIterator]: () => {
+                const iterator = subscription[Symbol.asyncIterator]();
+                return {
+                    next: async () => {
+                        try {
+                            const result = await iterator.next();
+                            if (result.done)
+                                signal?.removeEventListener("abort", onAbort);
+                            return result;
+                        }
+                        catch (error) {
+                            signal?.removeEventListener("abort", onAbort);
+                            if (shouldEvictAfterSubscriptionError(error)) {
+                                await this.evict(slot).catch(() => undefined);
+                            }
+                            throw error;
+                        }
+                    },
+                    return: async () => {
+                        await close();
+                        return { done: true, value: undefined };
+                    },
+                };
+            },
+            close,
+        };
+    }
+    async openDedicatedDirectTerminal(slot, sessionId, options) {
+        const timeoutMs = parseCallTimeout(options.timeoutMs);
+        let persisted;
+        try {
+            persisted = await this.options.credentials.load(slot.target.credentialRef);
+        }
+        catch (error) {
+            throw managerError("authentication_failed", "Runtime target credential is unavailable", error);
+        }
+        if (persisted.daemonId !== slot.target.daemonId ||
+            persisted.identityPublicKey !== slot.target.identityPublicKey) {
+            throw managerError("identity_mismatch", "Runtime target metadata does not match its protected credential");
+        }
+        this.assertSlotCurrent(slot);
+        throwIfAborted(options.signal);
+        const credential = {
+            ...persisted,
+            directEndpoint: slot.target.directRoute.endpoint,
+        };
+        const connecting = this.client.connect(credential);
+        let connection;
+        try {
+            connection = await waitFor(connecting, options.signal);
+        }
+        catch (error) {
+            if (isAbort(error)) {
+                void connecting.then((opened) => opened.close()).catch(() => undefined);
+            }
+            throw error;
+        }
+        let opening;
+        try {
+            this.assertSlotCurrent(slot);
+            throwIfAborted(options.signal);
+            opening = connection.openSessionTerminal(sessionId, {
+                role: options.role,
+                cols: options.cols,
+                rows: options.rows,
+                ...(timeoutMs === undefined ? {} : { timeoutMs }),
+            });
+            const terminal = await waitFor(opening, options.signal);
+            this.assertSlotCurrent(slot);
+            throwIfAborted(options.signal);
+            slot.lastUsedAt = Date.now();
+            return this.trackDedicatedTerminal(slot, dedicatedDirectTerminal(connection, terminal, options.signal));
+        }
+        catch (error) {
+            if (opening && isAbort(error)) {
+                void opening.then((terminal) => terminal.close()).catch(() => undefined);
+            }
+            await connection.close().catch(() => undefined);
+            if (error instanceof DirectRuntimeSessionTerminalError) {
+                throw new SessionTerminalOpenError(remoteTerminalOpenErrorCode(error.reason), error.message, { cause: error });
+            }
+            if (error instanceof DirectRuntimeClientCapacityError) {
+                throw new SessionTerminalOpenError("capacity", error.message, { cause: error });
+            }
+            if (error instanceof DirectRuntimeClientError && error.code === "incompatible") {
+                throw new SessionTerminalOpenError("method_not_found", error.message, { cause: error });
+            }
+            if (error instanceof DirectRuntimeClientError && error.code === "authentication_failed") {
+                throw new SessionTerminalOpenError("unauthorized", error.message, { cause: error });
+            }
+            throw error;
+        }
+    }
+    async openDedicatedDirectBrowserSurface(slot, frame, options) {
+        const timeoutMs = parseCallTimeout(options.timeoutMs);
+        let persisted;
+        try {
+            persisted = await this.options.credentials.load(slot.target.credentialRef);
+        }
+        catch (error) {
+            throw managerError("authentication_failed", "Runtime target credential is unavailable", error);
+        }
+        if (persisted.daemonId !== slot.target.daemonId ||
+            persisted.identityPublicKey !== slot.target.identityPublicKey) {
+            throw managerError("identity_mismatch", "Runtime target metadata does not match its protected credential");
+        }
+        this.assertSlotCurrent(slot);
+        throwIfAborted(options.signal);
+        const credential = {
+            ...persisted,
+            directEndpoint: slot.target.directRoute.endpoint,
+        };
+        const openBrowserSurface = this.client.openBrowserSurface
+            ?? ((surfaceCredential, surfaceFrame, surfaceOptions) => openDirectRuntimeBrowserSurface(surfaceCredential, surfaceFrame, surfaceOptions));
+        const signal = combinedSignal(options.signal, slot.dedicatedAbortController.signal);
+        let resolveOpeningOperation;
+        const openingOperation = new Promise((resolve) => {
+            resolveOpeningOperation = resolve;
+        });
+        slot.pendingDedicatedOpenings.add(openingOperation);
+        let resolvedSurface;
+        let opening;
+        try {
+            throwIfAborted(signal);
+            opening = openBrowserSurface(credential, frame, {
+                ...(timeoutMs === undefined ? {} : { timeoutMs }),
+                ...(signal ? { signal } : {}),
+            }).then((opened) => {
+                resolvedSurface = opened;
+                return opened;
+            });
+            const surface = await waitFor(opening, signal);
+            this.assertSlotCurrent(slot);
+            throwIfAborted(signal);
+            slot.lastUsedAt = Date.now();
+            return this.trackDedicatedBrowserSurface(slot, surface);
+        }
+        catch (error) {
+            if (resolvedSurface) {
+                await resolvedSurface.close().catch(() => undefined);
+            }
+            else if (opening) {
+                // Cancellation may win while the dedicated connection is still
+                // opening. Ownership never reaches the caller in that case, so close
+                // the late result exactly once when it arrives.
+                const closeLate = opening.then((opened) => opened.close()).catch(() => undefined);
+                if (slot.dedicatedAbortController.signal.aborted)
+                    await closeLate;
+                else
+                    void closeLate;
+            }
+            if (slot.dedicatedAbortController.signal.aborted && isAbort(error)) {
+                throw managerError("closed", "Runtime connection was invalidated while opening Browser Surface");
+            }
+            throw error;
+        }
+        finally {
+            slot.pendingDedicatedOpenings.delete(openingOperation);
+            resolveOpeningOperation();
+        }
+    }
+    async openDedicatedDirectEmulatorSurface(slot, sessionId, bindingId, options) {
+        const timeoutMs = parseCallTimeout(options.timeoutMs);
+        let persisted;
+        try {
+            persisted = await this.options.credentials.load(slot.target.credentialRef);
+        }
+        catch (error) {
+            throw managerError("authentication_failed", "Runtime target credential is unavailable", error);
+        }
+        if (persisted.daemonId !== slot.target.daemonId ||
+            persisted.identityPublicKey !== slot.target.identityPublicKey)
+            throw managerError("identity_mismatch", "Runtime target metadata does not match its protected credential");
+        const credential = {
+            ...persisted,
+            directEndpoint: slot.target.directRoute.endpoint,
+        };
+        const signal = combinedSignal(options.signal, slot.dedicatedAbortController.signal);
+        let resolveOpeningOperation;
+        const openingOperation = new Promise((resolve) => { resolveOpeningOperation = resolve; });
+        slot.pendingDedicatedOpenings.add(openingOperation);
+        let connection;
+        let connecting;
+        let surface;
+        let opening;
+        try {
+            throwIfAborted(signal);
+            connecting = this.client.connect(credential).then((opened) => {
+                connection = opened;
+                return opened;
+            });
+            connection = await waitFor(connecting, signal);
+            throwIfAborted(signal);
+            opening = connection.openEmulatorSurface(sessionId, bindingId, {
+                ...(timeoutMs === undefined ? {} : { timeoutMs }),
+                ...(options.maximumFrameRate === undefined ? {} : { maximumFrameRate: options.maximumFrameRate }),
+            }).then((opened) => {
+                surface = opened;
+                return opened;
+            });
+            surface = await waitFor(opening, signal);
+            this.assertSlotCurrent(slot);
+            throwIfAborted(signal);
+            slot.lastUsedAt = Date.now();
+            return this.trackDedicatedEmulatorSurface(slot, connection, surface);
+        }
+        catch (error) {
+            const closeSurface = surface
+                ? surface.close().catch(() => undefined)
+                : opening?.then((opened) => opened.close()).catch(() => undefined);
+            const closeConnection = connection
+                ? connection.close().catch(() => undefined)
+                : connecting?.then((opened) => opened.close()).catch(() => undefined);
+            if (slot.dedicatedAbortController.signal.aborted) {
+                await Promise.all([closeSurface, closeConnection]);
+            }
+            else {
+                void Promise.all([closeSurface, closeConnection]);
+            }
+            if (slot.dedicatedAbortController.signal.aborted && isAbort(error)) {
+                throw managerError("closed", "Runtime connection was invalidated while opening Emulator Surface");
+            }
+            throw error;
+        }
+        finally {
+            slot.pendingDedicatedOpenings.delete(openingOperation);
+            resolveOpeningOperation();
+        }
+    }
+    slotFor(target) {
+        const current = this.slots.get(target.daemonId);
+        if (current && current.generation === this.generation(target.daemonId))
+            return current;
+        const generation = this.generation(target.daemonId);
+        const slot = {
+            daemonId: target.daemonId,
+            generation,
+            target,
+            refs: 0,
+            waiters: 0,
+            lastUsedAt: Date.now(),
+            dedicatedClosers: new Set(),
+            dedicatedAbortController: new AbortController(),
+            pendingDedicatedOpenings: new Set(),
+        };
+        slot.connecting = this.openDirectConnection(slot);
+        this.slots.set(target.daemonId, slot);
+        void slot.connecting.then(() => {
+            if (this.isSlotCurrent(slot) && slot.refs === 0 && slot.waiters === 0) {
+                this.scheduleIdleClose(slot);
+            }
+        }, () => undefined);
+        return slot;
+    }
+    async openDirectConnection(slot) {
+        let persisted;
+        let connection;
+        try {
+            persisted = await this.options.credentials.load(slot.target.credentialRef);
+        }
+        catch (error) {
+            if (this.isSlotCurrent(slot)) {
+                this.slots.delete(slot.daemonId);
+                this.bumpGeneration(slot.daemonId);
+            }
+            throw managerError("authentication_failed", "Runtime target credential is unavailable", error);
+        }
+        try {
+            if (persisted.daemonId !== slot.target.daemonId ||
+                persisted.identityPublicKey !== slot.target.identityPublicKey) {
+                throw managerError("identity_mismatch", "Runtime target metadata does not match its protected credential");
+            }
+            const credential = {
+                ...persisted,
+                directEndpoint: slot.target.directRoute.endpoint,
+            };
+            connection = await this.client.connect(credential);
+            slot.connection = connection;
+            const status = await connection.status();
+            if (status.daemonId !== slot.daemonId) {
+                throw managerError("identity_mismatch", "Runtime status belongs to a different daemon");
+            }
+            slot.status = {
+                ...status,
+                semanticCapabilities: [...status.semanticCapabilities],
+            };
+            if (!this.isSlotCurrent(slot)) {
+                throw managerError("closed", "Runtime connection was invalidated while connecting");
+            }
+            return connection;
+        }
+        catch (error) {
+            const slotIsCurrent = this.isSlotCurrent(slot);
+            // invalidate()/close() already owns closure for a detached generation.
+            // Close here only when authentication/status preflight itself failed.
+            if (connection && slotIsCurrent)
+                await connection.close().catch(() => undefined);
+            if (slotIsCurrent) {
+                this.slots.delete(slot.daemonId);
+                this.bumpGeneration(slot.daemonId);
+            }
+            if (error instanceof RuntimeConnectionManagerError)
+                throw error;
+            throw error;
+        }
+    }
+    async evict(slot) {
+        if (this.isSlotCurrent(slot)) {
+            this.slots.delete(slot.daemonId);
+            this.bumpGeneration(slot.daemonId);
+        }
+        this.cancelIdleTimer(slot);
+        await this.closeSlot(slot);
+    }
+    closeSlot(slot) {
+        if (slot.closePromise)
+            return slot.closePromise;
+        slot.closePromise = (async () => {
+            // Start closing generation-scoped dedicated transports immediately;
+            // do not let a still-connecting shared channel keep them authorized.
+            slot.dedicatedAbortController.abort();
+            const dedicatedClosing = [...slot.dedicatedClosers].map((close) => close());
+            const pendingDedicatedOpenings = [...slot.pendingDedicatedOpenings];
+            let connection = slot.connection;
+            if (!connection) {
+                try {
+                    connection = await slot.connecting;
+                }
+                catch {
+                    connection = slot.connection;
+                }
+            }
+            await closeAll([
+                ...dedicatedClosing,
+                ...pendingDedicatedOpenings,
+                ...(connection ? [connection.close()] : []),
+            ]);
+        })();
+        return slot.closePromise;
+    }
+    trackDedicatedTerminal(slot, terminal) {
+        const close = this.registerDedicatedCloser(slot, () => terminal.close(), terminal.closed.then(() => undefined));
+        return {
+            sessionId: terminal.sessionId,
+            role: terminal.role,
+            closed: terminal.closed,
+            write: (data) => {
+                this.assertSlotCurrent(slot);
+                return terminal.write(data);
+            },
+            resize: (cols, rows) => {
+                this.assertSlotCurrent(slot);
+                return terminal.resize(cols, rows);
+            },
+            close,
+            [Symbol.asyncIterator]: () => {
+                const iterator = terminal[Symbol.asyncIterator]();
+                return {
+                    next: () => {
+                        this.assertSlotCurrent(slot);
+                        return iterator.next();
+                    },
+                    return: async () => {
+                        await close();
+                        return { done: true, value: undefined };
+                    },
+                };
+            },
+        };
+    }
+    trackDedicatedBrowserSurface(slot, surface) {
+        const close = this.registerDedicatedCloser(slot, () => surface.close(), surface.closed.then(() => undefined));
+        return {
+            ready: surface.ready,
+            send: async (frame) => {
+                this.assertSlotCurrent(slot);
+                await surface.send(frame);
+            },
+            close,
+            [Symbol.asyncIterator]: () => {
+                const iterator = surface[Symbol.asyncIterator]();
+                return {
+                    next: async () => {
+                        this.assertSlotCurrent(slot);
+                        return await iterator.next();
+                    },
+                    return: async () => {
+                        await close();
+                        return { done: true, value: undefined };
+                    },
+                };
+            },
+        };
+    }
+    trackDedicatedEmulatorSurface(slot, connection, surface) {
+        const close = this.registerDedicatedCloser(slot, async () => {
+            try {
+                await surface.close();
+            }
+            finally {
+                await connection.close();
+            }
+        }, surface.closed.then(() => connection.close(), () => connection.close()).then(() => undefined));
+        return {
+            ready: surface.ready,
+            close,
+            sendTouch: (point) => surface.sendTouch(point),
+            [Symbol.asyncIterator]: () => {
+                const iterator = surface[Symbol.asyncIterator]();
+                return {
+                    next: async () => {
+                        this.assertSlotCurrent(slot);
+                        return await iterator.next();
+                    },
+                    return: async () => {
+                        await close();
+                        return { done: true, value: undefined };
+                    },
+                };
+            },
+        };
+    }
+    registerDedicatedCloser(slot, closeResource, naturallyClosed) {
+        this.assertSlotCurrent(slot);
+        let closePromise;
+        const close = () => {
+            closePromise ??= Promise.resolve()
+                .then(closeResource)
+                .finally(() => slot.dedicatedClosers.delete(close));
+            return closePromise;
+        };
+        slot.dedicatedClosers.add(close);
+        if (naturallyClosed) {
+            void naturallyClosed.then(() => slot.dedicatedClosers.delete(close), () => slot.dedicatedClosers.delete(close));
+        }
+        return close;
+    }
+    scheduleIdleClose(slot) {
+        this.cancelIdleTimer(slot);
+        if (this.idleTtlMs === 0) {
+            void this.evict(slot).catch(() => undefined);
+            return;
+        }
+        slot.idleTimer = setTimeout(() => {
+            if (this.isSlotCurrent(slot) && slot.refs === 0 && slot.waiters === 0) {
+                void this.evict(slot).catch(() => undefined);
+            }
+        }, this.idleTtlMs);
+        slot.idleTimer.unref?.();
+        this.pruneIdleConnections();
+    }
+    pruneIdleConnections() {
+        const idle = [...this.slots.values()]
+            .filter((slot) => slot.refs === 0 && slot.waiters === 0 && slot.connection)
+            .sort((left, right) => left.lastUsedAt - right.lastUsedAt);
+        const excess = idle.length - this.maxIdleConnections;
+        for (let index = 0; index < excess; index += 1) {
+            void this.evict(idle[index]).catch(() => undefined);
+        }
+    }
+    cancelIdleTimer(slot) {
+        if (slot.idleTimer)
+            clearTimeout(slot.idleTimer);
+        slot.idleTimer = undefined;
+    }
+    assertOpen() {
+        if (this.closed)
+            throw managerError("closed", "Runtime connection manager is closed");
+    }
+    assertSlotCurrent(slot) {
+        if (!this.isSlotCurrent(slot)) {
+            throw managerError("closed", "Runtime connection lease is no longer active");
+        }
+    }
+    isSlotCurrent(slot) {
+        return (!this.closed &&
+            this.slots.get(slot.daemonId) === slot &&
+            this.generation(slot.daemonId) === slot.generation);
+    }
+    generation(daemonId) {
+        return this.generations.get(daemonId) ?? 0;
+    }
+    bumpGeneration(daemonId) {
+        this.generations.set(daemonId, this.generation(daemonId) + 1);
+    }
+}
+function dedicatedDirectTerminal(connection, terminal, signal) {
+    let closePromise;
+    const closeConnection = () => {
+        closePromise ??= connection.close();
+        return closePromise;
+    };
+    const onAbort = () => {
+        void close().catch(() => undefined);
+    };
+    const close = async () => {
+        signal?.removeEventListener("abort", onAbort);
+        try {
+            await terminal.close();
+        }
+        finally {
+            await closeConnection();
+        }
+    };
+    if (signal?.aborted)
+        onAbort();
+    else
+        signal?.addEventListener("abort", onAbort, { once: true });
+    const closed = terminal.closed
+        .then((frame) => ({
+        reason: frame.reason,
+        ...(frame.exitCode === undefined ? {} : { exitCode: frame.exitCode }),
+    }))
+        .finally(() => {
+        signal?.removeEventListener("abort", onAbort);
+        void closeConnection().catch(() => undefined);
+    });
+    void closed.catch(() => undefined);
+    return {
+        sessionId: terminal.sessionId,
+        role: terminal.role,
+        closed,
+        write: (data) => terminal.write(data),
+        resize: (cols, rows) => terminal.resize(cols, rows),
+        close,
+        [Symbol.asyncIterator]: () => {
+            const iterator = terminal[Symbol.asyncIterator]();
+            return {
+                next: async () => {
+                    try {
+                        const result = await iterator.next();
+                        if (result.done)
+                            await closeConnection().catch(() => undefined);
+                        return result;
+                    }
+                    catch (error) {
+                        await closeConnection().catch(() => undefined);
+                        throw error;
+                    }
+                },
+                return: async () => {
+                    await close();
+                    return { done: true, value: undefined };
+                },
+            };
+        },
+    };
+}
+function remoteTerminalOpenErrorCode(reason) {
+    if (reason === "not_live")
+        return "not_live";
+    if (reason === "unauthorized")
+        return "unauthorized";
+    if (reason === "capacity" || reason === "backpressure")
+        return "capacity";
+    return "internal";
+}
+/**
+ * Local dispatch has no WebSocket adapter to drain the process bus. Drain it
+ * here into the same count/UTF-8-byte envelope used by the Direct client so a
+ * stalled SSE consumer cannot grow the SessionBus subscriber queue forever.
+ * Overflow is terminal only for this subscription; the Local lease remains
+ * usable for unrelated calls.
+ */
+function boundedLocalSessionSubscription(opened) {
+    const subscriptionId = `local_${randomUUID()}`;
+    const source = opened.events[Symbol.asyncIterator]();
+    const queue = [];
+    let queuedBytes = 0;
+    let waiter;
+    let terminal;
+    let cancelPromise;
+    const cancelSource = () => {
+        cancelPromise ??= Promise.resolve().then(() => opened.cancel());
+        return cancelPromise;
+    };
+    const clearQueue = () => {
+        queue.length = 0;
+        queuedBytes = 0;
+    };
+    const finish = (nextTerminal, discardQueue) => {
+        if (terminal)
+            return;
+        terminal = nextTerminal;
+        if (discardQueue)
+            clearQueue();
+        const pending = waiter;
+        waiter = undefined;
+        if (!pending)
+            return;
+        if (nextTerminal.kind === "error")
+            pending.reject(nextTerminal.error);
+        else
+            pending.resolve({ done: true, value: undefined });
+    };
+    const push = (event) => {
+        if (terminal)
+            return false;
+        const encoded = JSON.stringify(event);
+        if (encoded === undefined)
+            throw new Error("Local Session event is not JSON-encodable");
+        const bytes = Buffer.byteLength(encoded, "utf8");
+        if (waiter) {
+            const pending = waiter;
+            waiter = undefined;
+            pending.resolve({ done: false, value: event });
+            return true;
+        }
+        if (queue.length >= LOCAL_SESSION_MAX_QUEUED_EVENTS ||
+            queuedBytes + bytes > LOCAL_SESSION_MAX_QUEUED_EVENT_BYTES) {
+            finish({
+                kind: "error",
+                error: new DirectRuntimeSessionEventsError("backpressure", subscriptionId, opened.sessionId, "Local Runtime Session event queue exceeded its bounded capacity"),
+            }, true);
+            void cancelSource().catch(() => undefined);
+            return false;
+        }
+        queue.push({ event, bytes });
+        queuedBytes += bytes;
+        return true;
+    };
+    void (async () => {
+        try {
+            while (!terminal) {
+                const next = await source.next();
+                if (terminal)
+                    return;
+                if (next.done) {
+                    finish({ kind: "done" }, false);
+                    return;
+                }
+                if (!push(next.value))
+                    return;
+            }
+        }
+        catch (error) {
+            if (!terminal)
+                finish({ kind: "error", error }, true);
+        }
+        finally {
+            if (terminal)
+                await cancelSource().catch(() => undefined);
+        }
+    })();
+    const close = async () => {
+        finish({ kind: "done" }, true);
+        await cancelSource();
+    };
+    const consumer = {
+        next() {
+            const queued = queue.shift();
+            if (queued) {
+                queuedBytes -= queued.bytes;
+                return Promise.resolve({ done: false, value: queued.event });
+            }
+            if (terminal?.kind === "error")
+                return Promise.reject(terminal.error);
+            if (terminal)
+                return Promise.resolve({ done: true, value: undefined });
+            if (waiter) {
+                return Promise.reject(managerError("protocol_error", "concurrent reads from one Local Session subscription are not allowed"));
+            }
+            return new Promise((resolve, reject) => {
+                waiter = { resolve, reject };
+            });
+        },
+        async return() {
+            await close();
+            return { done: true, value: undefined };
+        },
+    };
+    return {
+        sessionId: opened.sessionId,
+        daemonInstanceId: opened.daemonInstanceId,
+        [Symbol.asyncIterator]: () => consumer,
+        close,
+    };
+}
+function localBrowserSurfaceConnection(attachment) {
+    let closed = false;
+    return {
+        ready: attachment.ready,
+        [Symbol.asyncIterator]: () => attachment.events[Symbol.asyncIterator](),
+        send: async (frame) => {
+            if (closed)
+                throw managerError("closed", "Browser Surface is closed");
+            await attachment.handle(frame);
+        },
+        close: async () => {
+            if (closed)
+                return;
+            closed = true;
+            await attachment.close("client_closed");
+        },
+    };
+}
+function localEmulatorSurfaceConnection(attachment, maximumFrameRate) {
+    let closed = false;
+    let sequence = 0;
+    let inputSequence = 0;
+    let lastCaptureAt = 0;
+    const intervalMs = Math.ceil(1_000 / maximumFrameRate);
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        await attachment.close();
+    };
+    return {
+        ready: attachment.ready,
+        close,
+        sendTouch: async (point) => {
+            if (closed)
+                throw managerError("closed", "Emulator Surface is closed");
+            await attachment.handle({
+                type: "emulator.surface.touch",
+                surfaceId: attachment.ready.surfaceId,
+                inputSequence: inputSequence++,
+                ...point,
+            });
+        },
+        [Symbol.asyncIterator]: () => ({
+            next: async () => {
+                if (closed)
+                    return { done: true, value: undefined };
+                const waitMs = intervalMs - (Date.now() - lastCaptureAt);
+                if (waitMs > 0)
+                    await new Promise((resolve) => setTimeout(resolve, waitMs));
+                if (closed)
+                    return { done: true, value: undefined };
+                const encodedBytes = await attachment.capture();
+                lastCaptureAt = Date.now();
+                return {
+                    done: false,
+                    value: {
+                        surfaceId: attachment.ready.surfaceId,
+                        frameSequence: sequence++,
+                        timestampMilliseconds: lastCaptureAt,
+                        format: attachment.ready.format,
+                        encodedBytes,
+                    },
+                };
+            },
+            return: async () => {
+                await close();
+                return { done: true, value: undefined };
+            },
+        }),
+    };
+}
+function nonNegativeInteger(value, fallback, field) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new TypeError(`${field} must be a non-negative safe integer`);
+    }
+    return value;
+}
+function parseCallTimeout(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(value) ||
+        value < MIN_CALL_TIMEOUT_MS ||
+        value > MAX_CALL_TIMEOUT_MS) {
+        throw managerError("protocol_error", `timeoutMs must be an integer between ${MIN_CALL_TIMEOUT_MS} and ${MAX_CALL_TIMEOUT_MS}`);
+    }
+    return value;
+}
+class LocalRuntimeDeadlineError extends Error {
+    constructor() {
+        super("Local Runtime call deadline exceeded");
+        this.name = "LocalRuntimeDeadlineError";
+    }
+}
+async function withDeadline(promise, timeoutMs, onTimeout) {
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            onTimeout();
+            reject(new LocalRuntimeDeadlineError());
+        }, timeoutMs);
+        timer.unref?.();
+        void promise.then((value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+function combinedSignal(first, second) {
+    if (!first)
+        return second;
+    if (!second)
+        return first;
+    return AbortSignal.any([first, second]);
+}
+async function waitFor(promise, signal) {
+    if (!signal)
+        return await promise;
+    throwIfAborted(signal);
+    return await new Promise((resolve, reject) => {
+        const abort = () => reject(abortError());
+        signal.addEventListener("abort", abort, { once: true });
+        void promise.then((value) => {
+            signal.removeEventListener("abort", abort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", abort);
+            reject(error);
+        });
+    });
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw abortError();
+}
+function abortError() {
+    return managerError("cancelled", "Runtime connection operation was cancelled");
+}
+function isAbort(error) {
+    return error instanceof RuntimeConnectionManagerError && error.code === "cancelled";
+}
+function shouldEvictAfterSubscriptionError(error) {
+    if (error instanceof DirectRuntimeSessionEventsError) {
+        // A scoped capacity/not-found/backpressure close does not poison the
+        // authenticated channel. Revocation does.
+        return error.reason === "unauthorized";
+    }
+    return true;
+}
+function managerError(code, message, cause, outcome) {
+    return new RuntimeConnectionManagerError(code, message, cause === undefined && outcome === undefined
+        ? undefined
+        : {
+            ...(cause === undefined ? {} : { cause }),
+            ...(outcome === undefined ? {} : { outcome }),
+        });
+}
+function managerPreflightError(error, message) {
+    if (error instanceof RuntimeConnectionManagerError) {
+        return managerError(error.code, error.message, error, "not_started");
+    }
+    if (error instanceof DirectRuntimeClientError) {
+        return managerError(error.code === "authentication_failed" ? "authentication_failed" : "protocol_error", message, error, "not_started");
+    }
+    return managerError("protocol_error", message, error, "not_started");
+}
+async function closeAll(closing) {
+    const results = await Promise.allSettled(closing);
+    const errors = results
+        .filter((result) => result.status === "rejected")
+        .map((result) => result.reason);
+    if (errors.length > 0) {
+        throw new AggregateError(errors, "failed to close Runtime connections");
+    }
+}