deepline 0.1.208 → 0.1.210

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

@@ -2445,8 +2445,6 @@ function runRequestFromPlayWorkflowParams(
     preloadedDbSessions: params.preloadedDbSessions ?? null,
     runtimeTestFaultHeader: params.runtimeTestFaultHeader ?? null,
     testPolicyOverrides: params.testPolicyOverrides ?? null,
-    inlineChildRunRegistered:
-      params.runtimeBackend === 'cf_workflows_dynamic_worker_inline_child',
     coordinatorUrl: params.coordinatorUrl ?? null,
     coordinatorInternalToken: params.coordinatorInternalToken ?? null,
     totalRows: params.totalRows,

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

@@ -32,6 +32,7 @@ import {
   type WorkflowEvent,
   type WorkflowStep,
 } from 'cloudflare:workers';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import {
   deterministicMapChunkStepName,
   type ExecutionPlan,
@@ -40,7 +41,6 @@ import {
   STANDARD_PLAY_RUNTIME_LIMIT_LABEL,
   STANDARD_PLAY_RUNTIME_LIMIT_SECONDS,
 } from '../../../shared_libs/play-runtime/runtime-constants';
-import { childSubmitIdempotencyKey } from '../../../shared_libs/play-runtime/child-run-id';
 import {
   createPlayExecutionGovernor,
   type GovernanceSnapshot,
@@ -104,7 +104,7 @@ import {
 import { createDeferredPlayDataset } from '../../../shared_libs/plays/dataset';
 import {
   buildDurableCtxCallCacheKey,
-  buildDurableRunPlaySemanticKey,
+  buildDurableRunPlayInvocationScope,
 } from '../../../shared_libs/play-runtime/durable-call-cache';
 import {
   resolveRuntimeToolReceiptWaitMaxAttempts,
@@ -368,8 +368,6 @@ type RunRequest = {
   /** Internal ctx.runPlay lineage. Public SDK/users never see this. */
   playCallGovernance?: PlayCallGovernanceSnapshot | null;
   preloadedDbSessions?: PreloadedRuntimeDbSession[] | null;
-  /** Coordinator already created the child run row before invoking /run-inline. */
-  inlineChildRunRegistered?: boolean | null;
   /** Cloudflare coordinator URL for direct Workflow control-plane signals. */
   coordinatorUrl?: string | null;
   /** Request-scoped coordinator auth token for preview/dev direct control calls. */
@@ -1148,11 +1146,29 @@ async function drainRunnerPerfTraces(req: RunRequest): Promise<void> {
 
 let workerRequestSequence = 0;
 
+const workerRunPlayRowContext = new AsyncLocalStorage<{
+  tableNamespace: string;
+  rowKey: string;
+  fieldName: string;
+}>();
+
 function makeRequestId(): string {
   workerRequestSequence = (workerRequestSequence + 1) % Number.MAX_SAFE_INTEGER;
   return `worker-request-${workerRequestSequence}`;
 }
 
+async function executeFreshChildInvocation<T>(
+  input: {
+    parentRunId: string;
+    key: string;
+    invocationScope: string;
+  },
+  execute: (invocationId: string) => Promise<T>,
+): Promise<T> {
+  const invocationId = `${input.parentRunId}:runPlay:${input.key}:${input.invocationScope}`;
+  return await execute(invocationId);
+}
+
 function makeRuntimeSheetAttempt(input: {
   runId: string;
   runAttempt?: number | null;
@@ -1665,27 +1681,6 @@ async function hashChildPlayEventKey(input: unknown): Promise<string> {
   return (await hashJson(input)).slice(0, 32);
 }
 
-function workerChildRevisionFingerprint(input: {
-  playName: string;
-  manifest: PlayRuntimeManifest | null | undefined;
-}): string | null {
-  const manifest = input.manifest;
-  if (!manifest) return null;
-  return sha256Hex(
-    stableStringify({
-      playId: manifest.playName?.trim() || input.playName,
-      codeFormat: 'cjs_module',
-      artifactHash: manifest.artifactHash ?? null,
-      graphHash: manifest.graphHash ?? null,
-      sourceHash: null,
-      sourceCodeHash:
-        typeof manifest.sourceCode === 'string'
-          ? sha256Hex(manifest.sourceCode)
-          : null,
-    }),
-  );
-}
-
 type RuntimeResolvedPlayResponse = {
   manifest?: PlayRuntimeManifest | null;
 };
@@ -5580,37 +5575,49 @@ function createMinimalWorkerCtx(
                             })
                           : null,
                     });
-                    const resolved = await executeWorkerStepResolver(
-                      value,
-                      enriched,
-                      rowCtx,
-                      absoluteIndex,
-                      previousCell,
-                      isWorkerStepProgram(value)
-                        ? {
-                            parentField: key,
-                            path: [],
-                            outputs: stepProgramOutputs,
-                            onOutput: async (stepOutput) => {
-                              generatedOutputFields.add(stepOutput.columnName);
-                              const status = stepOutput.status ?? 'completed';
-                              if (status === 'skipped') stepCellsSkipped += 1;
-                              else stepCellsCompleted += 1;
-                              await enqueueLiveRowUpdate({
-                                key: entry.rowKey,
-                                dataPatch: {
-                                  [stepOutput.columnName]: stepOutput.value,
-                                },
-                                cellMetaPatch: {
-                                  [stepOutput.columnName]: {
-                                    status,
-                                    stage: stepOutput.stepId,
-                                  },
+                    const resolved = await workerRunPlayRowContext.run(
+                      {
+                        tableNamespace: name,
+                        rowKey: entry.rowKey,
+                        fieldName: key,
+                      },
+                      () =>
+                        executeWorkerStepResolver(
+                          value,
+                          enriched,
+                          rowCtx,
+                          absoluteIndex,
+                          previousCell,
+                          isWorkerStepProgram(value)
+                            ? {
+                                parentField: key,
+                                path: [],
+                                outputs: stepProgramOutputs,
+                                onOutput: async (stepOutput) => {
+                                  generatedOutputFields.add(
+                                    stepOutput.columnName,
+                                  );
+                                  const status =
+                                    stepOutput.status ?? 'completed';
+                                  if (status === 'skipped')
+                                    stepCellsSkipped += 1;
+                                  else stepCellsCompleted += 1;
+                                  await enqueueLiveRowUpdate({
+                                    key: entry.rowKey,
+                                    dataPatch: {
+                                      [stepOutput.columnName]: stepOutput.value,
+                                    },
+                                    cellMetaPatch: {
+                                      [stepOutput.columnName]: {
+                                        status,
+                                        stage: stepOutput.stepId,
+                                      },
+                                    },
+                                  });
                                 },
-                              });
-                            },
-                          }
-                        : undefined,
+                              }
+                            : undefined,
+                        ),
                     );
                     enriched[key] = resolved.value;
                     fieldOutputs[key] = resolved.value;
@@ -6933,7 +6940,6 @@ function createMinimalWorkerCtx(
       options?: {
         description?: string;
         timeoutMs?: number;
-        staleAfterSeconds?: number;
       },
     ): Promise<unknown> {
       const normalizedKey = normalizeContextKey(key, 'runPlay');
@@ -6947,34 +6953,49 @@ function createMinimalWorkerCtx(
         playRef: resolvedName,
         cache: childManifestCache,
       });
-      const receiptKey = buildDurableCtxCallCacheKey({
-        orgId: req.orgId,
-        playId: req.playName,
-        kind: 'runPlay',
-        id: normalizedKey,
-        semanticKey: buildDurableRunPlaySemanticKey({
-          childPlayName: resolvedName,
-          childRevisionFingerprint: workerChildRevisionFingerprint({
-            playName: resolvedName,
-            manifest: childManifest,
-          }),
-          input,
-        }),
-        staleAfterSeconds: options?.staleAfterSeconds,
+      const rowScope = workerRunPlayRowContext.getStore();
+      const invocationScope = buildDurableRunPlayInvocationScope({
+        childPlayName: resolvedName,
+        input,
+        rowScope: rowScope
+          ? {
+              fieldName: rowScope.fieldName,
+              rowKey: rowScope.rowKey,
+              tableNamespace: rowScope.tableNamespace,
+            }
+          : null,
       });
-      return await executeWithRuntimeReceipt(
-        receiptKey,
-        async (receiptContext, wasFailed) => {
+      return await executeFreshChildInvocation(
+        {
+          parentRunId: req.runId,
+          key: normalizedKey,
+          invocationScope,
+        },
+        async (childInvocationId) => {
           // The Governor owns the play-call lineage: forkChild does the cycle
           // guard, depth/per-parent/playCall/descendant budget charges, and
           // returns the snapshot to thread into the child so budgets accumulate
-          // across isolates. Charged inside the receipt boundary so a replay
-          // (cache hit) never double-charges.
-          const childRunId = `${req.runId}:child:${normalizedKey}`;
-          const childGovernance = await governor.forkChild({
-            childPlayName: resolvedName,
-            childRunId,
-          });
+          // across isolates. Every ctx.runPlay call is a fresh child invocation.
+          const childRunId = `${req.runId}:child:${childInvocationId}`;
+          // Checkpoint governance admission separately from the child result.
+          // Workflow replay reuses this admission and the coordinator's stable
+          // child launch identity, but ctx.runPlay never caches child output.
+          const forkChild = () =>
+            governor.forkChild({
+              childPlayName: resolvedName,
+              childRunId,
+            });
+          const childGovernance = workflowStep
+            ? await (
+                workflowStep.do as unknown as <T>(
+                  name: string,
+                  callback: () => Promise<T>,
+                ) => Promise<T>
+              )(
+                `runPlay-governance:${sha256Hex(childInvocationId).slice(0, 24)}`,
+                forkChild,
+              )
+            : await forkChild();
           const nextDepth = childGovernance.callDepth;
           const nextParentCalls =
             governor.snapshot().parentChildCalls[req.playName] ?? 0;
@@ -7047,11 +7068,7 @@ function createMinimalWorkerCtx(
                   options?.timeoutMs == null && !childNeedsWorkflowScheduler,
                 body: {
                   name: resolvedName,
-                  childIdempotencyKey: childSubmitIdempotencyKey({
-                    receiptKey,
-                    wasFailed,
-                    leaseId: receiptContext.leaseId,
-                  }),
+                  childIdempotencyKey: childInvocationId,
                   input: isRecord(input) ? input : {},
                   orgId: req.orgId,
                   callbackUrl: req.callbackUrl,
@@ -7329,12 +7346,6 @@ function createMinimalWorkerCtx(
             childPlaySlot?.release();
           }
         },
-        {
-          forceFailedRefresh: true,
-          repairRunningReceiptForSameRunAfterWaitTimeout: true,
-          runningReceiptWaitMaxAttempts:
-            resolveRuntimeToolReceiptWaitMaxAttempts(input),
-        },
       );
     },
     async fetch(
@@ -7615,13 +7626,6 @@ async function handleRunInline(
     const probeStartedAt = nowMs();
     await probeHarnessOnce(env, runPrefix);
     traceInline('inline.probe_harness', probeStartedAt);
-    if (!req.inlineChildRunRegistered) {
-      const registerStartedAt = nowMs();
-      await registerInlineChildRun(req);
-      traceInline('inline.register_child_run', registerStartedAt);
-    } else {
-      traceInline('inline.register_child_run', nowMs(), { skipped: true });
-    }
     const executeStartedAt = nowMs();
     const output = await executeRunRequest(
       req,
@@ -7667,46 +7671,6 @@ async function handleRunInline(
   }
 }
 
-async function registerInlineChildRun(req: RunRequest): Promise<void> {
-  const snapshot = isRecord(req.contractSnapshot) ? req.contractSnapshot : {};
-  const artifactMetadata = isRecord(snapshot.artifactMetadata)
-    ? snapshot.artifactMetadata
-    : {};
-  const governance = req.playCallGovernance;
-  await postRuntimeApi(req.baseUrl, req.executorToken, {
-    action: 'start_inline_child_run',
-    playName: req.playName,
-    runId: req.runId,
-    parentRunId: governance?.parentRunId,
-    rootRunId: governance?.rootRunId,
-    workflowFamilyKey:
-      governance?.rootRunId ?? governance?.parentRunId ?? req.runId,
-    artifactStorageKey:
-      typeof artifactMetadata.storageKey === 'string'
-        ? artifactMetadata.storageKey
-        : undefined,
-    artifactHash:
-      typeof artifactMetadata.artifactHash === 'string'
-        ? artifactMetadata.artifactHash
-        : undefined,
-    graphHash:
-      typeof artifactMetadata.graphHash === 'string'
-        ? artifactMetadata.graphHash
-        : undefined,
-    runtimeBackend: 'workers_edge',
-    schedulerBackend: 'inline_child',
-    executionProfile: 'workers_edge',
-    maxCreditsPerRun: extractMaxCreditsPerRun(req.contractSnapshot),
-    staticPipeline: snapshot.staticPipeline ?? null,
-    source:
-      snapshot.source === 'published' ||
-      snapshot.source === 'ad_hoc' ||
-      snapshot.source === 'draft'
-        ? snapshot.source
-        : 'published',
-  });
-}
-
 /** Cap on run log lines retained in the terminal output compatibility shape. */
 const RUN_LOG_BUFFER_LIMIT = 500;
 /** Min wall-clock interval between live run-ledger flushes during a run. */

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

@@ -4,7 +4,6 @@ import {
   type WorkReceiptBatchMarkRunningCommand,
   type WorkReceiptClaim,
   type WorkReceiptCommand,
-  type WorkReceiptFailureKind,
   type WorkReceiptGetCommand,
   type WorkReceiptStatus,
 } from '../../../../shared_libs/play-runtime/work-receipts';
@@ -17,6 +16,7 @@ import {
   isPlayExecutionSuspendedError,
   isPlayRowExecutionSuspendedError,
 } from '../../../../shared_libs/play-runtime/suspension';
+import { runtimeReceiptFailureKindForError } from '../../../../shared_libs/play-runtime/durable-receipt-execution';
 import type { WorkerWorkBudgetMeter } from './work-budget';
 
 export type RuntimeReceiptStatus = WorkReceiptStatus;
@@ -132,15 +132,6 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-function runtimeReceiptFailureKindForError(
-  error: unknown,
-): WorkReceiptFailureKind {
-  return isPlayExecutionSuspendedError(error) ||
-    isPlayRowExecutionSuspendedError(error)
-    ? 'repairable'
-    : 'terminal';
-}
-
 async function waitForReusableReceipt<T>(input: {
   key: string;
   playName: string;
@@ -363,8 +354,7 @@ async function executeAndPersistReceipt<T>(input: {
       budgetMeter: input.budgetMeter,
       heartbeatIntervalMs: input.heartbeatIntervalMs,
       targets: [{ key: input.key, leaseId }],
-      execute: () =>
-        input.execute({ leaseId }, input.wasFailed === true),
+      execute: () => input.execute({ leaseId }, input.wasFailed === true),
     });
   } catch (error) {
     if (error instanceof RuntimeLeaseLostError) {

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/tool-dispatch.ts

@@ -54,6 +54,7 @@ import {
   markWorkerToolReceiptResultCached,
   markWorkerToolReceiptResultExecution,
   planWorkerToolReceiptGroups,
+  resolveRunningReceiptWaitMaxAttempts,
   resolveWorkerToolReceiptGroupWaitMaxAttempts,
   resolveWorkerToolRuntimeTimeoutMs,
 } from './tool-receipts';
@@ -1232,10 +1233,17 @@ export class WorkerToolBatchScheduler {
               try {
                 const result = await this.waitForDurableToolReceipt({
                   receiptKey,
-                  maxAttempts: resolveWorkerToolReceiptGroupWaitMaxAttempts(
-                    group,
-                    (request) => request.receiptWaitMaxAttempts,
-                  ),
+                  maxAttempts: resolveRunningReceiptWaitMaxAttempts({
+                    ownerRunId: claim.receipt.runId,
+                    currentRunId: this.options.req.runId,
+                    updatedAt: claim.receipt.updatedAt,
+                    requestedMaxAttempts:
+                      resolveWorkerToolReceiptGroupWaitMaxAttempts(
+                        group,
+                        (request) => request.receiptWaitMaxAttempts,
+                      ),
+                    nowMs: this.options.nowMs(),
+                  }),
                 });
                 if (groupState.forceDurableRefresh) {
                   return await this.claimForcedDurableToolReceiptGroupAfterWait(

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/tool-receipts.ts

@@ -39,106 +39,39 @@ export function canReclaimTimedOutWorkerToolReceipt(input: {
  * conservative constant, not a heartbeat multiple.
  */
 export const RUNNING_RECEIPT_DEAD_OWNER_STALENESS_MS = 60_000;
+export const RUNNING_RECEIPT_POLL_INTERVAL_MS = 250;
 
-/**
- * Decide whether a `running` receipt should be reclaimed IMMEDIATELY, skipping
- * the completion poll.
- *
- * The poll (`waitForCompletedRuntimeReceipt`) issues one service-binding
- * subrequest per 250ms tick, up to the receipt's wait budget (~1320 ticks for a
- * 5.5-minute default). On resume, a map can carry many receipts left `running`
- * by a DEAD prior run; polling each one burns its full tick budget waiting on a
- * receipt no live worker will complete, which blows Cloudflare's ~1000
- * subrequests-per-invocation budget and kills the resume with
- * "Too many subrequests by single Worker invocation" (prod resume deaths
- * 20260703t230209 / 20260703t232104).
- *
- * A receipt is a dead-owner orphan when it is owned by a DIFFERENT run (a
- * same-run `running` is this run replaying — its owner may still be live) and
- * its last write is stale (or missing entirely — a live owner would carry a
- * recent claim timestamp). Those reclaim immediately, matching the dispatch
- * code's own contract ("on resume it reclaims and re-executes"). A live or
- * freshly-claimed owner keeps the poll.
- */
-export function shouldReclaimRunningReceiptWithoutPolling(input: {
+/** Bound a follower poll by when a different-run owner becomes reclaimable. */
+export function resolveRunningReceiptWaitMaxAttempts(input: {
   ownerRunId?: string | null;
   currentRunId: string;
   updatedAt?: string | null;
+  requestedMaxAttempts: number;
   nowMs?: number;
   stalenessFloorMs?: number;
-}): boolean {
-  const currentRunId = input.currentRunId.trim();
+  pollIntervalMs?: number;
+}): number {
+  const requested = Math.max(1, Math.floor(input.requestedMaxAttempts));
   const ownerRunId = input.ownerRunId?.trim() ?? '';
-  // Only a receipt owned by a different run can be a dead prior-run orphan.
-  if (!currentRunId || !ownerRunId || ownerRunId === currentRunId) return false;
-  const floorMs =
-    input.stalenessFloorMs ?? RUNNING_RECEIPT_DEAD_OWNER_STALENESS_MS;
-  // No freshness signal at all: treat as stale. A live owner would carry a
-  // recent claim timestamp; an orphan from a dead run may carry none.
-  if (!input.updatedAt) return true;
-  const updatedAtMs = Date.parse(input.updatedAt);
-  if (!Number.isFinite(updatedAtMs)) return true;
-  const now = input.nowMs ?? Date.now();
-  return now - updatedAtMs >= floorMs;
-}
-
-/** Metadata a `running` receipt carries about its owner and last write. */
-export interface RunningReceiptOwnershipInput {
-  ownerRunId?: string | null;
-  currentRunId: string;
-  updatedAt?: string | null;
-  nowMs?: number;
-  stalenessFloorMs?: number;
-}
-
-/** Outcome of polling a `running` receipt for completion. */
-export type RunningReceiptPollOutcome =
-  /** The poll saw the receipt complete and already resolved the group. */
-  | { kind: 'completed' }
-  /** The poll timed out; the receipt is still `running`. */
-  | { kind: 'timed_out'; error: unknown }
-  /** The poll failed for a non-timeout reason (e.g. the receipt failed). */
-  | { kind: 'errored'; error: unknown };
-
-/**
- * Orchestrate the resume-time handling of a `running` receipt: reclaim it
- * immediately when it is a dead-owner orphan, otherwise poll for completion and
- * only reclaim after the poll times out. Kept as a pure, dependency-injected
- * function (the poll and reclaim side effects are passed in) so the
- * "skip the poll for a dead owner" decision is unit-testable with a poll counter
- * — the Worker scheduler that owns the real effects imports `cloudflare:workers`
- * and cannot be loaded under vitest.
- *
- * Behavior (must match the scheduler's prior inline logic exactly):
- * - dead-owner + reclaim-eligible → `reclaim` now, never polling;
- * - otherwise `poll`; on `completed` the group is already resolved (return []);
- *   on a non-timeout error `reject` and stop; on timeout, `reclaim` if still
- *   eligible else `reject` with the timeout error.
- */
-export async function reclaimRunningReceiptGroupAfterWait<TClaimed>(input: {
-  ownership: RunningReceiptOwnershipInput;
-  timeoutError: unknown;
-  poll: () => Promise<RunningReceiptPollOutcome>;
-  reclaim: (rejectionOnFallthrough: unknown) => Promise<TClaimed[]>;
-  reject: (error: unknown) => void;
-}): Promise<TClaimed[]> {
-  if (
-    shouldReclaimRunningReceiptWithoutPolling(input.ownership) &&
-    canReclaimTimedOutWorkerToolReceipt(input.ownership)
-  ) {
-    return await input.reclaim(input.timeoutError);
-  }
-  const outcome = await input.poll();
-  if (outcome.kind === 'completed') return [];
-  if (outcome.kind === 'errored') {
-    input.reject(outcome.error);
-    return [];
-  }
-  if (!canReclaimTimedOutWorkerToolReceipt(input.ownership)) {
-    input.reject(outcome.error);
-    return [];
+  const currentRunId = input.currentRunId.trim();
+  if (!ownerRunId || !currentRunId || ownerRunId === currentRunId) {
+    return requested;
   }
-  return await input.reclaim(outcome.error);
+  const updatedAtMs = input.updatedAt ? Date.parse(input.updatedAt) : NaN;
+  if (!Number.isFinite(updatedAtMs)) return 1;
+  const remainingMs = Math.max(
+    0,
+    updatedAtMs +
+      (input.stalenessFloorMs ?? RUNNING_RECEIPT_DEAD_OWNER_STALENESS_MS) -
+      (input.nowMs ?? Date.now()),
+  );
+  const attemptsUntilReclaim = Math.max(
+    1,
+    Math.floor(
+      remainingMs / (input.pollIntervalMs ?? RUNNING_RECEIPT_POLL_INTERVAL_MS),
+    ) + 1,
+  );
+  return Math.min(requested, attemptsUntilReclaim);
 }
 
 export function canReclaimFailedWorkerToolReceipt(input: {

package/dist/bundling-sources/sdk/src/client.ts

@@ -1807,6 +1807,16 @@ export class DeeplineClient {
     description?: string;
     artifact: Record<string, unknown>;
     integrationMode?: 'live' | 'eval_stub' | 'fixture';
+    /**
+     * Sibling plays from the same local bundle graph. Lets the server splice
+     * unpublished local children into the checked plan and enforce the
+     * row-scoped batch rule (ADR 0013).
+     */
+    importedPlays?: Array<{
+      playName?: string | null;
+      sourceCode: string;
+      sourcePath?: string | null;
+    }>;
   }): Promise<PlayCheckResult> {
     const integrationMode = normalizePlayRunIntegrationMode(
       input.integrationMode ?? process.env.DEEPLINE_EVAL_INTEGRATION_MODE,

package/dist/bundling-sources/sdk/src/play.ts

@@ -400,7 +400,7 @@ export type StepOptions<Row, Value = unknown> = {
    * Legacy dataset-column recompute flag accepted for older authored plays.
    *
    * Prefer putting freshness on the actual reusable call
-   * (`ctx.tools.execute`, `ctx.step`, `ctx.fetch`, or `ctx.runPlay`).
+   * (`ctx.tools.execute`, `ctx.step`, or `ctx.fetch`).
    */
   readonly recompute?: boolean;
   /** Legacy error-recompute flag accepted for older authored plays. */
@@ -889,7 +889,7 @@ export interface DeeplinePlayRuntimeContext {
     key: string,
     playRef: string | PlayReferenceLike,
     input: Record<string, unknown>,
-    options: { description: string; staleAfterSeconds?: number },
+    options: { description: string },
   ): Promise<TOutput>;
 
   /**

package/dist/bundling-sources/sdk/src/release.ts

@@ -106,10 +106,10 @@ export const SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: '0.1.208',
+  version: '0.1.210',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.208',
+    latest: '0.1.210',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [