@rynx-ai/remote-runtime-client 0.1.9

package/dist/client.d.ts

@@ -0,0 +1,86 @@
+import { type RemoteRuntimeRpcMethod, type RemoteRuntimeRpcParams, type RemoteRuntimeRpcResultFor, type RemoteRuntimeSequencedSessionEvent, type RemoteRuntimeSessionTerminalClosedFrame, type RemoteRuntimeSessionTerminalRole } from "@rynx-ai/protocol/remote-runtime-rpc";
+import { type DaemonStatus } from "@rynx-ai/protocol/remote-runtime";
+import { type RuntimeEmulatorSurfaceClosedFrame, type RuntimeEmulatorSurfaceImageFrame, type RuntimeEmulatorSurfaceReadyFrame } from "@rynx-ai/protocol/runtime-emulator-surface";
+import { type DirectRuntimeClientIdentity, type DirectRuntimeCredential } from "./credential.js";
+export interface DirectRuntimeClientOptions {
+    /** Overall connect/handshake timeout and the default per-RPC timeout. */
+    timeoutMs?: number;
+    /** RFC 6455 control-frame liveness; primarily exposed for deployment tests. */
+    liveness?: {
+        pingIntervalMs?: number;
+        inactivityTimeoutMs?: number;
+    };
+}
+export interface DirectRuntimeCallOptions {
+    /** Per-call override for operations whose expected duration differs from the handshake. */
+    timeoutMs?: number;
+}
+export interface DirectRuntimeSessionEventsOptions {
+    /** Timeout for the accepted ready barrier and cancellation acknowledgement. */
+    timeoutMs?: number;
+}
+export interface DirectRuntimeSessionEventsSubscription extends AsyncIterable<RemoteRuntimeSequencedSessionEvent> {
+    readonly subscriptionId: string;
+    readonly sessionId: string;
+    readonly daemonInstanceId: string;
+    /** Idempotently cancel the remote stream and wait for its close acknowledgement. */
+    close(): Promise<void>;
+}
+export interface DirectRuntimeSessionTerminalOptions {
+    role: RemoteRuntimeSessionTerminalRole;
+    cols: number;
+    rows: number;
+    /** Timeout for the opened barrier and close acknowledgement. */
+    timeoutMs?: number;
+}
+export interface DirectRuntimeSessionTerminal extends AsyncIterable<Uint8Array> {
+    readonly attachmentId: string;
+    readonly sessionId: string;
+    readonly role: RemoteRuntimeSessionTerminalRole;
+    readonly closed: Promise<RemoteRuntimeSessionTerminalClosedFrame>;
+    write(data: Uint8Array): Promise<void>;
+    resize(cols: number, rows: number): Promise<void>;
+    /** Idempotently detach and wait for the remote close acknowledgement. */
+    close(): Promise<void>;
+}
+export interface DirectRuntimeEmulatorSurfaceOptions {
+    maximumFrameRate?: number;
+    timeoutMs?: number;
+}
+export interface DirectRuntimeEmulatorSurface extends AsyncIterable<RuntimeEmulatorSurfaceImageFrame> {
+    readonly surfaceId: string;
+    readonly sessionId: string;
+    readonly bindingId: string;
+    readonly ready: RuntimeEmulatorSurfaceReadyFrame;
+    readonly closed: Promise<RuntimeEmulatorSurfaceClosedFrame>;
+    sendTouch(point: {
+        phase: "begin" | "move" | "end";
+        x: number;
+        y: number;
+    }): Promise<void>;
+    close(): Promise<void>;
+}
+export interface PairDirectRuntimeOptions extends DirectRuntimeClientOptions {
+    /** Optional pre-generated identity. A fresh identity is generated when omitted. */
+    identity?: DirectRuntimeClientIdentity;
+    /** Explicitly permit an expired offer for recovery enrollment. Defaults to false. */
+    allowExpiredOffer?: boolean;
+}
+export interface PairDirectRuntimeResult {
+    credential: DirectRuntimeCredential;
+    status: DaemonStatus;
+}
+export interface DirectRuntimeConnection {
+    status(): Promise<DaemonStatus>;
+    call<M extends RemoteRuntimeRpcMethod>(method: M, params: RemoteRuntimeRpcParams<M>, options?: DirectRuntimeCallOptions): Promise<RemoteRuntimeRpcResultFor<M>>;
+    /** Backward-compatible shorthand; equivalent to `call("status.get", {})`. */
+    call(method: "status.get", params?: Record<string, never>, options?: DirectRuntimeCallOptions): Promise<DaemonStatus>;
+    subscribeSessionEvents(sessionId: string, options?: DirectRuntimeSessionEventsOptions): Promise<DirectRuntimeSessionEventsSubscription>;
+    openSessionTerminal(sessionId: string, options: DirectRuntimeSessionTerminalOptions): Promise<DirectRuntimeSessionTerminal>;
+    openEmulatorSurface(sessionId: string, bindingId: string, options?: DirectRuntimeEmulatorSurfaceOptions): Promise<DirectRuntimeEmulatorSurface>;
+    close(): Promise<void>;
+}
+/** Enroll a client identity, authenticate the issued grant, and probe status. */
+export declare function pairDirectRuntime(untrustedOffer: unknown, options?: PairDirectRuntimeOptions): Promise<PairDirectRuntimeResult>;
+/** Connect once with a persisted grant. No retry or local fallback is attempted. */
+export declare function connectDirectRuntime(untrustedCredential: unknown, options?: DirectRuntimeClientOptions): Promise<DirectRuntimeConnection>;