@osolmaz/pi-workflows 0.16.2 → 0.16.3

package/dist/workflows/store.d.ts

@@ -37,7 +37,7 @@ export type WorkflowRunTerminalData = {
 };
 export type WorkflowRunStoreOptions = {
     authorityProvider?: (runId: string) => RunWriteAuthority | undefined;
-    /** Host-owned projection updates that must commit with each run snapshot. */
+    /** Server-owned projection updates that must commit with each run snapshot. */
     snapshotLifecycle?: (context: {
         runId: string;
         state: WorkflowRunState;
@@ -45,17 +45,17 @@ export type WorkflowRunStoreOptions = {
         database: StateDatabase;
         now: number;
     }) => void;
-    /** The global host may record an attested Pi session after the worker lease ends. */
-    allowHostSessionRecording?: boolean;
+    /** The global server may record an attested Pi session after the runner lease ends. */
+    allowServerSessionRecording?: boolean;
     state?: StateDatabase;
     readOnly?: boolean;
 };
-/** The state boundary used by workflow code, including out-of-process workers. */
+/** The state boundary used by workflow code, including out-of-process runners. */
 export interface WorkflowExecutionStore {
     readonly databasePath: string;
     initializeRun(workflow: WorkflowDefinition, state: WorkflowRunState, options?: InitializeWorkflowRunOptions): Promise<string>;
-    prepareRunResume(runId: string): Promise<LoadedWorkflowRun>;
-    readRun(runId: string, options?: ReadWorkflowRunOptions): LoadedWorkflowRun | null | Promise<LoadedWorkflowRun | null>;
+    prepareRunResume(runId: string): Promise<WorkflowRunState>;
+    readRunState(runId: string): WorkflowRunState | null | Promise<WorkflowRunState | null>;
     writeSnapshot(runId: string, state: WorkflowRunState, event: WorkflowTraceEventDraft): Promise<WorkflowTraceEvent>;
     publishUpdate(runId: string, state: WorkflowRunState, nodeId: string, attemptId: string, update: WorkflowUpdateInput, options?: {
         signal?: AbortSignal;
@@ -165,14 +165,14 @@ export declare class WorkflowRunStore {
     readonly state: StateDatabase;
     private readonly authorityProvider;
     private readonly snapshotLifecycle;
-    private readonly allowHostSessionRecording;
+    private readonly allowServerSessionRecording;
     private readonly contexts;
     private readonly ownsState;
     private readonly mutations;
     private readonly workflowMessages;
     constructor(databasePath?: string, options?: WorkflowRunStoreOptions);
     close(): void;
-    /** Host-only synchronization after a queue lifecycle mutation on the run resource. */
+    /** Server-only synchronization after a queue lifecycle mutation on the run resource. */
     synchronizeRevision(runId: string): number;
     createHumanDecisionRequest(request: HumanDecisionRequest): Promise<"created" | "adopted">;
     readResolvedHumanDecision(decisionId: string): Promise<ResolvedHumanDecision | null>;
@@ -218,7 +218,7 @@ export declare class WorkflowRunStore {
     originSessionId(runId: string): string | undefined;
     readFollowUpQueue(runId: string): WorkflowFollowUpQueueRecord | undefined;
     private readFollowUpQueueRange;
-    prepareRunResume(runId: string): Promise<LoadedWorkflowRun>;
+    prepareRunResume(runId: string): Promise<WorkflowRunState>;
     markRunInterrupted(runId: string, reason?: string): Promise<LoadedWorkflowRun | null>;
     publishUpdate(runId: string, state: WorkflowRunState, nodeId: string, attemptId: string, update: WorkflowUpdateInput, options?: {
         signal?: AbortSignal;
@@ -226,7 +226,7 @@ export declare class WorkflowRunStore {
         event: WorkflowTraceEvent;
         record: WorkflowUpdateRecord;
     }>;
-    /** Host-only synchronous form for an already serialized command transaction. */
+    /** Server-only synchronous form for an already serialized command transaction. */
     publishUpdateSynchronous(runId: string, state: WorkflowRunState, nodeId: string, attemptId: string, update: WorkflowUpdateInput, options?: {
         signal?: AbortSignal;
     }): {
@@ -253,6 +253,7 @@ export declare class WorkflowRunStore {
     readRunError(runId: string): string | null;
     readPresentationInstructions(runId: string): string;
     readTerminalData(runId: string): WorkflowRunTerminalData | null;
+    readRunState(runId: string): WorkflowRunState | null;
     readRun(runId: string, options?: ReadWorkflowRunOptions): LoadedWorkflowRun | null;
     readRunViewCounts(runId: string): WorkflowRunViewCounts | null;
     readRunView(runId: string, options: WorkflowRunViewReadOptions): WorkflowRunViewRead | null;
@@ -307,7 +308,7 @@ export declare class WorkflowRunStore {
     private syncContinuationIdentity;
     private readRunRow;
     private requireRunRow;
-    private readRunState;
+    private materializeRunState;
     private buildRunState;
     private readSteps;
     private readStepRange;

package/dist/workflows/store.js

@@ -68,7 +68,7 @@ export class WorkflowRunStore {
     state;
     authorityProvider;
     snapshotLifecycle;
-    allowHostSessionRecording;
+    allowServerSessionRecording;
     contexts = new Map();
     ownsState;
     mutations;
@@ -76,7 +76,7 @@ export class WorkflowRunStore {
     constructor(databasePath = workflowStatePath(), options = {}) {
         this.authorityProvider = options.authorityProvider;
         this.snapshotLifecycle = options.snapshotLifecycle;
-        this.allowHostSessionRecording = options.allowHostSessionRecording === true;
+        this.allowServerSessionRecording = options.allowServerSessionRecording === true;
         this.ownsState = options.state === undefined;
         this.state =
             options.state ??
@@ -93,7 +93,7 @@ export class WorkflowRunStore {
         if (this.ownsState)
             this.state.close();
     }
-    /** Host-only synchronization after a queue lifecycle mutation on the run resource. */
+    /** Server-only synchronization after a queue lifecycle mutation on the run resource. */
     synchronizeRevision(runId) {
         const revision = this.resourceRevision(runId);
         const context = this.contexts.get(runId);
@@ -712,11 +712,11 @@ export class WorkflowRunStore {
         return { runId, originSessionId, followUps };
     }
     async prepareRunResume(runId) {
-        const loaded = this.readRun(runId, { includeTrace: true });
-        if (loaded === null)
+        const state = this.readRunState(runId);
+        if (state === null)
             throw new Error(`Cannot resume unreadable workflow run: ${runId}`);
-        if (loaded.state.status !== "running") {
-            throw new Error(`Cannot resume workflow run ${runId} with status ${loaded.state.status}`);
+        if (state.status !== "running") {
+            throw new Error(`Cannot resume workflow run ${runId} with status ${state.status}`);
         }
         this.verifySettingsProjections(runId);
         const revision = this.resourceRevision(runId);
@@ -742,18 +742,18 @@ export class WorkflowRunStore {
                 payload: {},
             };
             insertRunEvent(this.state, row.resourceId, nextRevision, at, traceEvent);
-            loaded.state.traceSeq = nextRevision;
-            loaded.state.updatedAt = at;
-            this.persistRunState(row, loaded.state, nextRevision, now);
-            recordViewerDeltas(this.state, runId, runViewerTargets(loaded.state, traceEvent), now);
+            state.traceSeq = nextRevision;
+            state.updatedAt = at;
+            this.persistRunState(row, state, nextRevision, now);
+            recordViewerDeltas(this.state, runId, runViewerTargets(state, traceEvent), now);
             context.revision = nextRevision;
         });
-        const prepared = this.readRun(runId, { includeTrace: true });
+        const prepared = this.readRunState(runId);
         if (prepared === null)
             throw new Error(`Workflow run became unreadable: ${runId}`);
         return prepared;
     }
-    async markRunInterrupted(runId, reason = "Workflow host stopped before the run finished") {
+    async markRunInterrupted(runId, reason = "Workflow server stopped before the run finished") {
         const loaded = this.readRun(runId);
         if (loaded === null || loaded.state.status !== "running")
             return loaded;
@@ -780,7 +780,7 @@ export class WorkflowRunStore {
     async publishUpdate(runId, state, nodeId, attemptId, update, options = {}) {
         return await this.withRunLock(runId, async () => this.publishUpdateSynchronous(runId, state, nodeId, attemptId, update, options));
     }
-    /** Host-only synchronous form for an already serialized command transaction. */
+    /** Server-only synchronous form for an already serialized command transaction. */
     publishUpdateSynchronous(runId, state, nodeId, attemptId, update, options = {}) {
         if (options.signal?.aborted === true) {
             throw options.signal.reason ?? new Error("workflow update attempt is no longer active");
@@ -941,7 +941,7 @@ export class WorkflowRunStore {
                     },
                 };
                 insertRunEvent(this.state, run.resourceId, revision, at, traceEvent);
-                const current = this.readRunState(run, this.readDefinition(run.definitionHash));
+                const current = this.materializeRunState(run, this.readDefinition(run.definitionHash));
                 current.traceSeq = revision;
                 current.updatedAt = at;
                 this.persistRunState(run, current, revision, now);
@@ -1304,12 +1304,18 @@ export class WorkflowRunStore {
             restartNumber: row.restartNumber,
         };
     }
+    readRunState(runId) {
+        const row = this.readRunRow(runId);
+        if (row === undefined)
+            return null;
+        return this.materializeRunState(row, this.readDefinition(row.definitionHash));
+    }
     readRun(runId, options = {}) {
         const row = this.readRunRow(runId);
         if (row === undefined)
             return null;
         const snapshot = this.readDefinition(row.definitionHash);
-        const state = this.readRunState(row, snapshot);
+        const state = this.materializeRunState(row, snapshot);
         const segments = this.segmentRows(runId).map((segment) => this.loadSegment(segment, state));
         const flat = segments.find((segment) => segment.attemptId === "") ?? emptySegment();
         return {
@@ -1548,7 +1554,7 @@ export class WorkflowRunStore {
     }
     assertSessionWriteAuthority(runId) {
         const run = this.requireRunRow(runId);
-        if (this.allowHostSessionRecording)
+        if (this.allowServerSessionRecording)
             return;
         this.assertWriteAuthority(run, this.contextFor(runId).revision);
     }
@@ -2264,7 +2270,7 @@ export class WorkflowRunStore {
             throw new Error(`Workflow run is missing: ${runId}`);
         return row;
     }
-    readRunState(row, snapshot) {
+    materializeRunState(row, snapshot) {
         const steps = this.readSteps(row.runId);
         return this.buildRunState(row, snapshot, steps, steps, this.readUpdates(row.runId).updates ?? []);
     }