@ricsam/r5d-worker 0.0.137 → 0.0.139

package/dist/types/runtime/releases/process.d.ts

@@ -0,0 +1,14 @@
+import { type ChildProcessWithoutNullStreams } from "node:child_process";
+import { type ExecutorCommand } from "../protocol";
+/** Owns only a translation process. Never starts, signals, supervises or adopts the executor. */
+export declare class AdapterChild {
+    private readonly timeoutMs;
+    readonly process: ChildProcessWithoutNullStreams;
+    private readonly pending;
+    private gone;
+    constructor(runtimePath: string, entrypoint: string, configPath: string, home: string, timeoutMs?: number);
+    private fail;
+    get alive(): boolean;
+    request<T = unknown>(command: ExecutorCommand): Promise<T>;
+    close(): Promise<void>;
+}

package/dist/types/runtime/releases/retirement.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+/** Written only after closing a known owned child. Not inferred from process absence. */
+export declare const AdapterRetirementCompletion: z.ZodObject<{
+    format: z.ZodLiteral<1>;
+    installationId: z.ZodString;
+    workerId: z.ZodString;
+    adapterId: z.ZodString;
+    manifestDigest: z.ZodString;
+    grantDigest: z.ZodString;
+    retirementIntentDigest: z.ZodString;
+    managerInvocation: z.ZodString;
+    childPid: z.ZodNumber;
+    completionId: z.ZodString;
+}, z.core.$strict>;
+export type AdapterRetirementCompletion = z.infer<typeof AdapterRetirementCompletion>;

package/dist/types/runtime/releases/rpc-client.d.ts

@@ -0,0 +1,52 @@
+import type { OperationEnvelope } from "@ricsam/r5d-api/runtime-protocol";
+import { ExecutorCommand, type RunIdentity, type RunReceipt, type PollResult, type ActionReceipt } from "../protocol";
+import { DeliveryReceipt, ManagerRpcClientConfig, type ManagerCommand } from "./rpc-protocol";
+export type DeliveryReceiptSink = (receipt: DeliveryReceipt) => Promise<void>;
+export declare class ManagerRpcClient {
+    readonly config: ReturnType<typeof ManagerRpcClientConfig.parse>;
+    constructor(config: ManagerRpcClientConfig);
+    request<T = unknown>(command: ManagerCommand): Promise<T>;
+    probe(): Promise<unknown>;
+    execute(callId: string, command: ExecutorCommand): Promise<DeliveryReceipt>;
+    observe(command: ExecutorCommand): Promise<DeliveryReceipt>;
+    receipt(callId: string): Promise<DeliveryReceipt>;
+    acknowledge(callId: string, responseDigest: string, ackToken: string): Promise<{
+        callId: string;
+        responseDigest: string;
+        acknowledged: true;
+    }>;
+}
+/** Workspace facade: every resource method traverses manager -> actual child -> executor. No executor token/socket available. */
+export declare class ManagedExecutorClient {
+    private readonly receiptSink?;
+    private readonly onAcknowledged?;
+    readonly rpc: ManagerRpcClient;
+    constructor(config: ManagerRpcClientConfig, receiptSink?: DeliveryReceiptSink | undefined, onAcknowledged?: DeliveryReceiptSink | undefined);
+    get config(): {
+        socketPath: string;
+        installationId: string;
+        workerId: string;
+        principalId: string;
+        token: string;
+        adapterId: string;
+        hello: {
+            installationId: string;
+            instanceId: string;
+            releaseId: string;
+            role: "web" | "scheduler" | "runner" | "gateway" | "worker-adapter" | "browser-adapter" | "executor" | "keeper" | "storage";
+            protocol: {
+                min: number;
+                max: number;
+            };
+            capabilities: string[];
+        };
+        timeoutMs: number;
+    };
+    status(): Promise<unknown>;
+    request<T = unknown>(command: ExecutorCommand): Promise<T>;
+    start(operation: OperationEnvelope): Promise<RunReceipt>;
+    poll(run: RunIdentity, stdoutOffset?: number, stderrOffset?: number, maxBytes?: number): Promise<PollResult>;
+    write(run: RunIdentity, actionId: string, data: string, eof?: boolean): Promise<ActionReceipt>;
+    resize(run: RunIdentity, actionId: string, cols: number, rows: number): Promise<ActionReceipt>;
+    cancel(run: RunIdentity, actionId: string): Promise<ActionReceipt>;
+}

package/dist/types/runtime/releases/rpc-main.d.ts

@@ -0,0 +1,10 @@
+import { WorkerAdapterReleases } from "./manager";
+import { ManagerRpcConfig } from "./rpc-protocol";
+export declare function readManagerPrivateJson(path: string): unknown;
+/** Independently supervised Unix service; callers never receive grants, adapter tokens or admin authority. */
+export declare function startManagerRpc(input: ManagerRpcConfig): Promise<{
+    manager: WorkerAdapterReleases;
+    socketPath: string;
+    readonly pending: number;
+    close(): Promise<void>;
+}>;