deepline 0.1.60 → 0.1.61

package/dist/cli/index.js

@@ -220,10 +220,10 @@ function resolveConfig(options) {
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.60",
+  version: "0.1.61",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.60",
+    latest: "0.1.61",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }

package/dist/cli/index.mjs

@@ -197,10 +197,10 @@ function resolveConfig(options) {
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.60",
+  version: "0.1.61",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.60",
+    latest: "0.1.61",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }

package/dist/index.js

@@ -232,10 +232,10 @@ function resolveConfig(options) {
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.60",
+  version: "0.1.61",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.60",
+    latest: "0.1.61",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }

package/dist/index.mjs

@@ -170,10 +170,10 @@ function resolveConfig(options) {
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.60",
+  version: "0.1.61",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.60",
+    latest: "0.1.61",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }

package/dist/repo/apps/play-runner-workers/src/coordinator-entry.ts

@@ -545,7 +545,7 @@ const WORKFLOW_POOL_PROTOCOL_VERSION =
 const WORKFLOW_POOL_DO_NAME = 'workflow-pool:v2';
 const WORKFLOW_POOL_START_EVENT_TYPE = 'play_start';
 const WORKFLOW_POOL_TTL_MS = 8 * 60 * 1000;
-const WORKFLOW_POOL_TARGET_SIZE = 16;
+const WORKFLOW_POOL_TARGET_SIZE = 0;
 const WORKFLOW_POOL_READY_TIMEOUT_MS = 1_500;
 const WORKFLOW_POOL_READY_POLL_MS = 250;
 const WORKFLOW_POOL_REFILL_ON_MISS_TIMEOUT_MS = 2_500;
@@ -3637,10 +3637,10 @@ async function handleWorkflowRoute(input: {
       }
       return Response.json({ runId, status: 'cancelled' });
     }
-    if (!instance) {
-      return new Response('not found', { status: 404 });
-    }
     if (action === 'signal') {
+      if (!instance) {
+        return new Response('not found', { status: 404 });
+      }
       const body = (await request.json().catch(() => ({}))) as Record<
         string,
         unknown
@@ -3697,11 +3697,14 @@ async function handleWorkflowRoute(input: {
             waitMs: 0,
             workflowStatus: 'terminal-cache',
             statusPolls: 0,
-            instanceId: instance.id,
+            instanceId: instance?.id ?? null,
           },
           ...(includeTrace ? { coordinatorTrace } : {}),
         });
       }
