@ricsam/r5d-worker 0.0.172 → 0.0.174

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

@@ -273,6 +273,40 @@ export declare const ManagerCommand: z.ZodDiscriminatedUnion<[z.ZodObject<{
             }, z.core.$strict>;
         }, z.core.$strict>;
         actionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"subscribe">;
+        run: z.ZodObject<{
+            operationId: z.ZodString;
+            userId: z.ZodString;
+            sessionId: z.ZodOptional<z.ZodString>;
+            fence: z.ZodObject<{
+                installationId: z.ZodString;
+                resourceType: z.ZodString;
+                resourceId: z.ZodString;
+                ownerId: z.ZodString;
+                epoch: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        offset: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"input">;
+        run: z.ZodObject<{
+            operationId: z.ZodString;
+            userId: z.ZodString;
+            sessionId: z.ZodOptional<z.ZodString>;
+            fence: z.ZodObject<{
+                installationId: z.ZodString;
+                resourceType: z.ZodString;
+                resourceId: z.ZodString;
+                ownerId: z.ZodString;
+                epoch: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        data: z.ZodOptional<z.ZodString>;
+        resize: z.ZodOptional<z.ZodObject<{
+            cols: z.ZodNumber;
+            rows: z.ZodNumber;
+        }, z.core.$strict>>;
     }, z.core.$strict>], "method">;
 }, z.core.$strict>, z.ZodObject<{
     method: z.ZodLiteral<"observe">;
@@ -439,6 +473,40 @@ export declare const ManagerCommand: z.ZodDiscriminatedUnion<[z.ZodObject<{
             }, z.core.$strict>;
         }, z.core.$strict>;
         actionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"subscribe">;
+        run: z.ZodObject<{
+            operationId: z.ZodString;
+            userId: z.ZodString;
+            sessionId: z.ZodOptional<z.ZodString>;
+            fence: z.ZodObject<{
+                installationId: z.ZodString;
+                resourceType: z.ZodString;
+                resourceId: z.ZodString;
+                ownerId: z.ZodString;
+                epoch: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        offset: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"input">;
+        run: z.ZodObject<{
+            operationId: z.ZodString;
+            userId: z.ZodString;
+            sessionId: z.ZodOptional<z.ZodString>;
+            fence: z.ZodObject<{
+                installationId: z.ZodString;
+                resourceType: z.ZodString;
+                resourceId: z.ZodString;
+                ownerId: z.ZodString;
+                epoch: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        data: z.ZodOptional<z.ZodString>;
+        resize: z.ZodOptional<z.ZodObject<{
+            cols: z.ZodNumber;
+            rows: z.ZodNumber;
+        }, z.core.$strict>>;
     }, z.core.$strict>], "method">;
 }, z.core.$strict>, z.ZodObject<{
     method: z.ZodLiteral<"receipt">;
@@ -782,6 +850,40 @@ export declare const ManagerRequest: z.ZodObject<{
                 }, z.core.$strict>;
             }, z.core.$strict>;
             actionId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            method: z.ZodLiteral<"subscribe">;
+            run: z.ZodObject<{
+                operationId: z.ZodString;
+                userId: z.ZodString;
+                sessionId: z.ZodOptional<z.ZodString>;
+                fence: z.ZodObject<{
+                    installationId: z.ZodString;
+                    resourceType: z.ZodString;
+                    resourceId: z.ZodString;
+                    ownerId: z.ZodString;
+                    epoch: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            offset: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            method: z.ZodLiteral<"input">;
+            run: z.ZodObject<{
+                operationId: z.ZodString;
+                userId: z.ZodString;
+                sessionId: z.ZodOptional<z.ZodString>;
+                fence: z.ZodObject<{
+                    installationId: z.ZodString;
+                    resourceType: z.ZodString;
+                    resourceId: z.ZodString;
+                    ownerId: z.ZodString;
+                    epoch: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            data: z.ZodOptional<z.ZodString>;
+            resize: z.ZodOptional<z.ZodObject<{
+                cols: z.ZodNumber;
+                rows: z.ZodNumber;
+            }, z.core.$strict>>;
         }, z.core.$strict>], "method">;
     }, z.core.$strict>, z.ZodObject<{
         method: z.ZodLiteral<"observe">;
@@ -948,6 +1050,40 @@ export declare const ManagerRequest: z.ZodObject<{
                 }, z.core.$strict>;
             }, z.core.$strict>;
             actionId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            method: z.ZodLiteral<"subscribe">;
+            run: z.ZodObject<{
+                operationId: z.ZodString;
+                userId: z.ZodString;
+                sessionId: z.ZodOptional<z.ZodString>;
+                fence: z.ZodObject<{
+                    installationId: z.ZodString;
+                    resourceType: z.ZodString;
+                    resourceId: z.ZodString;
+                    ownerId: z.ZodString;
+                    epoch: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            offset: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            method: z.ZodLiteral<"input">;
+            run: z.ZodObject<{
+                operationId: z.ZodString;
+                userId: z.ZodString;
+                sessionId: z.ZodOptional<z.ZodString>;
+                fence: z.ZodObject<{
+                    installationId: z.ZodString;
+                    resourceType: z.ZodString;
+                    resourceId: z.ZodString;
+                    ownerId: z.ZodString;
+                    epoch: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            data: z.ZodOptional<z.ZodString>;
+            resize: z.ZodOptional<z.ZodObject<{
+                cols: z.ZodNumber;
+                rows: z.ZodNumber;
+            }, z.core.$strict>>;
         }, z.core.$strict>], "method">;
     }, z.core.$strict>, z.ZodObject<{
         method: z.ZodLiteral<"receipt">;

package/dist/types/runtime/workspace/authority.d.ts

@@ -1,5 +1,6 @@
 import { OperationEnvelope } from "@ricsam/r5d-api/runtime-protocol";
-import { type PollResult, type RunIdentity } from "../protocol";
+import { ExecutorError, type PollResult, type RunIdentity, type RunReceipt, type StreamFrame } from "../protocol";
+import type { ExecutorSubscription } from "../client";
 import { WorkspaceConfig, type ExecutorRoute, type WorkspaceIdentity, type OuterState, type ApprovedWorkbench as ApprovedWorkbenchInput } from "./contracts";
 import { SessionArtifactChunk } from "./artifacts";
 import { WorkspaceFileWrite } from "./file-write";
@@ -32,6 +33,7 @@ export declare class WorkspaceAuthority {
     private closed;
     private closeTask?;
     private readonly actions;
+    private readonly subscriptions;
     private readonly repositoryInitializations;
     private outerRepository?;
     private pending;
@@ -55,7 +57,7 @@ export declare class WorkspaceAuthority {
         content: string;
         bytes: number;
     }>;
-    processes(identity: WorkspaceIdentity): Promise<{
+    processes(identity: WorkspaceIdentity): Promise<({
         workerLabel: string;
         operationId: string;
         userId: string;
@@ -78,7 +80,30 @@ export declare class WorkspaceAuthority {
         startedAt?: string;
         updatedAt?: string;
         completedAt?: string;
-    }[]>;
+    } | {
+        operationId: string;
+        userId: string;
+        sessionId: string;
+        state: string;
+        pid: null;
+        pty: boolean;
+        lane: string;
+        stdoutBytes: number;
+        stderrBytes: number;
+        stdinClosed: boolean;
+        exitCode: null;
+        signal: null;
+        reason: string;
+        workerLabel: string;
+        artifactEnvironment?: boolean;
+        mutating: boolean;
+        payloadHash: string;
+        argv?: string[];
+        cwd?: string;
+        startedAt?: string;
+        updatedAt?: string;
+        completedAt?: string;
+    })[]>;
     fileHistoryDates(identity: WorkspaceIdentity, file: string): Promise<{
         createdAt: string | null;
         updatedAt: string;
@@ -192,6 +217,11 @@ export declare class WorkspaceAuthority {
         original?: undefined;
         modified?: undefined;
     }>;
+    /** Bench state is one in-memory object with several writers on different
+     * queues (checkout work, run receipts). Writes of its file are chained so
+     * they never overlap and the write that lands last always serializes the
+     * newest state; the chain covers only the write itself, never the work
+     * around it, so a run receipt does not wait for a publication. */
     private save;
     private owned;
     private serial;
@@ -433,7 +463,7 @@ export declare class WorkspaceAuthority {
     startWithCredentials(identity: WorkspaceIdentity, input: OperationEnvelope, resolve: () => Promise<Array<{
         id: string;
         generation: number;
-    }>>): Promise<import("..").RunReceipt>;
+    }>>): Promise<RunReceipt>;
     materializeArtifact(identity: WorkspaceIdentity, input: SessionArtifactChunk): Promise<{
         filename: string;
         sha256: string;
@@ -442,10 +472,28 @@ export declare class WorkspaceAuthority {
         complete: boolean;
     }>;
     /** Default arbitrary shell is mutating. Exact trusted config approval is the sole exemption. */
-    start(identity: WorkspaceIdentity, input: OperationEnvelope, allowBlockedConflict?: boolean): Promise<import("..").RunReceipt>;
+    start(identity: WorkspaceIdentity, input: OperationEnvelope, allowBlockedConflict?: boolean): Promise<RunReceipt>;
     private runRoute;
     private action;
     poll(identity: WorkspaceIdentity, run: RunIdentity, stdoutOffset?: number, stderrOffset?: number, maxBytes?: number): Promise<PollResult>;
+    /** Run liveness is process state observed from the executor, not a workspace
+     * mutation: it is recorded on its own short queue, never behind the checkout's
+     * hydration, commit or publication work. A crash between two writers loses
+     * nothing lasting — `refresh` re-reads every open run from the executor. */
+    private recordRunState;
+    /** Live terminal channel. The subscription is not an admitted action: it
+     * lives as long as its transport, outlives the request budget, and is torn
+     * down on close. Its exit frame is the only durable-state effect. */
+    subscribe(identity: WorkspaceIdentity, run: RunIdentity, offset: number, handlers: {
+        frame(frame: StreamFrame): void;
+        close(error?: ExecutorError): void;
+    }): Promise<ExecutorSubscription>;
+    /** Live PTY input: fenced and owned like a write, but with no action receipt
+     * and no queue in front of it. */
+    streamInput(identity: WorkspaceIdentity, run: RunIdentity, data?: string, resize?: {
+        cols: number;
+        rows: number;
+    }): Promise<import("../protocol").InputResult>;
     private actionOutcome;
     write(identity: WorkspaceIdentity, run: RunIdentity, actionId: string, data: string, eof?: boolean): Promise<import("..").ActionReceipt>;
     resize(identity: WorkspaceIdentity, run: RunIdentity, actionId: string, cols: number, rows: number): Promise<import("..").ActionReceipt>;

package/dist/types/runtime/workspace/contracts.d.ts

@@ -44,7 +44,7 @@ export declare const WorkspaceConfig: z.ZodObject<{
 }, z.core.$strict>;
 export type WorkspaceConfig = z.input<typeof WorkspaceConfig>;
 export type ExecutorRoute = {
-    client: Pick<HostExecutorClient, "start" | "poll" | "write" | "cancel"> & Partial<Pick<HostExecutorClient, "resize">>;
+    client: Pick<HostExecutorClient, "start" | "poll" | "write" | "cancel"> & Partial<Pick<HostExecutorClient, "resize" | "subscribe" | "input">>;
     workerFence: OwnershipFence;
 };
 export type WorkspaceIdentity = {

package/dist/types/runtime/workspace/files.d.ts

@@ -15,6 +15,10 @@ export declare function readHostRegular(file: string, limit?: number): Promise<B
  * Restore only that directory skeleton after confirming the authority-owned
  * repository markers; refs, objects, indexes and configuration are untouched. */
 export declare function ensureAuthorityGitRepositoryLayout(repo: string): Promise<void>;
+/** Writes `value` atomically: a private temporary file, fsync, rename, directory
+ * fsync. Concurrent writers of the same file each get their own temporary name,
+ * so neither fails on the other's; the rename that lands last wins, which is why
+ * callers that share in-memory state also serialize their writes. */
 export declare function durableJson(file: string, value: unknown): Promise<void>;
 /** All Git operates in authority-created repos; NEVER workbench .git/config/index.
  * hash-object --no-filters and update-index --index-info replace git add/checkout.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.172",
+  "version": "0.0.174",
   "type": "module",
   "main": "./dist/mjs/main.mjs",
   "module": "./dist/mjs/main.mjs",
@@ -21,7 +21,7 @@
     "r5d-worker": "dist/mjs/main.mjs"
   },
   "dependencies": {
-    "@ricsam/r5d-api": "^0.0.172",
+    "@ricsam/r5d-api": "^0.0.174",
     "node-pty": "1.1.0",
     "zod": "^4.1.13",
     "picomatch": "^4.0.3"