@rynx-ai/server 0.1.0 → 0.1.10-beta.2

package/dist/provider-cli-host.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderCliId, ProviderCliJob, ProviderCliOperation, ProviderCliStatusList } from "@rynx-ai/protocol/control";
+/** Read-only Runtime-owned Provider CLI inventory, safe to expose over Direct Runtime. */
+export interface ProviderCliStatusHost {
+    listStatuses(): Promise<ProviderCliStatusList>;
+}
+/** Local-machine mutation port. Control never forwards this interface remotely. */
+export interface ProviderCliManagementHost extends ProviderCliStatusHost {
+    startOperation(provider: ProviderCliId, operation: ProviderCliOperation): Promise<ProviderCliJob>;
+    getJob(id: string): ProviderCliJob | undefined;
+}

package/dist/provider-cli-host.js

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

package/dist/remote-runtime-dispatcher.d.ts

@@ -0,0 +1,94 @@
+import type { RemoteRuntimeEmulatorGesturePoint, RemoteRuntimeRpcRequest, RemoteRuntimeRpcResponse, RemoteRuntimeSequencedSessionEvent } from "@rynx-ai/protocol/remote-runtime-rpc";
+import { type DaemonRuntimeHost } from "./remote-runtime.js";
+import { type MachineSessionService } from "./machine-session-service.js";
+import { type SessionBrowserService } from "./session-browser-service.js";
+import { type SessionEmulatorService } from "./session-emulator-service.js";
+import { type SessionTerminalAttachment, type SessionTerminalHost, type SessionTerminalOpenOptions } from "./session-terminal-host.js";
+import type { ProviderCliStatusHost } from "./provider-cli-host.js";
+/** Binding-neutral application identity established before dispatch. */
+export interface AuthenticatedRuntimeSubject {
+    subjectId: string;
+    effectiveAuthorities: readonly string[];
+}
+export interface RemoteRuntimeDispatchContext {
+    subject: AuthenticatedRuntimeSubject;
+    signal?: AbortSignal;
+}
+export interface RemoteRuntimeDispatcherOptions {
+    runtime: DaemonRuntimeHost;
+    emulator?: RemoteRuntimeEmulatorHost;
+    sessionEmulators?: RemoteRuntimeSessionEmulatorHost;
+    sessions?: RemoteRuntimeSessionHost;
+    browsers?: RemoteRuntimeBrowserHost;
+    terminals?: SessionTerminalHost;
+    providerClis?: ProviderCliStatusHost;
+    /** Optional diagnostic sink. Wire errors deliberately omit internal details. */
+    onError?: (error: unknown, request: RemoteRuntimeRpcRequest) => void;
+}
+export type RemoteRuntimeSessionHost = Pick<MachineSessionService, "list" | "snapshot" | "watch" | "interrupt" | "agentOptions" | "launchOptions" | "create" | "sendMessage" | "resourcePolicy" | "beginResourceUpload" | "writeResourceUploadChunk" | "commitResourceUpload" | "getResource" | "readResource" | "deleteResource" | "enqueueMessage" | "startTerminal" | "delete" | "resolveInteraction">;
+export type RemoteRuntimeBrowserHost = Pick<SessionBrowserService, "getState" | "open" | "close" | "createPage" | "closePage" | "activatePage" | "navigatePage" | "goBack" | "goForward" | "reload">;
+export type RemoteRuntimeSessionEmulatorHost = Pick<SessionEmulatorService, "getState" | "listDevices" | "attach" | "detach" | "tap" | "type" | "button" | "rotate" | "launch" | "gesture" | "releaseDevice" | "stopDevice">;
+export interface OpenRemoteRuntimeSessionEvents {
+    sessionId: string;
+    daemonInstanceId: string;
+    events: AsyncIterable<RemoteRuntimeSequencedSessionEvent>;
+    cancel(): Promise<void>;
+}
+export type RemoteRuntimeSessionEventsOpenErrorCode = "unauthorized" | "invalid_request" | "method_not_found" | "internal";
+export declare class RemoteRuntimeSessionEventsOpenError extends Error {
+    readonly code: RemoteRuntimeSessionEventsOpenErrorCode;
+    constructor(code: RemoteRuntimeSessionEventsOpenErrorCode, message: string, options?: ErrorOptions);
+}
+/** Transport-independent emulator application port used by Local and Direct bindings. */
+export interface RemoteRuntimeEmulatorHost {
+    devices(): Promise<unknown[]>;
+    active(): Promise<unknown | null>;
+    deviceSession?(input: {
+        device: string;
+    }): Promise<unknown | null>;
+    attach(device?: string): Promise<unknown>;
+    tap(input: {
+        x: number;
+        y: number;
+        device?: string;
+    }): Promise<unknown>;
+    type(input: {
+        text: string;
+        device?: string;
+        mode?: string;
+    }): Promise<unknown>;
+    button(input: {
+        name?: string;
+        device?: string;
+    }): Promise<unknown>;
+    rotate(input: {
+        orientation: string;
+        device?: string;
+    }): Promise<unknown>;
+    launch(input: {
+        appId: string;
+        device?: string;
+    }): Promise<unknown>;
+    gesture(input: {
+        points: RemoteRuntimeEmulatorGesturePoint[];
+        device?: string;
+    }): Promise<unknown>;
+    kill(input: {
+        device?: string;
+    }): Promise<unknown>;
+    shutdown(input: {
+        device?: string;
+    }): Promise<unknown>;
+}
+/** Transport-neutral V1 unary dispatcher shared by Local and Direct bindings. */
+export declare class RemoteRuntimeDispatcher {
+    private readonly options;
+    constructor(options: RemoteRuntimeDispatcherOptions);
+    dispatch(request: RemoteRuntimeRpcRequest, { subject, signal }: RemoteRuntimeDispatchContext): Promise<RemoteRuntimeRpcResponse>;
+    openSessionEvents(sessionId: string, context: RemoteRuntimeDispatchContext): OpenRemoteRuntimeSessionEvents;
+    openSessionTerminal(sessionId: string, options: SessionTerminalOpenOptions, context: RemoteRuntimeDispatchContext): Promise<SessionTerminalAttachment>;
+    private withEmulator;
+    private withSessions;
+    private withSessionEmulators;
+    private withBrowsers;
+}

package/dist/remote-runtime-dispatcher.js

@@ -0,0 +1,403 @@
+import { encodeRemoteRuntimeRpcResponse, parseRemoteRuntimeRpcResponseForMethod, REMOTE_RUNTIME_RPC_METHOD_METADATA, } from "@rynx-ai/protocol/remote-runtime-rpc";
+import { encodeDaemonStatus } from "./remote-runtime.js";
+import { MachineSessionServiceFailure, MachineSessionServiceInputError, } from "./machine-session-service.js";
+import { SessionBrowserServiceError, } from "./session-browser-service.js";
+import { SessionEmulatorServiceError, } from "./session-emulator-service.js";
+import { projectRemoteRuntimeSessionEvent, projectRemoteRuntimeSessionListResult, projectRemoteRuntimeSessionSnapshotResult, } from "./remote-runtime-session-projection.js";
+import { SessionTerminalOpenError, } from "./session-terminal-host.js";
+const FULL_DAEMON_AUTHORITY = "daemon.full";
+export class RemoteRuntimeSessionEventsOpenError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = "RemoteRuntimeSessionEventsOpenError";
+    }
+}
+/** Transport-neutral V1 unary dispatcher shared by Local and Direct bindings. */
+export class RemoteRuntimeDispatcher {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async dispatch(request, { subject, signal }) {
+        if (signal?.aborted) {
+            return rpcError(request.id, "invalid_request", "Remote Runtime request was cancelled");
+        }
+        if (!subject.effectiveAuthorities.includes(FULL_DAEMON_AUTHORITY)) {
+            return rpcError(request.id, "unauthorized", "Remote Runtime authority is insufficient");
+        }
+        try {
+            switch (request.method) {
+                case "status.get":
+                    return rpcResult(request, encodeDaemonStatus(this.options.runtime.status()));
+                case "provider.cli.status.list":
+                    return this.options.providerClis
+                        ? rpcResult(request, await this.options.providerClis.listStatuses())
+                        : rpcError(request.id, "method_not_found", "Provider CLI status is unavailable");
+                case "emulator.devices.list":
+                    return await this.withEmulator(request, (emulator) => emulator.devices());
+                case "emulator.active.get":
+                    return await this.withEmulator(request, (emulator) => {
+                        if (!request.params.device)
+                            return emulator.active();
+                        if (!emulator.deviceSession) {
+                            throw new Error("device-scoped emulator sessions are unavailable");
+                        }
+                        return emulator.deviceSession({ device: request.params.device });
+                    });
+                case "emulator.attach":
+                    return await this.withEmulator(request, (emulator) => emulator.attach(request.params.device));
+                case "emulator.tap":
+                    return await this.withEmulator(request, (emulator) => emulator.tap(request.params));
+                case "emulator.type":
+                    return await this.withEmulator(request, (emulator) => emulator.type(request.params));
+                case "emulator.button":
+                    return await this.withEmulator(request, (emulator) => emulator.button(request.params));
+                case "emulator.rotate":
+                    return await this.withEmulator(request, (emulator) => emulator.rotate(request.params));
+                case "emulator.launch":
+                    return await this.withEmulator(request, (emulator) => emulator.launch(request.params));
+                case "emulator.gesture":
+                    return await this.withEmulator(request, (emulator) => emulator.gesture(request.params));
+                case "emulator.kill":
+                    return this.options.sessionEmulators
+                        ? rpcResult(request, await this.options.sessionEmulators.stopDevice({
+                            action: "kill",
+                            ...(request.params.device ? { device: request.params.device } : {}),
+                        }))
+                        : await this.withEmulator(request, (emulator) => emulator.kill(request.params));
+                case "emulator.shutdown":
+                    return this.options.sessionEmulators
+                        ? rpcResult(request, await this.options.sessionEmulators.stopDevice({
+                            action: "shutdown",
+                            ...(request.params.device ? { device: request.params.device } : {}),
+                        }))
+                        : await this.withEmulator(request, (emulator) => emulator.shutdown(request.params));
+                case "session.emulator.state.get":
+                    return await this.withSessionEmulators(request, (emulators) => emulators.getState(request.params));
+                case "session.emulator.devices.list":
+                    return await this.withSessionEmulators(request, (emulators) => emulators.listDevices(request.params));
+                case "session.emulator.attach":
+                    return await this.withSessionEmulators(request, (emulators) => emulators.attach(request.params));
+                case "session.emulator.detach":
+                    return await this.withSessionEmulators(request, (emulators) => emulators.detach(request.params));
+                case "session.emulator.tap":
+                    return await this.withSessionEmulators(request, (emulators) => emulators.tap(request.params));
+                case "session.emulator.type":
+                    return await this.withSessionEmulators(request, (emulators) => emulators.type(request.params));
+                case "session.emulator.button":
+                    return await this.withSessionEmulators(request, (emulators) => emulators.button(request.params));
+                case "session.emulator.rotate":
+                    return await this.withSessionEmulators(request, (emulators) => emulators.rotate(request.params));
+                case "session.emulator.launch":
+                    return await this.withSessionEmulators(request, (emulators) => emulators.launch(request.params));
+                case "session.emulator.gesture":
+                    return await this.withSessionEmulators(request, (emulators) => emulators.gesture(request.params));
+                case "session.list":
+                    return await this.withSessions(request, async (sessions) => projectRemoteRuntimeSessionListResult(await sessions.list(request.params)));
+                case "session.agentOptions.list":
+                    return await this.withSessions(request, (sessions) => sessions.agentOptions());
+                case "session.launchOptions.list":
+                    return await this.withSessions(request, (sessions) => sessions.launchOptions());
+                case "session.create":
+                    return await this.withSessions(request, (sessions) => sessions.create(request.params));
+                case "session.message.send":
+                    return await this.withSessions(request, (sessions) => {
+                        const { sessionId, ...input } = request.params;
+                        return sessions.sendMessage(sessionId, input.content === undefined && input.clientMessageId === undefined
+                            ? input.message
+                            : input);
+                    });
+                case "session.resource.policy.get":
+                    return await this.withSessions(request, async (sessions) => sessions.resourcePolicy(request.params.sessionId));
+                case "session.resource.upload.begin":
+                    return await this.withSessions(request, (sessions) => sessions.beginResourceUpload(request.params));
+                case "session.resource.upload.chunk":
+                    return await this.withSessions(request, (sessions) => sessions.writeResourceUploadChunk(request.params));
+                case "session.resource.upload.commit":
+                    return await this.withSessions(request, (sessions) => sessions.commitResourceUpload(request.params));
+                case "session.resource.get":
+                    return await this.withSessions(request, (sessions) => sessions.getResource(request.params));
+                case "session.resource.read":
+                    return await this.withSessions(request, (sessions) => sessions.readResource(request.params));
+                case "session.resource.delete":
+                    return await this.withSessions(request, (sessions) => sessions.deleteResource(request.params));
+                case "session.message.enqueue":
+                    return await this.withSessions(request, (sessions) => sessions.enqueueMessage(request.params.sessionId, request.params.message));
+                case "session.terminal.start":
+                    return await this.withSessions(request, (sessions) => sessions.startTerminal(request.params.sessionId));
+                case "session.delete":
+                    return await this.withSessions(request, (sessions) => sessions.delete(request.params.sessionId));
+                case "session.snapshot.get":
+                    return await this.withSessions(request, async (sessions) => projectRemoteRuntimeSessionSnapshotResult(await sessions.snapshot(request.params)));
+                case "session.interrupt":
+                    return await this.withSessions(request, (sessions) => sessions.interrupt(request.params.sessionId));
+                case "session.interaction.resolve":
+                    return await this.withSessions(request, (sessions) => sessions.resolveInteraction(request.params.sessionId, request.params.interactionId, request.params.resolution));
+                case "browser.state.get":
+                    return await this.withBrowsers(request, (browsers) => browsers.getState(request.params));
+                case "browser.open":
+                    return await this.withBrowsers(request, (browsers) => browsers.open(request.params));
+                case "browser.close":
+                    return await this.withBrowsers(request, (browsers) => browsers.close(request.params));
+                case "browser.page.create":
+                    return await this.withBrowsers(request, (browsers) => browsers.createPage(request.params));
+                case "browser.page.close":
+                    return await this.withBrowsers(request, (browsers) => browsers.closePage(request.params));
+                case "browser.page.activate":
+                    return await this.withBrowsers(request, (browsers) => browsers.activatePage(request.params));
+                case "browser.page.navigate":
+                    return await this.withBrowsers(request, (browsers) => browsers.navigatePage(request.params));
+                case "browser.page.back":
+                    return await this.withBrowsers(request, (browsers) => browsers.goBack(request.params));
+                case "browser.page.forward":
+                    return await this.withBrowsers(request, (browsers) => browsers.goForward(request.params));
+                case "browser.page.reload":
+                    return await this.withBrowsers(request, (browsers) => browsers.reload(request.params));
+            }
+            return rpcError(request.id, "method_not_found", "Remote Runtime method is not supported");
+        }
+        catch (error) {
+            this.options.onError?.(error, request);
+            const mapped = mapHostError(request, error);
+            return rpcError(request.id, mapped.code, mapped.message);
+        }
+    }
+    openSessionEvents(sessionId, context) {
+        if (context.signal?.aborted) {
+            throw new RemoteRuntimeSessionEventsOpenError("invalid_request", "Remote Session subscription was cancelled");
+        }
+        if (!context.subject.effectiveAuthorities.includes(FULL_DAEMON_AUTHORITY)) {
+            throw new RemoteRuntimeSessionEventsOpenError("unauthorized", "Remote Runtime authority is insufficient");
+        }
+        const sessions = this.options.sessions;
+        if (!sessions) {
+            throw new RemoteRuntimeSessionEventsOpenError("method_not_found", "Remote Runtime sessions are unavailable");
+        }
+        const daemonInstanceId = this.options.runtime.status().daemonInstanceId;
+        let watch;
+        try {
+            // MachineSessionService.watch installs its bus listener synchronously.
+            watch = sessions.watch(sessionId, { signal: context.signal });
+        }
+        catch (error) {
+            if (error instanceof MachineSessionServiceInputError) {
+                throw new RemoteRuntimeSessionEventsOpenError("invalid_request", "Remote Session subscription argument is invalid", { cause: error });
+            }
+            throw new RemoteRuntimeSessionEventsOpenError("internal", "Remote Session subscription could not be opened", { cause: error });
+        }
+        if (watch.sessionId !== sessionId) {
+            void watch.cancel().catch(() => undefined);
+            throw new RemoteRuntimeSessionEventsOpenError("internal", "Remote Session subscription identity mismatch");
+        }
+        const cancel = idempotentCancel(watch);
+        return {
+            sessionId,
+            daemonInstanceId,
+            events: projectedSessionEvents(watch, sessionId, cancel),
+            cancel,
+        };
+    }
+    async openSessionTerminal(sessionId, options, context) {
+        if (context.signal?.aborted) {
+            throw new SessionTerminalOpenError("invalid_request", "Remote Session terminal open was cancelled");
+        }
+        if (!context.subject.effectiveAuthorities.includes(FULL_DAEMON_AUTHORITY)) {
+            throw new SessionTerminalOpenError("unauthorized", "Remote Runtime authority is insufficient");
+        }
+        const terminals = this.options.terminals;
+        if (!terminals) {
+            throw new SessionTerminalOpenError("method_not_found", "Remote Runtime Session terminals are unavailable");
+        }
+        try {
+            const attachment = await terminals.open(sessionId, {
+                ...options,
+                ...(context.signal ? { signal: context.signal } : {}),
+            });
+            if (attachment.sessionId !== sessionId) {
+                await attachment.close().catch(() => undefined);
+                throw new SessionTerminalOpenError("internal", "Remote Session terminal identity mismatch");
+            }
+            return attachment;
+        }
+        catch (error) {
+            if (error instanceof SessionTerminalOpenError)
+                throw error;
+            throw new SessionTerminalOpenError("internal", "Remote Session terminal could not be opened", { cause: error });
+        }
+    }
+    async withEmulator(request, invoke) {
+        const emulator = this.options.emulator;
+        if (!emulator) {
+            return rpcError(request.id, "method_not_found", "Remote Runtime emulator is unavailable");
+        }
+        return rpcResult(request, await invoke(emulator));
+    }
+    async withSessions(request, invoke) {
+        const sessions = this.options.sessions;
+        if (!sessions) {
+            return rpcError(request.id, "method_not_found", "Remote Runtime sessions are unavailable");
+        }
+        return rpcResult(request, await invoke(sessions));
+    }
+    async withSessionEmulators(request, invoke) {
+        const emulators = this.options.sessionEmulators;
+        if (!emulators) {
+            return rpcError(request.id, "method_not_found", "Remote Runtime Session Emulator is unavailable");
+        }
+        return rpcResult(request, await invoke(emulators));
+    }
+    async withBrowsers(request, invoke) {
+        const browsers = this.options.browsers;
+        if (!browsers) {
+            return rpcError(request.id, "method_not_found", "Remote Runtime Browser is unavailable");
+        }
+        return rpcResult(request, await invoke(browsers));
+    }
+}
+function mapHostError(request, error) {
+    if (error instanceof SessionBrowserServiceError) {
+        switch (error.code) {
+            case "invalid_request":
+                return { code: "invalid_request", message: "Browser request argument is invalid" };
+            case "not_found":
+                return { code: "not_found", message: "Browser resource was not found" };
+            case "generation_mismatch":
+                return { code: "conflict", message: "Browser generation is stale" };
+            case "unavailable":
+            case "capacity":
+            case "shutting_down":
+                return { code: "failed_precondition", message: "Browser operation is unavailable" };
+            case "outcome_unknown":
+                return { code: "outcome_unknown", message: "Browser operation may have been applied" };
+            case "host_failure":
+                return { code: "internal", message: "Browser Host request failed" };
+        }
+    }
+    if (error instanceof SessionEmulatorServiceError) {
+        switch (error.code) {
+            case "session_not_found":
+            case "device_not_found":
+                return { code: "not_found", message: "Session Emulator resource was not found" };
+            case "device_in_use":
+            case "binding_mismatch":
+                return { code: "conflict", message: "Session Emulator binding changed or is in use" };
+            case "emulator_unavailable":
+                return { code: "failed_precondition", message: "Session Emulator is unavailable" };
+        }
+    }
+    if (error instanceof MachineSessionServiceInputError) {
+        return { code: "invalid_request", message: "Remote Session request argument is invalid" };
+    }
+    if (error instanceof MachineSessionServiceFailure) {
+        const message = error.code === "not_found"
+            ? "Remote Session resource was not found"
+            : error.code === "failed_precondition"
+                ? "Remote Session operation is unavailable"
+                : error.code === "conflict"
+                    ? "Remote Session resource conflicts with existing state"
+                    : "Remote Session operation may have been applied";
+        return { code: error.code, message };
+    }
+    if (request.method === "session.interrupt") {
+        return {
+            code: "outcome_unknown",
+            message: "Session interrupt may have been applied",
+        };
+    }
+    if (request.method.startsWith("session.") &&
+        REMOTE_RUNTIME_RPC_METHOD_METADATA[request.method].retryPolicy === "never") {
+        return {
+            code: "outcome_unknown",
+            message: "Remote Session operation may have been applied",
+        };
+    }
+    if (!request.method.startsWith("emulator.")) {
+        return { code: "internal", message: "Remote Runtime request failed" };
+    }
+    const emulatorCode = emulatorHostErrorCode(error);
+    if (emulatorCode === "emulator_invalid_argument") {
+        return { code: "invalid_request", message: "Emulator operation argument is invalid" };
+    }
+    if (emulatorCode === "emulator_device_not_found" || emulatorCode === "emulator_app_not_found") {
+        return { code: "not_found", message: "Emulator device or application was not found" };
+    }
+    if (emulatorCode === "emulator_android_unavailable" ||
+        emulatorCode === "emulator_ios_unavailable" ||
+        emulatorCode === "emulator_android_device_unavailable" ||
+        emulatorCode === "emulator_unsupported") {
+        return { code: "failed_precondition", message: "Emulator operation is unavailable" };
+    }
+    if (emulatorCode === "emulator_command_failed" && sentEmulatorFrames(error) === 0) {
+        return { code: "operation_failed", message: "Emulator operation failed before input was sent" };
+    }
+    if (REMOTE_RUNTIME_RPC_METHOD_METADATA[request.method].retryPolicy === "never") {
+        return {
+            code: "outcome_unknown",
+            message: "Emulator operation may have been partially applied",
+        };
+    }
+    return { code: "internal", message: "Remote Runtime request failed" };
+}
+function idempotentCancel(watch) {
+    let pending;
+    return () => {
+        pending ??= Promise.resolve().then(() => watch.cancel());
+        return pending;
+    };
+}
+function projectedSessionEvents(watch, sessionId, cancel) {
+    const source = watch[Symbol.asyncIterator]();
+    return {
+        [Symbol.asyncIterator]() {
+            return {
+                async next() {
+                    try {
+                        const next = await source.next();
+                        if (next.done) {
+                            await cancel();
+                            return { value: undefined, done: true };
+                        }
+                        return {
+                            value: projectRemoteRuntimeSessionEvent(next.value, sessionId),
+                            done: false,
+                        };
+                    }
+                    catch (error) {
+                        await cancel().catch(() => undefined);
+                        throw error;
+                    }
+                },
+                async return() {
+                    await cancel();
+                    return { value: undefined, done: true };
+                },
+            };
+        },
+    };
+}
+function emulatorHostErrorCode(error) {
+    if (!error || typeof error !== "object" || !("code" in error))
+        return undefined;
+    const code = error.code;
+    return typeof code === "string" && code.startsWith("emulator_") ? code : undefined;
+}
+function sentEmulatorFrames(error) {
+    if (!error || typeof error !== "object" || !("sentFrames" in error))
+        return undefined;
+    const sentFrames = error.sentFrames;
+    return typeof sentFrames === "number" && Number.isSafeInteger(sentFrames) && sentFrames >= 0
+        ? sentFrames
+        : undefined;
+}
+function rpcResult(request, result) {
+    const response = parseRemoteRuntimeRpcResponseForMethod({ type: "rpc.result", id: request.id, result }, request.method);
+    // Enforce the Direct binding's aggregate frame budget even for the Local
+    // binding, so transport selection cannot change accepted result semantics.
+    encodeRemoteRuntimeRpcResponse(response, request.method);
+    return response;
+}
+function rpcError(id, code, message) {
+    return { type: "rpc.error", id, error: { code, message } };
+}

package/dist/remote-runtime-session-projection.d.ts

@@ -0,0 +1,19 @@
+import { type SequencedSessionEvent, type SessionItem } from "@rynx-ai/protocol";
+import { type RemoteRuntimeSequencedSessionEvent, type RemoteRuntimeSessionItem, type RemoteRuntimeSessionListResult, type RemoteRuntimeSessionSnapshotResult } from "@rynx-ai/protocol/remote-runtime-rpc";
+export declare class RemoteRuntimeSessionProjectionError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+/** Validate the list application result without truncating identity or summaries. */
+export declare function projectRemoteRuntimeSessionListResult(value: unknown): RemoteRuntimeSessionListResult;
+/** Project canonical history payloads into the bounded Direct Runtime DTO. */
+export declare function projectRemoteRuntimeSessionSnapshotResult(value: {
+    sessionId: string;
+    items: SessionItem[];
+    runtime: unknown;
+    hasMore: boolean;
+    nextAfterId?: string;
+}): RemoteRuntimeSessionSnapshotResult;
+/** Project one canonical durable item, preserving every identity and array entry. */
+export declare function projectRemoteRuntimeSessionItem(item: SessionItem): RemoteRuntimeSessionItem;
+/** Project one live event and reject any event that can be proven cross-session. */
+export declare function projectRemoteRuntimeSessionEvent(event: SequencedSessionEvent, expectedSessionId?: string): RemoteRuntimeSequencedSessionEvent;