@abot-ai/runtime 1.1.0 → 1.3.0

package/dist/src/runtime/local-host/endpoint.d.ts

@@ -0,0 +1,7 @@
+import type { LocalRuntimeEndpoint } from "./contracts.js";
+export declare function localRuntimeEndpointPath(directory: string): string;
+export { ensurePrivateRuntimeDirectory } from "./private-directory.js";
+export declare function readLocalRuntimeEndpoint(directory: string): Promise<LocalRuntimeEndpoint | undefined>;
+export declare function writeLocalRuntimeEndpoint(directory: string, endpoint: LocalRuntimeEndpoint): Promise<void>;
+export declare function removeLocalRuntimeEndpoint(directory: string, token: string): Promise<void>;
+export declare function isLocalRuntimeProcessAlive(pid: number): boolean;

package/dist/src/runtime/local-host/endpoint.js

@@ -0,0 +1,79 @@
+import { randomUUID } from "node:crypto";
+import { lstat, open, readFile, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { assertPrivateRuntimeAccess } from "./private-access.js";
+export function localRuntimeEndpointPath(directory) {
+    return join(directory, "endpoint.json");
+}
+export { ensurePrivateRuntimeDirectory } from "./private-directory.js";
+export async function readLocalRuntimeEndpoint(directory) {
+    const path = localRuntimeEndpointPath(directory);
+    try {
+        const stat = await lstat(path);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error("local_runtime_endpoint_not_private");
+        await assertPrivateRuntimeAccess(path, stat, "local_runtime_endpoint_not_private");
+        const value = JSON.parse(await readFile(path, "utf8"));
+        if (!isLocalRuntimeEndpoint(value))
+            throw new Error("local_runtime_invalid_endpoint");
+        return value;
+    }
+    catch (error) {
+        if (hasFileErrorCode(error, "ENOENT"))
+            return undefined;
+        throw error;
+    }
+}
+export async function writeLocalRuntimeEndpoint(directory, endpoint) {
+    const path = localRuntimeEndpointPath(directory);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    const handle = await open(temporary, "wx", 0o600);
+    try {
+        await handle.writeFile(JSON.stringify(endpoint), "utf8");
+        await handle.sync();
+        await handle.close();
+        await rename(temporary, path);
+    }
+    catch (error) {
+        await handle.close().catch(() => undefined);
+        await rm(temporary, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+export async function removeLocalRuntimeEndpoint(directory, token) {
+    const endpoint = await readLocalRuntimeEndpoint(directory);
+    if (endpoint?.token !== token)
+        return;
+    await rm(localRuntimeEndpointPath(directory), { force: true });
+}
+export function isLocalRuntimeProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return !hasFileErrorCode(error, "ESRCH");
+    }
+}
+function isLocalRuntimeEndpoint(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const endpoint = value;
+    if (endpoint.version !== 1)
+        return false;
+    if (typeof endpoint.identity !== "string" || !endpoint.identity)
+        return false;
+    if (!isPositiveInteger(endpoint.pid))
+        return false;
+    if (!isPositiveInteger(endpoint.port) || endpoint.port > 65_535)
+        return false;
+    return (typeof endpoint.token === "string" && /^[a-f0-9]{64}$/.test(endpoint.token));
+}
+function isPositiveInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function hasFileErrorCode(error, code) {
+    if (!error || typeof error !== "object" || !("code" in error))
+        return false;
+    return error.code === code;
+}

package/dist/src/runtime/local-host/owner-activity.d.ts

@@ -0,0 +1,10 @@
+/** Keeps accepted RPC effects under the owner's lease until they settle. */
+export declare class LocalRuntimeOwnerActivity {
+    private readonly active;
+    private stopped;
+    assertAcceptingRequests(): void;
+    run<T>(operation: () => Promise<T>): Promise<T>;
+    stop(): void;
+    isIdle(): boolean;
+    whenIdle(): Promise<void>;
+}

package/dist/src/runtime/local-host/owner-activity.js

@@ -0,0 +1,30 @@
+/** Keeps accepted RPC effects under the owner's lease until they settle. */
+export class LocalRuntimeOwnerActivity {
+    active = new Set();
+    stopped = false;
+    assertAcceptingRequests() {
+        if (this.stopped)
+            throw new Error("local_runtime_owner_stopped");
+    }
+    async run(operation) {
+        this.assertAcceptingRequests();
+        const pending = operation();
+        this.active.add(pending);
+        try {
+            return await pending;
+        }
+        finally {
+            this.active.delete(pending);
+        }
+    }
+    stop() {
+        this.stopped = true;
+    }
+    isIdle() {
+        return this.active.size === 0;
+    }
+    async whenIdle() {
+        // stop closes intake synchronously before the transport asks for this fence.
+        await Promise.allSettled([...this.active]);
+    }
+}

package/dist/src/runtime/local-host/owner-retirement.d.ts

@@ -0,0 +1,3 @@
+import type { LocalRuntimeOwner } from "./contracts.js";
+/** Releasing a live owner's lease is separate from closing client transport. */
+export declare function releaseRuntimeOwnerWhenIdle(owner: LocalRuntimeOwner | undefined, release: () => Promise<void>): Promise<void>;

package/dist/src/runtime/local-host/owner-retirement.js

@@ -0,0 +1,15 @@
+/** Releasing a live owner's lease is separate from closing client transport. */
+export function releaseRuntimeOwnerWhenIdle(owner, release) {
+    if (!owner?.whenIdle)
+        return release();
+    const alreadyIdle = owner.isIdle?.() === true;
+    const retirement = owner.whenIdle().then(release);
+    if (alreadyIdle)
+        return retirement;
+    void retirement.catch((error) => {
+        // Fail closed: uncertainty must never admit a second environment writer.
+        // A true process exit still permits the normal abandoned-PID recovery.
+        console.error("Local runtime owner retirement failed:", error);
+    });
+    return Promise.resolve();
+}

package/dist/src/runtime/local-host/owner-server.d.ts

@@ -0,0 +1,6 @@
+import type { LocalRuntimeEndpoint, LocalRuntimeOwner } from "./contracts.js";
+export declare function localRuntimeIdentityHeader(identity: string): string;
+export declare function startLocalRuntimeOwnerServer(identity: string, owner: LocalRuntimeOwner): Promise<{
+    endpoint: LocalRuntimeEndpoint;
+    close: () => Promise<void>;
+}>;

package/dist/src/runtime/local-host/owner-server.js

@@ -0,0 +1,88 @@
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+import { WebSocketServer } from "ws";
+import { closeHttpServerImmediately } from "../../shared/http-server-shutdown.js";
+import { LocalRuntimeRpcPeer } from "./rpc-peer.js";
+export function localRuntimeIdentityHeader(identity) {
+    return createHash("sha256").update(identity).digest("hex");
+}
+export async function startLocalRuntimeOwnerServer(identity, owner) {
+    const token = randomBytes(32).toString("hex");
+    const expectedIdentity = localRuntimeIdentityHeader(identity);
+    const peers = new Set();
+    const server = createServer((_request, response) => {
+        response.writeHead(404).end();
+    });
+    const sockets = new WebSocketServer({
+        server,
+        maxPayload: 64 * 1024 * 1024,
+        perMessageDeflate: false,
+        verifyClient: ({ req }) => isAuthenticatedLocalClient(req, token, expectedIdentity),
+    });
+    sockets.on("connection", (socket) => {
+        const rpc = new LocalRuntimeRpcPeer(socket);
+        const peer = Object.freeze({
+            id: rpc.id,
+            callClient: (method, args) => rpc.call(method, args),
+            onClose: (listener) => rpc.onClose(listener),
+        });
+        rpc.setHandler((method, args) => owner.call(method, args, peer));
+        peers.add(rpc);
+        rpc.onClose(() => {
+            peers.delete(rpc);
+        });
+    });
+    const unsubscribe = owner.subscribe((event) => {
+        for (const peer of peers)
+            peer.publish(event);
+    });
+    try {
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(0, "127.0.0.1", () => {
+                server.removeListener("error", reject);
+                resolve();
+            });
+        });
+    }
+    catch (error) {
+        unsubscribe();
+        sockets.close();
+        throw error;
+    }
+    const endpoint = {
+        version: 1,
+        identity,
+        pid: process.pid,
+        port: server.address().port,
+        token,
+    };
+    let shutdown;
+    return {
+        endpoint,
+        close: () => {
+            shutdown ??= closeOwner();
+            return shutdown;
+        },
+    };
+    async function closeOwner() {
+        unsubscribe();
+        const serverClosed = closeHttpServerImmediately(server, sockets);
+        for (const peer of peers)
+            peer.close();
+        await Promise.all([owner.stop(), serverClosed]);
+    }
+}
+function isAuthenticatedLocalClient(request, token, identity) {
+    if (request.socket.remoteAddress !== "127.0.0.1")
+        return false;
+    if (request.headers["x-abot-runtime-identity"] !== identity)
+        return false;
+    const authorization = request.headers.authorization ?? "";
+    const expected = `Bearer ${token}`;
+    const observedBytes = Buffer.from(authorization);
+    const expectedBytes = Buffer.from(expected);
+    if (observedBytes.length !== expectedBytes.length)
+        return false;
+    return timingSafeEqual(observedBytes, expectedBytes);
+}

