@abot-ai/runtime 1.1.0 → 1.3.0

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

@@ -0,0 +1,4 @@
+import { type RuntimeDependencyOverrides } from "../composition.js";
+import type { RuntimeConfig } from "../ports.js";
+import type { LocalRuntimeOwner } from "./contracts.js";
+export declare function createLocalRuntimeOwner(config: RuntimeConfig, overrides?: RuntimeDependencyOverrides): Promise<LocalRuntimeOwner>;

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

@@ -0,0 +1,119 @@
+import { createRuntimeApplication, } from "../composition.js";
+import { LocalMemoryDispatcher } from "./app-memory-dispatch.js";
+import { LocalRequestControls, } from "./app-request-control.js";
+import { dispatchLocalServiceCall } from "./app-service-dispatch.js";
+import { LocalRuntimeOwnerActivity } from "./owner-activity.js";
+export async function createLocalRuntimeOwner(config, overrides = {}) {
+    const listeners = new Set();
+    const publish = (event) => {
+        for (const listener of listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                /* A subscribing view cannot change canonical request execution. */
+            }
+        }
+    };
+    const controls = new LocalRequestControls(publish);
+    const activity = new LocalRuntimeOwnerActivity();
+    const application = createRuntimeApplication(config, {
+        ...overrides,
+        scheduledRequestOptions: (run) => controls.scheduled(run),
+    });
+    const memory = new LocalMemoryDispatcher(application.services.longTermMemory);
+    const unsubscribe = application.subscribeScheduledEvents((event) => {
+        publish({ type: "scheduled.event", event });
+        if (event.type === "completed" || event.type === "failed")
+            controls.finish(String(event.requestId));
+    });
+    try {
+        await application.start();
+    }
+    catch (error) {
+        activity.stop();
+        application.services.requestAdmission?.close();
+        unsubscribe();
+        await application.stop();
+        throw error;
+    }
+    let shutdown;
+    return {
+        call(method, args, peer) {
+            return activity.run(async () => {
+                if (method === "controls.register")
+                    return controls.register(peer);
+                if (method === "request.steer")
+                    return controls.steer(args[0], args[1]);
+                if (method === "request.run")
+                    return runPeerRequest(application, controls, activity, args, peer);
+                if (method.startsWith("memory."))
+                    return memory.call(method, args, peer);
+                return dispatchLocalServiceCall(application.services, method, args);
+            });
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        stop() {
+            if (shutdown)
+                return shutdown;
+            activity.stop();
+            application.services.requestAdmission?.close();
+            memory.stop();
+            controls.stop();
+            unsubscribe();
+            listeners.clear();
+            shutdown = application.stop();
+            return shutdown;
+        },
+        isIdle() {
+            if (!activity.isIdle())
+                return false;
+            return application.services.requestAdmission?.isIdle() ?? true;
+        },
+        async whenIdle() {
+            await Promise.all([
+                activity.whenIdle(),
+                application.services.requestAdmission?.whenIdle(),
+            ]);
+        },
+    };
+}
+async function runPeerRequest(application, controls, activity, args, peer) {
+    const message = args[0];
+    if (!message || typeof message.requestId !== "string")
+        throw new Error("local_runtime_request_invalid");
+    const options = controls.ordinary(message.requestId, peer, (args[1] ?? {}));
+    let connected = true;
+    const removeClose = peer.onClose(() => {
+        connected = false;
+    });
+    let delivery = Promise.resolve();
+    const socket = {
+        send(data) {
+            if (!connected)
+                return;
+            const event = JSON.parse(data);
+            delivery = delivery
+                .then(async () => {
+                if (connected)
+                    await peer.callClient("request.event", [message.requestId, event]);
+            })
+                .catch(() => {
+                connected = false;
+            });
+        },
+    };
+    try {
+        await peer.callClient("request.accepted", [message.requestId]);
+        activity.assertAcceptingRequests();
+        await application.requests.handle(socket, message, options);
+        await delivery;
+    }
+    finally {
+        removeClose();
+        controls.finish(message.requestId);
+    }
+}

package/dist/src/runtime/local-host/app-request-control.d.ts

@@ -0,0 +1,24 @@
+import type { RuntimeRequestOptions } from "../composition.js";
+import { type RequestSteeringUpdate } from "../request/request-steering.js";
+import type { SchedulerRun } from "../scheduler/contracts.js";
+import type { LocalRuntimePeer } from "./contracts.js";
+export type LocalRequestRunOptions = {
+    approvalAvailable?: boolean;
+    steeringUpdates?: readonly RequestSteeringUpdate[];
+};
+export declare class LocalRequestControls {
+    private readonly publish;
+    private readonly active;
+    private readonly controlPeers;
+    private readonly pendingApprovals;
+    constructor(publish: (event: unknown) => void);
+    register(peer: LocalRuntimePeer): Promise<void>;
+    ordinary(requestId: string, peer: LocalRuntimePeer, options: LocalRequestRunOptions): RuntimeRequestOptions;
+    scheduled(run: SchedulerRun): RuntimeRequestOptions;
+    steer(requestId: unknown, update: unknown): unknown;
+    finish(requestId: string): void;
+    stop(): void;
+    private open;
+    private approvals;
+    private requestApproval;
+}

package/dist/src/runtime/local-host/app-request-control.js

@@ -0,0 +1,135 @@
+import { createRequestSteeringInbox, } from "../request/request-steering.js";
+function readApprovalDecision(value) {
+    if (typeof value !== "object" || value === null)
+        return { approved: false, reason: "Tool approval response was invalid." };
+    const decision = value;
+    return {
+        approved: decision.approved === true,
+        ...(typeof decision.reason === "string" ? { reason: decision.reason } : {}),
+    };
+}
+export class LocalRequestControls {
+    publish;
+    active = new Map();
+    controlPeers = new Map();
+    pendingApprovals = new Set();
+    constructor(publish) {
+        this.publish = publish;
+    }
+    async register(peer) {
+        if (!this.controlPeers.has(peer.id)) {
+            this.controlPeers.set(peer.id, peer);
+            peer.onClose(() => this.controlPeers.delete(peer.id));
+        }
+        const runs = [...this.active.values()].flatMap((entry) => entry.run ? [entry.run] : []);
+        // Queue snapshots on the same ordered channel as subsequent run events.
+        await Promise.all(runs.map((run) => peer.callClient("scheduled.started", [run])));
+    }
+    ordinary(requestId, peer, options) {
+        const steering = this.open(requestId);
+        try {
+            for (const update of options.steeringUpdates ?? []) {
+                const accepted = steering.append(update);
+                if (!accepted.ok)
+                    throw new Error(accepted.reason);
+            }
+        }
+        catch (error) {
+            this.finish(requestId);
+            throw error;
+        }
+        return {
+            requestSteering: steering,
+            ...(options.approvalAvailable
+                ? { toolApprovalController: this.approvals(peer) }
+                : {}),
+        };
+    }
+    scheduled(run) {
+        const steering = this.open(run.requestId, run);
+        this.publish({ type: "scheduled.started", run });
+        const peer = this.controlPeers.values().next().value;
+        return {
+            requestSteering: steering,
+            ...(peer ? { toolApprovalController: this.approvals(peer) } : {}),
+        };
+    }
+    steer(requestId, update) {
+        if (typeof requestId !== "string")
+            return { ok: false, reason: "request_not_active" };
+        const control = this.active.get(requestId);
+        if (!control)
+            return { ok: false, reason: "request_not_active" };
+        if (!update || typeof update !== "object")
+            return { ok: false, reason: "invalid_steer_request" };
+        const input = update;
+        if (typeof input.steerId !== "string" || typeof input.text !== "string")
+            return { ok: false, reason: "invalid_steer_request" };
+        return control.steering.append({
+            steerId: input.steerId,
+            text: input.text,
+        });
+    }
+    finish(requestId) {
+        const entry = this.active.get(requestId);
+        this.active.delete(requestId);
+        void entry?.steering.close();
+    }
+    stop() {
+        this.controlPeers.clear();
+        for (const cancel of this.pendingApprovals)
+            cancel();
+        // Active canonical requests own their inbox lifetime until finalization.
+        this.active.clear();
+    }
+    open(requestId, run) {
+        if (!requestId || this.active.has(requestId))
+            throw new Error("local_runtime_request_already_active");
+        const steering = createRequestSteeringInbox({ requestId });
+        this.active.set(requestId, { steering, ...(run ? { run } : {}) });
+        return steering;
+    }
+    approvals(peer) {
+        return {
+            requestToolApproval: (request, options) => this.requestApproval(peer, request, options?.abortSignal),
+        };
+    }
+    requestApproval(peer, request, signal) {
+        if (signal?.aborted)
+            return Promise.resolve({
+                approved: false,
+                reason: "Tool approval was cancelled.",
+            });
+        return new Promise((resolve) => {
+            let settled = false;
+            let removeClose = () => { };
+            const complete = (decision) => {
+                if (settled)
+                    return;
+                settled = true;
+                signal?.removeEventListener("abort", cancel);
+                this.pendingApprovals.delete(cancel);
+                removeClose();
+                resolve(decision);
+            };
+            const cancel = () => {
+                void peer
+                    .callClient("request.approval.cancel", [request.approvalId])
+                    .catch(() => undefined);
+                complete({ approved: false, reason: "Tool approval was cancelled." });
+            };
+            this.pendingApprovals.add(cancel);
+            removeClose = peer.onClose(() => complete({
+                approved: false,
+                reason: "Tool approval connection was closed.",
+            }));
+            if (settled)
+                return;
+            signal?.addEventListener("abort", cancel, { once: true });
+            void peer.callClient("request.approval", [request]).then((decision) => complete(readApprovalDecision(decision)), () => complete({
+                approved: false,
+                reason: "Tool approval connection was closed.",
+            }));
+        });
+    }
+}

package/dist/src/runtime/local-host/app-service-dispatch.d.ts

@@ -0,0 +1,5 @@
+import type { RuntimeEnvironmentServices } from "../composition.js";
+export declare const LOCAL_SESSION_METHODS: readonly ["getOrCreateSession", "getAllSessions", "listSessions", "getSessionById", "getSessionSnapshot", "getRequestReplayById", "updateSessionTitle", "updateSessionRuntimeMode", "appendMessage", "appendContextEntry", "upsertArtifactPaths", "startRequestStream", "appendRequestEvent", "deleteSession", "deleteSessionWithStats", "resetSession", "clearSessionMessages", "deleteMessage", "deleteMessageWithStats", "compareAndSwapSessionMemoryCheckpoint"];
+export declare const LOCAL_ATTACHMENT_METHODS: readonly ["saveAttachment", "validateAttachmentReferences", "resolveAttachment", "deleteAttachment", "deleteSessionAttachments"];
+export declare const LOCAL_SCHEDULER_METHODS: readonly ["tick", "create", "list", "get", "update", "pause", "resume", "cancel", "runNow", "deleteSession", "listRuns"];
+export declare function dispatchLocalServiceCall(services: RuntimeEnvironmentServices, method: string, args: readonly unknown[]): Promise<unknown>;

package/dist/src/runtime/local-host/app-service-dispatch.js

@@ -0,0 +1,64 @@
+export const LOCAL_SESSION_METHODS = [
+    "getOrCreateSession",
+    "getAllSessions",
+    "listSessions",
+    "getSessionById",
+    "getSessionSnapshot",
+    "getRequestReplayById",
+    "updateSessionTitle",
+    "updateSessionRuntimeMode",
+    "appendMessage",
+    "appendContextEntry",
+    "upsertArtifactPaths",
+    "startRequestStream",
+    "appendRequestEvent",
+    "deleteSession",
+    "deleteSessionWithStats",
+    "resetSession",
+    "clearSessionMessages",
+    "deleteMessage",
+    "deleteMessageWithStats",
+    "compareAndSwapSessionMemoryCheckpoint",
+];
+export const LOCAL_ATTACHMENT_METHODS = [
+    "saveAttachment",
+    "validateAttachmentReferences",
+    "resolveAttachment",
+    "deleteAttachment",
+    "deleteSessionAttachments",
+];
+export const LOCAL_SCHEDULER_METHODS = [
+    "tick",
+    "create",
+    "list",
+    "get",
+    "update",
+    "pause",
+    "resume",
+    "cancel",
+    "runNow",
+    "deleteSession",
+    "listRuns",
+];
+function selectServiceMethod(target, method, methods) {
+    if (!methods.includes(method))
+        throw new Error("local_runtime_method_unknown");
+    if (!target)
+        throw new Error("local_runtime_service_unavailable");
+    const selected = target[method];
+    if (typeof selected !== "function")
+        throw new Error("local_runtime_method_unavailable");
+    return selected.bind(target);
+}
+export async function dispatchLocalServiceCall(services, method, args) {
+    const [service, operation, extra] = method.split(".");
+    if (!operation || extra)
+        throw new Error("local_runtime_method_unknown");
+    if (service === "sessions")
+        return selectServiceMethod(services.sessions, operation, LOCAL_SESSION_METHODS)(...args);
+    if (service === "attachments")
+        return selectServiceMethod(services.attachments, operation, LOCAL_ATTACHMENT_METHODS)(...args);
+    if (service === "scheduler")
+        return selectServiceMethod(services.scheduler, operation, LOCAL_SCHEDULER_METHODS)(...args);
+    throw new Error("local_runtime_method_unknown");
+}

package/dist/src/runtime/local-host/client-identity.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeConfig } from "../ports.js";
+/** Rejects attaching a caller whose resolved execution configuration differs. */
+export declare function resolveLocalRuntimeIdentity(config: RuntimeConfig): string;

package/dist/src/runtime/local-host/client-identity.js

@@ -0,0 +1,17 @@
+import { createHash } from "node:crypto";
+/** Rejects attaching a caller whose resolved execution configuration differs. */
+export function resolveLocalRuntimeIdentity(config) {
+    return createHash("sha256")
+        .update(JSON.stringify(canonicalConfigValue(config)))
+        .digest("hex");
+}
+function canonicalConfigValue(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalConfigValue);
+    if (value === null || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .filter(([, entry]) => entry !== undefined)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, entry]) => [key, canonicalConfigValue(entry)]));
+}

package/dist/src/runtime/local-host/client-memory.d.ts

@@ -0,0 +1,7 @@
+import type { LongTermMemoryService } from "../long-term-memory/contracts.js";
+import type { LocalRuntimeCallHandler } from "./contracts.js";
+/** Moves cancellation and callbacks explicitly; executable values never cross IPC. */
+export declare function createLocalMemoryClient(call: LocalRuntimeCallHandler, enabled: boolean): {
+    service: LongTermMemoryService;
+    handleEvent(args: readonly unknown[]): void;
+};

package/dist/src/runtime/local-host/client-memory.js

@@ -0,0 +1,54 @@
+import { randomUUID } from "node:crypto";
+/** Moves cancellation and callbacks explicitly; executable values never cross IPC. */
+export function createLocalMemoryClient(call, enabled) {
+    const eventListeners = new Map();
+    async function invoke(method, input) {
+        const operationId = randomUUID();
+        const operation = { operationId, cancelled: false };
+        const record = input;
+        const context = record?.context;
+        if (context?.abortSignal?.aborted)
+            throw context.abortSignal.reason;
+        const { abortSignal, onEvent, ...serializableContext } = context ?? {};
+        const argument = context
+            ? { ...record, context: serializableContext }
+            : input;
+        if (onEvent)
+            eventListeners.set(operationId, onEvent);
+        const abort = () => {
+            operation.cancelled = true;
+            void call("memory.cancel", [operationId]).catch(() => undefined);
+        };
+        abortSignal?.addEventListener("abort", abort, { once: true });
+        try {
+            return await call(`memory.${method}`, [argument, operation]);
+        }
+        finally {
+            abortSignal?.removeEventListener("abort", abort);
+            eventListeners.delete(operationId);
+        }
+    }
+    const service = {
+        enabled,
+        status: () => invoke("status"),
+        list: (input) => invoke("list", input),
+        search: (input) => invoke("search", input),
+        create: (input) => invoke("create", input),
+        update: (input) => invoke("update", input),
+        delete: (input) => invoke("delete", input),
+        clear: () => invoke("clear"),
+        retrieve: (input) => invoke("retrieve", input),
+        processCandidates: (input) => invoke("processCandidates", input),
+        scheduleCandidates: (input) => {
+            void invoke("scheduleCandidates", input).catch((error) => {
+                console.error("Local runtime memory scheduling failed:", error);
+            });
+        },
+    };
+    return {
+        service,
+        handleEvent(args) {
+            eventListeners.get(String(args[0]))?.(String(args[1]), args[2]);
+        },
+    };
+}

package/dist/src/runtime/local-host/client-requests.d.ts

@@ -0,0 +1,19 @@
+import type { RuntimeRequestHandler, RuntimeRequestOptions } from "../composition.js";
+import type { SchedulerRun } from "../scheduler/contracts.js";
+import type { LocalRuntimeCallHandler } from "./contracts.js";
+/** Client projections only. The owner validates and commits every steering update. */
+export declare class LocalRuntimeClientRequests {
+    private readonly call;
+    private readonly scheduledOptions?;
+    private readonly active;
+    private readonly approvals;
+    private readonly listeners;
+    constructor(call: LocalRuntimeCallHandler, scheduledOptions?: ((run: SchedulerRun) => RuntimeRequestOptions) | undefined);
+    readonly requests: RuntimeRequestHandler;
+    subscribe(listener: (event: Record<string, unknown>) => void): () => void;
+    receive(event: unknown): void;
+    handleCallback(method: string, args: readonly unknown[]): Promise<unknown>;
+    close(disconnected?: boolean): void;
+    private open;
+    private publish;
+}

package/dist/src/runtime/local-host/client-requests.js

@@ -0,0 +1,145 @@
+/** Client projections only. The owner validates and commits every steering update. */
+export class LocalRuntimeClientRequests {
+    call;
+    scheduledOptions;
+    active = new Map();
+    approvals = new Map();
+    listeners = new Set();
+    constructor(call, scheduledOptions) {
+        this.call = call;
+        this.scheduledOptions = scheduledOptions;
+    }
+    requests = {
+        handle: async (ws, message, options = {}) => {
+            const requestId = String(message.requestId ?? "");
+            if (this.active.has(requestId))
+                throw new Error("local_runtime_request_already_active");
+            const state = this.open(requestId, options, (event) => ws.send(JSON.stringify(event)));
+            try {
+                await this.call("request.run", [
+                    message,
+                    {
+                        approvalAvailable: Boolean(options.toolApprovalController),
+                        steeringUpdates: options.requestSteering?.snapshot().updates ?? [],
+                    },
+                ]);
+            }
+            finally {
+                state.accept();
+                this.active.delete(requestId);
+            }
+        },
+        steer: async (requestId, input) => {
+            await this.active.get(requestId)?.accepted;
+            return (await this.call("request.steer", [
+                requestId,
+                input,
+            ]));
+        },
+    };
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    receive(event) {
+        if (!event || typeof event !== "object")
+            return;
+        const envelope = event;
+        if (envelope.type === "scheduled.started") {
+            const run = envelope.run;
+            if (this.active.has(run.requestId))
+                return;
+            const state = this.open(run.requestId, this.scheduledOptions?.(run) ?? {});
+            state.run = run;
+            state.accept();
+            return;
+        }
+        if (envelope.type !== "scheduled.event")
+            return;
+        const payload = envelope.event;
+        this.publish(payload);
+        if (payload.type === "completed" || payload.type === "failed") {
+            this.active.delete(String(payload.requestId));
+        }
+    }
+    async handleCallback(method, args) {
+        if (method === "scheduled.started") {
+            this.receive({ type: "scheduled.started", run: args[0] });
+            return null;
+        }
+        if (method === "request.accepted") {
+            this.active.get(String(args[0]))?.accept();
+            return null;
+        }
+        if (method === "request.event") {
+            this.active
+                .get(String(args[0]))
+                ?.send?.(args[1]);
+            return null;
+        }
+        if (method === "request.approval.cancel") {
+            this.approvals.get(String(args[0]))?.abort();
+            return null;
+        }
+        if (method !== "request.approval")
+            throw new Error("local_runtime_callback_unknown");
+        const request = args[0];
+        const approval = this.active.get(request.requestId)?.options
+            .toolApprovalController;
+        if (!approval)
+            return { approved: false, reason: "Tool approval is unavailable." };
+        const controller = new AbortController();
+        this.approvals.set(request.approvalId, controller);
+        try {
+            return await approval.requestToolApproval(request, {
+                abortSignal: controller.signal,
+            });
+        }
+        finally {
+            this.approvals.delete(request.approvalId);
+        }
+    }
+    close(disconnected = false) {
+        if (disconnected) {
+            for (const [requestId, state] of this.active) {
+                if (!state.run)
+                    continue;
+                this.publish({
+                    type: "failed",
+                    requestId,
+                    sessionId: state.run.sessionId,
+                    environment: state.run.environmentId,
+                    error: "local_runtime_disconnected_outcome_unknown",
+                });
+            }
+        }
+        for (const controller of this.approvals.values())
+            controller.abort();
+        for (const state of this.active.values())
+            state.accept();
+        this.active.clear();
+        this.approvals.clear();
+        this.listeners.clear();
+    }
+    open(requestId, options, send) {
+        let accept;
+        const accepted = new Promise((resolve) => {
+            accept = resolve;
+        });
+        const state = { options, send, accept, accepted };
+        this.active.set(requestId, state);
+        return state;
+    }
+    publish(event) {
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // A client view cannot prevent request or approval cleanup.
+            }
+        }
+    }
+}