+      if (!instance) {
+        return new Response('not found', { status: 404 });
+      }
       const status = await instance.status();
       const workflowError = readWorkflowError(status);
       if (workflowError) {

package/dist/repo/apps/play-runner-workers/src/entry.ts

@@ -3141,6 +3141,7 @@ function createMinimalWorkerCtx(
 ): unknown {
   let playCallCount = 0;
   const parentChildCalls: Record<string, number> = {};
+  const stepCallCounts: Record<string, number> = {};
   const inFlightChildCallsByPlayName: Record<string, number> = {};
   let inFlightChildPlayCalls = 0;
   const childPlaySlotWaiters: Array<() => void> = [];
@@ -3182,6 +3183,7 @@ function createMinimalWorkerCtx(
   const executeWithRuntimeReceipt = async <T>(
     key: string,
     execute: () => Promise<T> | T,
+    repairRunningReceiptForSameRun = false,
   ): Promise<T> => {
     const serialized = await runWorkerRuntimeReceiptBoundary<unknown>({
       baseUrl: req.baseUrl,
@@ -3192,9 +3194,36 @@ function createMinimalWorkerCtx(
       key,
       postRuntimeApi,
       execute: async () => serializeDurableStepValue(await execute()),
+      repairRunningReceiptForSameRun,
     });
     return deserializeDurableStepValue(serialized) as T;
   };
+  const executeWithWorkflowStep = async <T>(
+    name: string,
+    execute: () => Promise<T> | T,
+  ): Promise<T> => {
+    if (!workflowStep) {
+      return await executeWithRuntimeReceipt(name, execute);
+    }
+    return await executeWithRuntimeReceipt(
+      name,
+      async () => {
+        const serialized = await (
+          workflowStep.do as unknown as (
+            name: string,
+            callback: () => Promise<unknown>,
+          ) => Promise<unknown>
+        )(name, async () => serializeDurableStepValue(await execute()));
+        return deserializeDurableStepValue(serialized) as T;
+      },
+      true,
+    );
+  };
+  const nextCtxStepReceiptKey = (name: string): string => {
+    const count = stepCallCounts[name] ?? 0;
+    stepCallCounts[name] = count + 1;
+    return count === 0 ? `step:${name}` : `step:${name}:${count}`;
+  };
   const staleRuntimeSuffix = (staleAfterSeconds?: number): string => {
     if (staleAfterSeconds === undefined) return '';
     if (
@@ -3952,11 +3981,8 @@ function createMinimalWorkerCtx(
       if (!normalizedName) {
         throw new Error('ctx.step(name, callback) requires a name.');
       }
-      // Static pipeline JS blocks are already Workflow steps in the Workers
-      // backend. Nesting another `step.do` here can leave preview runs parked
-      // inside the JS stage before they reach subsequent event waits.
-      return await executeWithRuntimeReceipt(
-        `step:${normalizedName}${staleRuntimeSuffix(options?.staleAfterSeconds)}`,
+      return await executeWithWorkflowStep(
+        `${nextCtxStepReceiptKey(normalizedName)}${staleRuntimeSuffix(options?.staleAfterSeconds)}`,
         callback,
       );
     },
@@ -4607,7 +4633,7 @@ async function executeRunRequest(
       runtimeBackend: 'cf_workflows_dynamic_worker',
     },
   ];
-  let lastLedgerFlushAt = 0;
+  let lastLedgerFlushAt = startedAt;
   let ledgerFlushInFlight: Promise<void> = Promise.resolve();
 
   const appendRunLogLine = (line: string) => {
@@ -4760,7 +4786,6 @@ async function executeRunRequest(
     terminalEvent: PlayRunLedgerEvent,
   ): Promise<void> => {
     if (!options?.persistResultDatasets) return;
-    await ledgerFlushInFlight.catch(() => undefined);
     const now = nowMs();
     pendingRunLogLines = runLogBuffer;
     dirtyProgressNodeIds = new Set([
@@ -4768,6 +4793,7 @@ async function executeRunRequest(
       ...Object.keys(stepProgressByNodeId),
     ]);
     pendingLedgerEvents = [...pendingLedgerEvents, terminalEvent];
+    await ledgerFlushInFlight;
     const events = drainPendingLedgerEvents(now);
     if (events.length === 0) return;
     try {
@@ -4851,7 +4877,7 @@ async function executeRunRequest(
     });
     if (options?.persistResultDatasets) {
       const ledgerFlushWaitStartedAt = nowMs();
-      await ledgerFlushInFlight.catch(() => undefined);
+      await ledgerFlushInFlight;
       recordRunnerPerfTrace({
         req,
         phase: 'runner.run_ledger_flush_wait',
@@ -4866,29 +4892,19 @@ async function executeRunRequest(
       });
       const terminalResult = trimResultForStatus(serializedResult);
       const terminalOccurredAt = nowMs();
-      const terminalLedgerPromise = (async () => {
-        const terminalUpdateStartedAt = nowMs();
-        await flushTerminalLedgerEvents({
-          type: 'run.completed',
-          runId: req.runId,
-          source: 'worker',
-          occurredAt: terminalOccurredAt,
-          result: terminalResult,
-        });
-        recordRunnerPerfTrace({
-          req,
-          phase: 'runner.terminal_ledger_append',
-          ms: nowMs() - terminalUpdateStartedAt,
-        });
-      })().catch((error) => {
-        console.error(
-          `[play-harness] non-fatal terminal ledger append failed runId=${req.runId}: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-        );
+      const terminalUpdateStartedAt = nowMs();
+      await flushTerminalLedgerEvents({
+        type: 'run.completed',
+        runId: req.runId,
+        source: 'worker',
+        occurredAt: terminalOccurredAt,
+        result: terminalResult,
+      });
+      recordRunnerPerfTrace({
+        req,
+        phase: 'runner.terminal_ledger_append',
+        ms: nowMs() - terminalUpdateStartedAt,
       });
-
-      await terminalLedgerPromise;
 
       const billingStartedAt = nowMs();
       const billingPromise = finalizeWorkerComputeBilling({

package/dist/repo/apps/play-runner-workers/src/runtime/receipts.ts

@@ -59,6 +59,10 @@ type RuntimeReceiptContext = {
   ) => Promise<WorkerRuntimeReceiptResponse>;
 };
 
+type PostRuntimeReceiptAction = (
+  body: WorkerRuntimeReceiptAction,
+) => Promise<WorkerRuntimeReceiptResponse>;
+
 function scopedReceiptKey(input: {
   orgId?: string | null;
   playName: string;
@@ -81,27 +85,57 @@ function runningReceiptError(key: string, receipt: WorkerRuntimeReceipt): Error
   );
 }
 
+async function executeAndPersistReceipt<T>(input: {
+  key: string;
+  playName: string;
+  runId: string;
+  execute: () => Promise<T> | T;
+  postRuntimeReceiptAction: PostRuntimeReceiptAction;
+  ownership: 'claimed' | 'workflow_replay';
+}): Promise<T> {
+  let output: T;
+  try {
+    output = await input.execute();
+  } catch (error) {
+    const failed = await input.postRuntimeReceiptAction({
+      action: 'fail_runtime_step_receipt',
+      playName: input.playName,
+      runId: input.runId,
+      key: input.key,
+      error: errorMessage(error),
+    });
+    if (!failed.receipt) {
+      throw new Error(
+        `Runtime receipt ${input.key} ${input.ownership} execution failed and failed receipt could not be persisted: ${errorMessage(error)}`,
+      );
+    }
+    throw error;
+  }
+
+  const completed = await input.postRuntimeReceiptAction({
+    action: 'complete_runtime_step_receipt',
+    playName: input.playName,
+    runId: input.runId,
+    key: input.key,
+    output,
+  });
+  if (!completed.receipt) {
+    throw new Error(
+      `Runtime receipt ${input.key} ${input.ownership} execution completed but completed receipt could not be persisted.`,
+    );
+  }
+  return output;
+}
+
 export async function runWorkerRuntimeReceiptBoundary<T>(
   input: RuntimeReceiptContext & {
     execute: () => Promise<T> | T;
+    repairRunningReceiptForSameRun?: boolean;
   },
 ): Promise<T> {
   const key = scopedReceiptKey(input);
   const postRuntimeReceiptAction = (body: WorkerRuntimeReceiptAction) =>
     input.postRuntimeApi(input.baseUrl, input.executorToken, body);
-  const existing = await postRuntimeReceiptAction({
-    action: 'get_runtime_step_receipt',
-    playName: input.playName,
-    runId: input.runId,
-    key,
-  });
-  if (
-    existing.receipt?.status === 'completed' ||
-    existing.receipt?.status === 'skipped'
-  ) {
-    return receiptOutput<T>(existing.receipt);
-  }
-
   const claimed = await postRuntimeReceiptAction({
     action: 'claim_runtime_step_receipt',
     playName: input.playName,
@@ -122,6 +156,19 @@ export async function runWorkerRuntimeReceiptBoundary<T>(
       return receiptOutput<T>(latest.receipt);
     }
     if (latest.receipt?.status === 'running') {
+      if (
+        input.repairRunningReceiptForSameRun &&
+        latest.receipt.runId === input.runId
+      ) {
+        return executeAndPersistReceipt({
+          key,
+          playName: input.playName,
+          runId: input.runId,
+          execute: input.execute,
+          postRuntimeReceiptAction,
+          ownership: 'workflow_replay',
+        });
+      }
       throw runningReceiptError(key, latest.receipt);
     }
     if (latest.receipt?.status === 'failed') {
@@ -134,35 +181,12 @@ export async function runWorkerRuntimeReceiptBoundary<T>(
     );
   }
 
-  let output: T;
-  try {
-    output = await input.execute();
-  } catch (error) {
-    const failed = await postRuntimeReceiptAction({
-      action: 'fail_runtime_step_receipt',
-      playName: input.playName,
-      runId: input.runId,
-      key,
-      error: errorMessage(error),
-    });
-    if (!failed.receipt) {
-      throw new Error(
-        `Runtime receipt ${key} execution failed and failed receipt could not be persisted: ${errorMessage(error)}`,
-      );
-    }
-    throw error;
-  }
-  const completed = await postRuntimeReceiptAction({
-    action: 'complete_runtime_step_receipt',
+  return executeAndPersistReceipt({
+    key,
     playName: input.playName,
     runId: input.runId,
-    key,
-    output,
+    execute: input.execute,
+    postRuntimeReceiptAction,
+    ownership: 'claimed',
   });
-  if (!completed.receipt) {
-    throw new Error(
-      `Runtime receipt ${key} execution completed but completed receipt could not be persisted.`,
-    );
-  }
-  return output;
 }

package/dist/repo/sdk/src/release.ts

@@ -50,10 +50,10 @@ export type SdkRelease = {
 };
 
 export const SDK_RELEASE = {
-  version: '0.1.60',
+  version: '0.1.61',
   apiContract: '2026-05-play-bootstrap-dataset-summary',
   supportPolicy: {
-    latest: '0.1.60',
+    latest: '0.1.61',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.60",
+  "version": "0.1.61",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {