deepline 0.1.60 → 0.1.62

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.62",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.60",
+    latest: "0.1.62",
     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.62",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.60",
+    latest: "0.1.62",
     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.62",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.60",
+    latest: "0.1.62",
     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.62",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.60",
+    latest: "0.1.62",
     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

@@ -117,6 +117,7 @@ import {
   harnessStartSheetDataset,
   setHarnessBinding,
 } from '../../../sdk/src/plays/harness-stub';
+import { createHarnessWorkerReceiptStore } from './runtime/harness-receipt-store';
 import {
   applyCsvRenameProjection,
   stripCsvProjectedFields,
@@ -397,7 +398,7 @@ async function fetchRuntimeApi(
       ? RUNTIME_API_PLAY_RUN_TIMEOUT_MS
       : /^\/api\/v2\/integrations\/[^/]+\/execute$/.test(path)
         ? RUNTIME_API_INTEGRATION_EXECUTE_TIMEOUT_MS
-      : RUNTIME_API_TIMEOUT_MS;
+        : RUNTIME_API_TIMEOUT_MS;
   const controller = new AbortController();
   let timeout: ReturnType<typeof setTimeout> | null = null;
   const timeoutPromise = new Promise<never>((_, reject) => {
@@ -619,10 +620,7 @@ function publicCsvOutputRow<T extends Record<string, unknown>>(row: T): T {
   const stripped = stripCsvProjectionMetadata(row) as Record<string, unknown>;
   const publicRow: Record<string, unknown> = {};
   for (const fieldName of Reflect.ownKeys(stripped)) {
-    if (
-      typeof fieldName === 'string' &&
-      fieldName.startsWith('__deepline')
-    ) {
+    if (typeof fieldName === 'string' && fieldName.startsWith('__deepline')) {
       continue;
     }
     const descriptor = Object.getOwnPropertyDescriptor(stripped, fieldName);
@@ -3141,6 +3139,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> = [];
@@ -3179,9 +3178,13 @@ function createMinimalWorkerCtx(
   };
   const rootGovernance = req.playCallGovernance;
   const rootRunId = rootGovernance?.rootRunId ?? req.runId;
+  const receiptStore = env.HARNESS
+    ? createHarnessWorkerReceiptStore({ executorToken: req.executorToken })
+    : undefined;
   const executeWithRuntimeReceipt = async <T>(
     key: string,
     execute: () => Promise<T> | T,
+    repairRunningReceiptForSameRun = false,
   ): Promise<T> => {
     const serialized = await runWorkerRuntimeReceiptBoundary<unknown>({
       baseUrl: req.baseUrl,
@@ -3191,10 +3194,38 @@ function createMinimalWorkerCtx(
       runId: req.runId,
       key,
       postRuntimeApi,
+      receiptStore,
       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 +3983,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,
       );
     },
@@ -4275,15 +4303,15 @@ function createMinimalWorkerCtx(
               req,
               allowInline:
                 options?.timeoutMs == null && !childNeedsWorkflowScheduler,
-	              body: {
-	                name: resolvedName,
-	                input: isRecord(input) ? input : {},
-	                orgId: req.orgId,
-	                callbackBaseUrl: req.callbackUrl,
-	                baseUrl: req.baseUrl,
-	                parentExecutorToken: req.executorToken,
-	                userEmail: req.userEmail ?? '',
-	                profile: 'workers_edge',
+              body: {
+                name: resolvedName,
+                input: isRecord(input) ? input : {},
+                orgId: req.orgId,
+                callbackBaseUrl: req.callbackUrl,
+                baseUrl: req.baseUrl,
+                parentExecutorToken: req.executorToken,
+                userEmail: req.userEmail ?? '',
+                profile: 'workers_edge',
                 manifest: childManifest,
                 childPlayManifests: req.childPlayManifests ?? null,
                 internalRunPlay: {
@@ -4607,7 +4635,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 +4788,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 +4795,7 @@ async function executeRunRequest(
       ...Object.keys(stepProgressByNodeId),
     ]);
     pendingLedgerEvents = [...pendingLedgerEvents, terminalEvent];
+    await ledgerFlushInFlight;
     const events = drainPendingLedgerEvents(now);
     if (events.length === 0) return;
     try {
@@ -4851,7 +4879,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 +4894,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/harness-receipt-store.ts

@@ -0,0 +1,31 @@
+import {
+  harnessClaimRuntimeReceipt,
+  harnessCompleteRuntimeReceipt,
+  harnessFailRuntimeReceipt,
+} from '../../../../sdk/src/plays/harness-stub';
+import type { WorkerRuntimeReceiptStore } from './receipts';
+
+export function createHarnessWorkerReceiptStore(input: {
+  executorToken: string;
+}): WorkerRuntimeReceiptStore {
+  return {
+    claimReceipt(command) {
+      return harnessClaimRuntimeReceipt({
+        executorToken: input.executorToken,
+        ...command,
+      });
+    },
+    completeReceipt(command) {
+      return harnessCompleteRuntimeReceipt({
+        executorToken: input.executorToken,
+        ...command,
+      });
+    },
+    failReceipt(command) {
+      return harnessFailRuntimeReceipt({
+        executorToken: input.executorToken,
+        ...command,
+      });
+    },
+  };
+}

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

@@ -1,17 +1,14 @@
-export type RuntimeReceiptStatus =
-  | 'pending'
-  | 'running'
-  | 'completed'
-  | 'failed'
-  | 'skipped';
-
-export type WorkerRuntimeReceipt = {
-  key: string;
-  status: RuntimeReceiptStatus;
-  output?: unknown;
-  error?: string;
-  runId?: string | null;
-};
+import type {
+  WorkReceipt,
+  WorkReceiptClaim,
+  WorkReceiptCommand,
+  WorkReceiptStatus,
+  WorkReceiptStore,
+} from '../../../../shared_libs/play-runtime/work-receipts';
+
+export type RuntimeReceiptStatus = WorkReceiptStatus;
+
+export type WorkerRuntimeReceipt = WorkReceipt;
 
 export type WorkerRuntimeReceiptResponse = {
   receipt?: WorkerRuntimeReceipt | null;
@@ -45,18 +42,27 @@ export type WorkerRuntimeReceiptAction =
       error: string;
     };
 
+export type WorkerRuntimeReceiptCommand = WorkReceiptCommand;
+
+export type WorkerRuntimeReceiptClaim = WorkReceiptClaim;
+
+export type WorkerRuntimeReceiptStore = WorkReceiptStore;
+
+type PostRuntimeApi = (
+  baseUrl: string,
+  executorToken: string,
+  body: WorkerRuntimeReceiptAction,
+) => Promise<WorkerRuntimeReceiptResponse>;
+
 type RuntimeReceiptContext = {
-  baseUrl: string;
-  executorToken: string;
+  baseUrl?: string;
+  executorToken?: string;
   orgId?: string | null;
   playName: string;
   runId: string;
   key: string;
-  postRuntimeApi: (
-    baseUrl: string,
-    executorToken: string,
-    body: WorkerRuntimeReceiptAction,
-  ) => Promise<WorkerRuntimeReceiptResponse>;
+  postRuntimeApi?: PostRuntimeApi;
+  receiptStore?: WorkerRuntimeReceiptStore;
 };
 
 function scopedReceiptKey(input: {
@@ -75,94 +81,185 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-function runningReceiptError(key: string, receipt: WorkerRuntimeReceipt): Error {
+function runningReceiptError(
+  key: string,
+  receipt: WorkerRuntimeReceipt,
+): Error {
   return new Error(
     `Runtime receipt ${key} is already running for run ${receipt.runId ?? 'unknown'}.`,
   );
 }
 
-export async function runWorkerRuntimeReceiptBoundary<T>(
-  input: RuntimeReceiptContext & {
-    execute: () => Promise<T> | T;
-  },
-): Promise<T> {
-  const key = scopedReceiptKey(input);
+function isReusableReceipt(receipt: WorkerRuntimeReceipt): boolean {
+  return receipt.status === 'completed' || receipt.status === 'skipped';
+}
+
+export function createRuntimeApiWorkerReceiptStore(input: {
+  baseUrl: string;
+  executorToken: string;
+  postRuntimeApi: PostRuntimeApi;
+}): WorkerRuntimeReceiptStore {
   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,
-    runId: input.runId,
-    key,
-  });
-  if (!claimed.receipt) {
-    const latest = await postRuntimeReceiptAction({
-      action: 'get_runtime_step_receipt',
-      playName: input.playName,
-      runId: input.runId,
-      key,
-    });
-    if (
-      latest.receipt?.status === 'completed' ||
-      latest.receipt?.status === 'skipped'
-    ) {
-      return receiptOutput<T>(latest.receipt);
-    }
-    if (latest.receipt?.status === 'running') {
-      throw runningReceiptError(key, latest.receipt);
-    }
-    if (latest.receipt?.status === 'failed') {
+  return {
+    async claimReceipt(command) {
+      const claimed = await postRuntimeReceiptAction({
+        action: 'claim_runtime_step_receipt',
+        playName: command.playName,
+        runId: command.runId,
+        key: command.key,
+      });
+      if (claimed.receipt) {
+        return { disposition: 'claimed', receipt: claimed.receipt };
+      }
+
+      const latest = await postRuntimeReceiptAction({
+        action: 'get_runtime_step_receipt',
+        playName: command.playName,
+        runId: command.runId,
+        key: command.key,
+      });
+      if (latest.receipt && isReusableReceipt(latest.receipt)) {
+        return { disposition: 'reused', receipt: latest.receipt };
+      }
+      if (latest.receipt?.status === 'running') {
+        return { disposition: 'running', receipt: latest.receipt };
+      }
+      if (latest.receipt?.status === 'failed') {
+        return { disposition: 'failed', receipt: latest.receipt };
+      }
       throw new Error(
-        `Runtime receipt ${key} is failed and could not be claimed: ${latest.receipt.error ?? 'unknown error'}`,
+        `Runtime receipt ${command.key} claim did not return execution ownership.`,
       );
-    }
+    },
+
+    async completeReceipt(command) {
+      const completed = await postRuntimeReceiptAction({
+        action: 'complete_runtime_step_receipt',
+        playName: command.playName,
+        runId: command.runId,
+        key: command.key,
+        output: command.output,
+      });
+      return completed.receipt ?? null;
+    },
+
+    async failReceipt(command) {
+      const failed = await postRuntimeReceiptAction({
+        action: 'fail_runtime_step_receipt',
+        playName: command.playName,
+        runId: command.runId,
+        key: command.key,
+        error: command.error,
+      });
+      return failed.receipt ?? null;
+    },
+  };
+}
+
+function resolveReceiptStore(
+  input: RuntimeReceiptContext,
+): WorkerRuntimeReceiptStore {
+  if (input.receiptStore) {
+    return input.receiptStore;
+  }
+  if (!input.baseUrl || !input.executorToken || !input.postRuntimeApi) {
     throw new Error(
-      `Runtime receipt ${key} claim did not return execution ownership.`,
+      'Runtime receipts require either a receiptStore or Runtime API transport.',
     );
   }
+  return createRuntimeApiWorkerReceiptStore({
+    baseUrl: input.baseUrl,
+    executorToken: input.executorToken,
+    postRuntimeApi: input.postRuntimeApi,
+  });
+}
 
+async function executeAndPersistReceipt<T>(input: {
+  key: string;
+  playName: string;
+  runId: string;
+  execute: () => Promise<T> | T;
+  receiptStore: WorkerRuntimeReceiptStore;
+  ownership: 'claimed' | 'workflow_replay';
+}): Promise<T> {
   let output: T;
   try {
     output = await input.execute();
   } catch (error) {
-    const failed = await postRuntimeReceiptAction({
-      action: 'fail_runtime_step_receipt',
+    const failed = await input.receiptStore.failReceipt({
       playName: input.playName,
       runId: input.runId,
-      key,
+      key: input.key,
       error: errorMessage(error),
     });
-    if (!failed.receipt) {
+    if (!failed) {
       throw new Error(
-        `Runtime receipt ${key} execution failed and failed receipt could not be persisted: ${errorMessage(error)}`,
+        `Runtime receipt ${input.key} ${input.ownership} execution failed and failed receipt could not be persisted: ${errorMessage(error)}`,
       );
     }
     throw error;
   }
-  const completed = await postRuntimeReceiptAction({
-    action: 'complete_runtime_step_receipt',
+
+  const completed = await input.receiptStore.completeReceipt({
     playName: input.playName,
     runId: input.runId,
-    key,
+    key: input.key,
     output,
   });
-  if (!completed.receipt) {
+  if (!completed) {
     throw new Error(
-      `Runtime receipt ${key} execution completed but completed receipt could not be persisted.`,
+      `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 receiptStore = resolveReceiptStore(input);
+  const claimed = await receiptStore.claimReceipt({
+    playName: input.playName,
+    runId: input.runId,
+    key,
+  });
+  if (claimed.disposition === 'reused') {
+    return receiptOutput<T>(claimed.receipt);
+  }
+  if (claimed.disposition === 'running') {
+    if (
+      input.repairRunningReceiptForSameRun &&
+      claimed.receipt.runId === input.runId
+    ) {
+      return executeAndPersistReceipt({
+        key,
+        playName: input.playName,
+        runId: input.runId,
+        execute: input.execute,
+        receiptStore,
+        ownership: 'workflow_replay',
+      });
+    }
+    throw runningReceiptError(key, claimed.receipt);
+  }
+  if (claimed.disposition === 'failed') {
+    throw new Error(
+      `Runtime receipt ${key} is failed and could not be claimed: ${claimed.receipt.error ?? 'unknown error'}`,
+    );
+  }
+
+  return executeAndPersistReceipt({
+    key,
+    playName: input.playName,
+    runId: input.runId,
+    execute: input.execute,
+    receiptStore,
+    ownership: 'claimed',
+  });
+}

package/dist/repo/sdk/src/plays/harness-stub.ts

@@ -32,13 +32,20 @@
 import type {
   PlayHarnessRpc,
   PreloadedRuntimeDbSessionInput,
+  CompleteRuntimeReceiptInput,
+  FailRuntimeReceiptInput,
   RuntimeApiCallInput,
   RuntimeApiCallResult,
+  RuntimeReceiptInput,
   SheetDatasetRowsInput,
   SheetDatasetRowsResult,
   StagedFileChunkInput,
   StagedFileChunkResult,
 } from '../../../apps/play-harness-worker/src/rpc-types';
+import type {
+  WorkReceipt,
+  WorkReceiptClaim,
+} from '../../../shared_libs/play-runtime/work-receipts';
 
 /**
  * Service-binding RPC stub shape — what `env.HARNESS` looks like inside
@@ -119,6 +126,24 @@ export async function harnessRuntimeApiCall(
   return requireBinding().runtimeApiCall(input);
 }
 
+export async function harnessClaimRuntimeReceipt(
+  input: RuntimeReceiptInput,
+): Promise<WorkReceiptClaim> {
+  return requireBinding().claimRuntimeReceipt(input);
+}
+
+export async function harnessCompleteRuntimeReceipt(
+  input: CompleteRuntimeReceiptInput,
+): Promise<WorkReceipt | null> {
+  return requireBinding().completeRuntimeReceipt(input);
+}
+
+export async function harnessFailRuntimeReceipt(
+  input: FailRuntimeReceiptInput,
+): Promise<WorkReceipt | null> {
+  return requireBinding().failRuntimeReceipt(input);
+}
+
 /**
  * Read a bounded staged-file byte range through typed harness RPC. This is the
  * only staged-file data path for per-play Workers; there is intentionally no

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.62',
   apiContract: '2026-05-play-bootstrap-dataset-summary',
   supportPolicy: {
-    latest: '0.1.60',
+    latest: '0.1.62',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
   },

package/package.json

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