package/dist/src/runtime/local-host/client-services.d.ts

@@ -0,0 +1,10 @@
+import type { SessionStore } from "../ports.js";
+import type { RuntimeAttachmentStore } from "../attachments/store.js";
+import type { SchedulerService } from "../scheduler/contracts.js";
+import type { LocalRuntimeCallHandler } from "./contracts.js";
+/** Projections of owner APIs; lifecycle remains with the managed application. */
+export declare function createLocalServiceClients(call: LocalRuntimeCallHandler): {
+    sessions: SessionStore;
+    attachments: RuntimeAttachmentStore;
+    scheduler: Omit<SchedulerService, "stop" | "start">;
+};

package/dist/src/runtime/local-host/client-services.js

@@ -0,0 +1,14 @@
+import { bindManagedSessionAttachmentDeletion } from "../session/session-attachment-deletion.js";
+import { LOCAL_SESSION_METHODS, LOCAL_ATTACHMENT_METHODS, LOCAL_SCHEDULER_METHODS, } from "./app-service-dispatch.js";
+/** Projections of owner APIs; lifecycle remains with the managed application. */
+export function createLocalServiceClients(call) {
+    const service = (prefix, methods) => Object.fromEntries(methods.map((method) => [
+        method,
+        (...args) => call(`${prefix}.${method}`, args),
+    ]));
+    const sessions = service("sessions", LOCAL_SESSION_METHODS);
+    const attachments = service("attachments", LOCAL_ATTACHMENT_METHODS);
+    const scheduler = service("scheduler", LOCAL_SCHEDULER_METHODS);
+    bindManagedSessionAttachmentDeletion(sessions, attachments);
+    return { sessions, attachments, scheduler };
+}

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

@@ -0,0 +1,36 @@
+export type LocalRuntimeCallHandler = (method: string, args: readonly unknown[]) => Promise<unknown>;
+export type LocalRuntimePeer = Readonly<{
+    id: string;
+    callClient: LocalRuntimeCallHandler;
+    onClose: (listener: () => void) => () => void;
+}>;
+export type LocalRuntimeOwner = Readonly<{
+    call: (method: string, args: readonly unknown[], peer: LocalRuntimePeer) => Promise<unknown>;
+    subscribe: (listener: (event: unknown) => void) => () => void;
+    stop: () => Promise<void>;
+    /** Synchronous activity snapshot; stable after stop has closed intake. */
+    isIdle?: () => boolean;
+    /** Settles only after stopped-owner execution and persistence have finished. */
+    whenIdle?: () => Promise<void>;
+}>;
+export type LocalRuntimeConnection = Readonly<{
+    ownership: "owner" | "client";
+    call: (method: string, args?: readonly unknown[]) => Promise<unknown>;
+    subscribe: (listener: (event: unknown) => void) => () => void;
+    setClientHandler: (handler: LocalRuntimeCallHandler) => void;
+    onClose: (listener: () => void) => () => void;
+    close: () => Promise<void>;
+}>;
+export type LocalRuntimeConnectionOptions = Readonly<{
+    directory: string;
+    identity: string;
+    createOwner: () => Promise<LocalRuntimeOwner>;
+    startupTimeoutMs?: number;
+}>;
+export type LocalRuntimeEndpoint = Readonly<{
+    version: 1;
+    identity: string;
+    pid: number;
+    port: number;
+    token: string;
+}>;

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

@@ -0,0 +1 @@
+export {};