package/dist/src/runtime/local-host/private-access.d.ts

@@ -0,0 +1,2 @@
+import type { Stats } from "node:fs";
+export declare function assertPrivateRuntimeAccess(path: string, stat: Stats, errorCode: string, newlyCreatedDirectory?: boolean): Promise<void>;

package/dist/src/runtime/local-host/private-access.js

@@ -0,0 +1,16 @@
+import { verifyWindowsPrivateAccess } from "./windows-private-access.js";
+export async function assertPrivateRuntimeAccess(path, stat, errorCode, newlyCreatedDirectory = false) {
+    if (process.platform === "win32") {
+        try {
+            await verifyWindowsPrivateAccess(path, newlyCreatedDirectory);
+            return;
+        }
+        catch {
+            throw new Error(errorCode);
+        }
+    }
+    if ((stat.mode & 0o077) !== 0)
+        throw new Error(errorCode);
+    if (process.getuid?.() !== stat.uid)
+        throw new Error(errorCode);
+}

package/dist/src/runtime/local-host/private-directory.d.ts

@@ -0,0 +1 @@
+export declare function ensurePrivateRuntimeDirectory(directory: string): Promise<void>;

package/dist/src/runtime/local-host/private-directory.js

@@ -0,0 +1,57 @@
+import { lstat, mkdir, mkdtemp, rename, rmdir } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { assertPrivateRuntimeAccess } from "./private-access.js";
+import { verifyWindowsPrivateAccess } from "./windows-private-access.js";
+export async function ensurePrivateRuntimeDirectory(directory) {
+    if (process.platform === "win32")
+        await installWindowsPrivateDirectory(directory);
+    else
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+    const stat = await lstat(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new Error("local_runtime_directory_not_private");
+    await assertPrivateRuntimeAccess(directory, stat, "local_runtime_directory_not_private");
+}
+async function installWindowsPrivateDirectory(directory) {
+    if (await hasExistingPath(directory))
+        return;
+    const parent = dirname(directory);
+    await mkdir(parent, { recursive: true });
+    const temporary = await mkdtemp(join(parent, `.${basename(directory)}.private-`));
+    try {
+        await verifyWindowsPrivateAccess(temporary, true);
+        try {
+            await rename(temporary, directory);
+        }
+        catch (error) {
+            if (!(await hasExistingPath(directory)))
+                throw error;
+            // A concurrent creator won; the caller verifies its installed ACL below.
+        }
+    }
+    catch {
+        throw new Error("local_runtime_directory_not_private");
+    }
+    finally {
+        await rmdir(temporary).catch((error) => {
+            if (!isMissingPath(error))
+                throw error;
+        });
+    }
+}
+async function hasExistingPath(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (isMissingPath(error))
+            return false;
+        throw error;
+    }
+}
+function isMissingPath(error) {
+    if (!error || typeof error !== "object" || !("code" in error))
+        return false;
+    return error.code === "ENOENT";
+}

package/dist/src/runtime/local-host/rpc-peer.d.ts

@@ -0,0 +1,22 @@
+import WebSocket from "ws";
+import type { LocalRuntimeCallHandler } from "./contracts.js";
+export declare class LocalRuntimeRpcPeer {
+    private readonly socket;
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    private readonly pending;
+    private readonly events;
+    private readonly closedListeners;
+    private handler;
+    private closed;
+    constructor(socket: WebSocket);
+    setHandler(handler: LocalRuntimeCallHandler): void;
+    call(method: string, args?: readonly unknown[]): Promise<unknown>;
+    subscribe(listener: (event: unknown) => void): () => void;
+    onClose(listener: () => void): () => void;
+    publish(value: unknown): void;
+    close(): void;
+    private send;
+    private receive;
+    private respond;
+    private disconnected;
+}

package/dist/src/runtime/local-host/rpc-peer.js

@@ -0,0 +1,168 @@
+import { randomUUID } from "node:crypto";
+import WebSocket from "ws";
+import { decodeRpcFrame, encodeRpcFrame, } from "./rpc-protocol.js";
+export class LocalRuntimeRpcPeer {
+    socket;
+    id = randomUUID();
+    pending = new Map();
+    events = new Set();
+    closedListeners = new Set();
+    handler = async () => {
+        throw new Error("local_runtime_client_handler_unavailable");
+    };
+    closed = false;
+    constructor(socket) {
+        this.socket = socket;
+        socket.on("message", (data, binary) => this.receive(data, binary));
+        socket.on("close", () => this.disconnected());
+        socket.on("error", () => this.disconnected());
+    }
+    setHandler(handler) {
+        this.handler = handler;
+    }
+    call(method, args = []) {
+        if (this.closed)
+            return Promise.reject(new Error("local_runtime_connection_lost"));
+        const id = randomUUID();
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            try {
+                this.send({ kind: "call", id, method, args });
+            }
+            catch (error) {
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    subscribe(listener) {
+        this.events.add(listener);
+        return () => {
+            this.events.delete(listener);
+        };
+    }
+    onClose(listener) {
+        if (this.closed) {
+            listener();
+            return () => { };
+        }
+        this.closedListeners.add(listener);
+        return () => {
+            this.closedListeners.delete(listener);
+        };
+    }
+    publish(value) {
+        if (this.closed)
+            return;
+        try {
+            this.send({ kind: "event", value });
+        }
+        catch {
+            this.close();
+        }
+    }
+    close() {
+        this.disconnected();
+        this.socket.terminate();
+    }
+    send(frame) {
+        if (this.socket.readyState !== WebSocket.OPEN)
+            throw new Error("local_runtime_connection_lost");
+        this.socket.send(encodeRpcFrame(frame), { binary: true }, (error) => {
+            if (error)
+                this.close();
+        });
+    }
+    receive(raw, binary) {
+        if (this.closed)
+            return;
+        try {
+            if (!binary)
+                throw new Error("local_runtime_invalid_frame");
+            const frame = decodeRpcFrame(toFrameBuffer(raw));
+            if (frame.kind === "call") {
+                void this.respond(frame);
+                return;
+            }
+            if (frame.kind === "event") {
+                for (const listener of this.events)
+                    invokeListener(() => listener(frame.value));
+                return;
+            }
+            const pending = this.pending.get(frame.id);
+            if (!pending)
+                return;
+            this.pending.delete(frame.id);
+            if (frame.kind === "error")
+                pending.reject(restoreRpcError(frame));
+            else
+                pending.resolve(frame.value);
+        }
+        catch {
+            this.close();
+        }
+    }
+    async respond(frame) {
+        try {
+            const value = await this.handler(frame.method, frame.args);
+            if (!this.closed)
+                this.send({ kind: "result", id: frame.id, value });
+        }
+        catch (error) {
+            if (this.closed)
+                return;
+            try {
+                this.send({
+                    kind: "error",
+                    id: frame.id,
+                    message: error instanceof Error ? error.message : String(error),
+                    ...(error instanceof Error ? { name: error.name } : {}),
+                    ...(hasRpcErrorCode(error) ? { code: error.code } : {}),
+                });
+            }
+            catch {
+                this.close();
+            }
+        }
+    }
+    disconnected() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const pending of this.pending.values())
+            pending.reject(new Error("local_runtime_connection_lost"));
+        this.pending.clear();
+        this.events.clear();
+        for (const listener of this.closedListeners)
+            invokeListener(listener);
+        this.closedListeners.clear();
+    }
+}
+function toFrameBuffer(data) {
+    if (Buffer.isBuffer(data))
+        return data;
+    if (Array.isArray(data))
+        return Buffer.concat(data);
+    return Buffer.from(data);
+}
+function invokeListener(listener) {
+    try {
+        listener();
+    }
+    catch {
+        /* Observers cannot break another peer's RPC. */
+    }
+}
+function hasRpcErrorCode(error) {
+    if (!error || typeof error !== "object" || !("code" in error))
+        return false;
+    return typeof error.code === "string";
+}
+function restoreRpcError(frame) {
+    const error = new Error(frame.message);
+    if (frame.name !== undefined)
+        error.name = frame.name;
+    if (frame.code !== undefined)
+        Object.assign(error, { code: frame.code });
+    return error;
+}

package/dist/src/runtime/local-host/rpc-protocol.d.ts

@@ -0,0 +1,21 @@
+export type RpcFrame = {
+    kind: "call";
+    id: string;
+    method: string;
+    args: readonly unknown[];
+} | {
+    kind: "result";
+    id: string;
+    value: unknown;
+} | {
+    kind: "error";
+    id: string;
+    message: string;
+    name?: string;
+    code?: string;
+} | {
+    kind: "event";
+    value: unknown;
+};
+export declare function encodeRpcFrame(frame: RpcFrame): Buffer;
+export declare function decodeRpcFrame(data: Buffer): RpcFrame;

package/dist/src/runtime/local-host/rpc-protocol.js

@@ -0,0 +1,46 @@
+import { deserialize, serialize } from "node:v8";
+export function encodeRpcFrame(frame) {
+    return serialize(frame);
+}
+export function decodeRpcFrame(data) {
+    const frame = deserialize(data);
+    if (!isRpcRecord(frame))
+        throw new Error("local_runtime_invalid_frame");
+    if (frame.kind === "event")
+        return { kind: "event", value: frame.value };
+    if (!hasRpcCorrelation(frame))
+        throw new Error("local_runtime_invalid_frame");
+    if (frame.kind === "result")
+        return { kind: "result", id: frame.id, value: frame.value };
+    if (frame.kind === "error" && typeof frame.message === "string")
+        return {
+            kind: "error",
+            id: frame.id,
+            message: frame.message,
+            ...(typeof frame.name === "string" ? { name: frame.name } : {}),
+            ...(typeof frame.code === "string" ? { code: frame.code } : {}),
+        };
+    if (hasRpcInvocation(frame))
+        return {
+            kind: "call",
+            id: frame.id,
+            method: frame.method,
+            args: frame.args,
+        };
+    throw new Error("local_runtime_invalid_frame");
+}
+function isRpcRecord(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    return !Array.isArray(value);
+}
+function hasRpcCorrelation(value) {
+    return typeof value.id === "string" && value.id.length > 0;
+}
+function hasRpcInvocation(value) {
+    if (value.kind !== "call")
+        return false;
+    if (typeof value.method !== "string" || !value.method)
+        return false;
+    return Array.isArray(value.args);
+}

package/dist/src/runtime/local-host/startup-connection.d.ts

@@ -0,0 +1,5 @@
+import type { LocalRuntimeConnectionOptions, LocalRuntimeEndpoint } from "./contracts.js";
+import { LocalRuntimeRpcPeer } from "./rpc-peer.js";
+export declare function connectToPublishedRuntimeOwner(options: Pick<LocalRuntimeConnectionOptions, "directory" | "identity">, deadline: number): Promise<LocalRuntimeRpcPeer | undefined>;
+export declare function waitForRuntimeOwnerElection(deadline: number): Promise<void>;
+export declare function connectToRuntimeOwner(endpoint: LocalRuntimeEndpoint, deadline: number): Promise<LocalRuntimeRpcPeer>;

package/dist/src/runtime/local-host/startup-connection.js

@@ -0,0 +1,72 @@
+import WebSocket from "ws";
+import { isLocalRuntimeProcessAlive, readLocalRuntimeEndpoint, } from "./endpoint.js";
+import { localRuntimeIdentityHeader } from "./owner-server.js";
+import { LocalRuntimeRpcPeer } from "./rpc-peer.js";
+export async function connectToPublishedRuntimeOwner(options, deadline) {
+    const endpoint = await readLocalRuntimeEndpoint(options.directory);
+    if (!endpoint)
+        return undefined;
+    if (!isLocalRuntimeProcessAlive(endpoint.pid))
+        return undefined;
+    assertRuntimeOwnerIdentity(endpoint, options.identity);
+    try {
+        return await connectToRuntimeOwner(endpoint, deadline);
+    }
+    catch (error) {
+        if (!isTransientRuntimeOwnerHandshakeFailure(error))
+            throw error;
+        return undefined;
+    }
+}
+export async function waitForRuntimeOwnerElection(deadline) {
+    assertRuntimeOwnerStartupTimeRemaining(deadline);
+    await new Promise((resolve) => setTimeout(resolve, Math.min(25, deadline - Date.now())));
+    assertRuntimeOwnerStartupTimeRemaining(deadline);
+}
+export async function connectToRuntimeOwner(endpoint, deadline) {
+    assertRuntimeOwnerStartupTimeRemaining(deadline);
+    return new Promise((resolve, reject) => {
+        const socket = new WebSocket(`ws://127.0.0.1:${endpoint.port}`, {
+            headers: {
+                authorization: `Bearer ${endpoint.token}`,
+                "x-abot-runtime-identity": localRuntimeIdentityHeader(endpoint.identity),
+            },
+            handshakeTimeout: Math.max(1, deadline - Date.now()),
+            maxPayload: 64 * 1024 * 1024,
+            perMessageDeflate: false,
+        });
+        const peer = new LocalRuntimeRpcPeer(socket);
+        const failed = (error) => {
+            peer.close();
+            reject(error);
+        };
+        socket.once("error", failed);
+        socket.once("open", () => {
+            socket.removeListener("error", failed);
+            resolve(peer);
+        });
+    });
+}
+function assertRuntimeOwnerIdentity(endpoint, identity) {
+    if (endpoint.identity !== identity)
+        throw new Error("local_runtime_identity_mismatch");
+}
+function assertRuntimeOwnerStartupTimeRemaining(deadline) {
+    if (Date.now() >= deadline)
+        throw new Error("local_runtime_owner_start_timeout");
+}
+function isTransientRuntimeOwnerHandshakeFailure(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (!("code" in error))
+        return false;
+    switch (error.code) {
+        case "ECONNREFUSED":
+        case "ECONNRESET":
+        case "EPIPE":
+        case "ETIMEDOUT":
+            return true;
+        default:
+            return false;
+    }
+}

package/dist/src/runtime/local-host/transport.d.ts

@@ -0,0 +1,3 @@
+import type { LocalRuntimeConnection, LocalRuntimeConnectionOptions } from "./contracts.js";
+export type { LocalRuntimeCallHandler, LocalRuntimeConnection, LocalRuntimeConnectionOptions, LocalRuntimeOwner, LocalRuntimePeer, } from "./contracts.js";
+export declare function createLocalRuntimeConnection(options: LocalRuntimeConnectionOptions): Promise<LocalRuntimeConnection>;