deepline 0.1.156 → 0.1.158

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

@@ -246,6 +246,7 @@ import {
   previousCellFromValue,
   type PreviousCell,
 } from '../../../shared_libs/play-runtime/cell-staleness';
+import type { PlayRowUpdate } from '../../../shared_libs/play-runtime/ctx-types';
 
 // The play's default export. The bundler injects this — see bundle-play-file.ts.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -1517,6 +1518,13 @@ type RecordedStepProgramOutput = {
   status?: 'skipped';
 };
 
+type WorkerStepProgramRecorder = {
+  parentField: string;
+  path: string[];
+  outputs: RecordedStepProgramOutput[];
+  onOutput?: (output: RecordedStepProgramOutput) => void | Promise<void>;
+};
+
 type WorkerStepResolution = {
   value: unknown;
   status?: 'skipped';
@@ -2670,11 +2678,7 @@ async function executeWorkerStepResolver(
   ctx: unknown,
   index: number,
   previousCell?: PreviousCell,
-  recorder?: {
-    parentField: string;
-    path: string[];
-    outputs: RecordedStepProgramOutput[];
-  },
+  recorder?: WorkerStepProgramRecorder,
 ): Promise<WorkerStepResolution> {
   if (isWorkerConditionalStepResolver(resolver)) {
     const shouldRun = await resolver.when(row, index);
@@ -2721,11 +2725,7 @@ async function executeWorkerStepProgram(
   inputRow: Record<string, unknown>,
   ctx: unknown,
   index: number,
-  recorder?: {
-    parentField: string;
-    path: string[];
-    outputs: RecordedStepProgramOutput[];
-  },
+  recorder?: WorkerStepProgramRecorder,
   workflowStep?: WorkflowStep,
 ): Promise<unknown> {
   let currentRow: Record<string, unknown> = cloneCsvAliasedRow(inputRow);
@@ -2767,13 +2767,15 @@ async function executeWorkerStepProgram(
     const value = deserializeDurableStepValue(resolution.value);
     currentRow = cloneCsvAliasedRow(currentRow, { [step.name]: value });
     if (recorder) {
-      recorder.outputs.push({
+      const output: RecordedStepProgramOutput = {
         field: `${recorder.parentField}.${stepId}`,
         columnName: stepProgramColumnName(recorder.parentField, stepId),
         stepId,
         value,
-        status: resolution.status,
-      });
+        ...(resolution.status ? { status: resolution.status } : {}),
+      };
+      recorder.outputs.push(output);
+      await recorder.onOutput?.(output);
     }
   }
   if (typeof program.returnResolver === 'function') {
@@ -3589,7 +3591,7 @@ async function persistCompletedMapRows(input: {
   ];
   const sessionScope = runtimeSheetSessionScope(input.req);
   const rows = input.rows.map((row) => publicCsvStorageRow(row));
-  await harnessPersistCompletedSheetRows({
+  const result = await harnessPersistCompletedSheetRows({
     ...sessionScope,
     tableNamespace: input.tableNamespace,
     sheetContract: augmentSheetContractWithDatasetFields({
@@ -3600,6 +3602,46 @@ async function persistCompletedMapRows(input: {
     rows,
     outputFields,
   });
+  if (result.rowsWritten !== rows.length) {
+    throw new Error(
+      `Runtime sheet persistence mismatch for ctx.dataset("${input.tableNamespace}"): attempted to persist ${rows.length} row(s), but ${result.rowsWritten} row(s) were updated for run ${input.req.runId}.`,
+    );
+  }
+}
+
+async function applyLiveMapRowUpdates(input: {
+  req: RunRequest;
+  tableNamespace: string;
+  updates: Array<Omit<PlayRowUpdate, 'rowId'> & { runId?: string }>;
+  outputFields: string[];
+  extraOutputFields?: string[];
+}): Promise<void> {
+  if (input.updates.length === 0) return;
+  const outputFields = [
+    ...input.outputFields,
+    ...(input.extraOutputFields ?? []).filter(
+      (field) => !input.outputFields.includes(field),
+    ),
+  ];
+  const rows = input.updates.map((update) => update.dataPatch ?? {});
+  await postRuntimeApi<{ ok: true }>(
+    input.req.baseUrl,
+    input.req.executorToken,
+    {
+      action: 'apply_row_updates',
+      playName: input.req.playName,
+      tableNamespace: input.tableNamespace,
+      sheetContract: augmentSheetContractWithDatasetFields({
+        contract: requireSheetContract(input.req, input.tableNamespace),
+        rows,
+        outputFields,
+      }),
+      contractSnapshot: input.req.contractSnapshot,
+      runId: input.req.runId,
+      userEmail: input.req.userEmail,
+      updates: input.updates,
+    },
+  );
 }
 
 async function prepareMapRows(input: {
@@ -4551,6 +4593,9 @@ function createMinimalWorkerCtx(
         false,
       );
       const generatedOutputFields = new Set<string>();
+      const pendingLiveRowUpdates: Array<
+        Omit<PlayRowUpdate, 'rowId'> & { runId?: string }
+      > = [];
       const persistedExecutedIndexes = new Set<number>();
       const persistedFailedIndexes = new Set<number>();
       let pendingPersistRows = 0;
@@ -4558,6 +4603,9 @@ function createMinimalWorkerCtx(
       let scheduledPersistTimer: ReturnType<typeof setTimeout> | null = null;
       let persistFlushChain: Promise<void> = Promise.resolve();
       let persistFailure: unknown = null;
+      let scheduledLiveUpdateTimer: ReturnType<typeof setTimeout> | null = null;
+      let liveUpdateFlushChain: Promise<void> = Promise.resolve();
+      let liveUpdateFailure: unknown = null;
 
       const clearScheduledPersistTimer = () => {
         if (scheduledPersistTimer) {
@@ -4566,6 +4614,13 @@ function createMinimalWorkerCtx(
         }
       };
 
+      const clearScheduledLiveUpdateTimer = () => {
+        if (scheduledLiveUpdateTimer) {
+          clearTimeout(scheduledLiveUpdateTimer);
+          scheduledLiveUpdateTimer = null;
+        }
+      };
+
       const persistExecutedRows = async () => {
         const rowsToPersist = executedRows
           .map((row, executedIndex) =>
@@ -4659,6 +4714,60 @@ function createMinimalWorkerCtx(
         return task;
       };
 
+      const flushLiveRowUpdates = (): Promise<void> => {
+        clearScheduledLiveUpdateTimer();
+        if (pendingLiveRowUpdates.length === 0) {
+          return liveUpdateFlushChain;
+        }
+        const updates = pendingLiveRowUpdates.splice(0);
+        const extraOutputFields = Array.from(generatedOutputFields);
+        const task = liveUpdateFlushChain.then(async () => {
+          if (liveUpdateFailure) throw liveUpdateFailure;
+          await applyLiveMapRowUpdates({
+            req,
+            tableNamespace: name,
+            outputFields,
+            extraOutputFields,
+            updates,
+          });
+        });
+        liveUpdateFlushChain = task.catch((error) => {
+          liveUpdateFailure ??= error;
+        });
+        return task;
+      };
+
+      const scheduleLiveRowUpdates = () => {
+        if (liveUpdateFailure) return;
+        if (
+          pendingLiveRowUpdates.length >= MAP_INCREMENTAL_PERSIST_CHUNK_ROWS
+        ) {
+          void flushLiveRowUpdates().catch(() => undefined);
+          return;
+        }
+        if (scheduledLiveUpdateTimer) return;
+        scheduledLiveUpdateTimer = setTimeout(() => {
+          scheduledLiveUpdateTimer = null;
+          void flushLiveRowUpdates().catch(() => undefined);
+        }, MAP_INCREMENTAL_PERSIST_INTERVAL_MS);
+      };
+
+      const enqueueLiveRowUpdate = (
+        update: Omit<PlayRowUpdate, 'rowId'> & { runId?: string },
+      ): Promise<void> => {
+        if (liveUpdateFailure) {
+          return Promise.reject(liveUpdateFailure);
+        }
+        pendingLiveRowUpdates.push(update);
+        if (
+          pendingLiveRowUpdates.length >= MAP_INCREMENTAL_PERSIST_CHUNK_ROWS
+        ) {
+          return flushLiveRowUpdates();
+        }
+        scheduleLiveRowUpdates();
+        return Promise.resolve();
+      };
+
       const schedulePersistExecutedRows = () => {
         if (persistFailure) return;
         if (
@@ -4769,6 +4878,26 @@ function createMinimalWorkerCtx(
                             parentField: key,
                             path: [],
                             outputs: stepProgramOutputs,
+                            onOutput: async (stepOutput) => {
+                              generatedOutputFields.add(stepOutput.columnName);
+                              const status = stepOutput.status ?? 'completed';
+                              await enqueueLiveRowUpdate({
+                                key: entry.rowKey,
+                                tableNamespace: name,
+                                runId: req.runId,
+                                status: 'running',
+                                stage: stepOutput.stepId,
+                                dataPatch: {
+                                  [stepOutput.columnName]: stepOutput.value,
+                                },
+                                cellMetaPatch: {
+                                  [stepOutput.columnName]: {
+                                    status,
+                                    stage: stepOutput.stepId,
+                                  },
+                                },
+                              });
+                            },
                           }
                         : undefined,
                     );
@@ -4926,6 +5055,9 @@ function createMinimalWorkerCtx(
         },
       });
       try {
+        await flushLiveRowUpdates();
+        await liveUpdateFlushChain;
+        if (liveUpdateFailure) throw liveUpdateFailure;
         await enqueuePersistExecutedRows();
         await persistFlushChain;
         if (persistFailure) throw persistFailure;

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/map-chunk-plan.ts

@@ -2,8 +2,10 @@ import {
   chooseMapChunkSize,
   type ExecutionPlan,
 } from '../../../../shared_libs/play-runtime/execution-plan';
+import { TOOL_CALLING_MAP_CHUNK_SIZE } from '../../../../shared_libs/play-runtime/map-chunk-limits';
 
 export const CACHE_ENABLED_SIMPLE_MAP_CHUNK_SIZE = 10_000;
+export { TOOL_CALLING_MAP_CHUNK_SIZE };
 
 export type WorkerMapChunkPlanInput = {
   mapName: string;
@@ -31,7 +33,7 @@ export function chooseWorkerMapRowsPerChunk(
   const toolFreeSimpleMap =
     !!planMap &&
     planMap.stepsPerChunk === 1 &&
-    (plan?.toolDeclarations.length ?? 0) === 0;
+    !mapDoesExternalWork(planMap, plan);
   if (
     toolFreeSimpleMap &&
     (input.rowCountHint === null ||
@@ -40,5 +42,55 @@ export function chooseWorkerMapRowsPerChunk(
     return Math.max(rowsPerChunk, CACHE_ENABLED_SIMPLE_MAP_CHUNK_SIZE);
   }
 
+  if (
+    mapDoesExternalWork(planMap, plan) &&
+    input.rowCountHint !== null &&
+    input.rowCountHint <= rowsPerChunk
+  ) {
+    return Math.min(rowsPerChunk, TOOL_CALLING_MAP_CHUNK_SIZE);
+  }
+
   return rowsPerChunk;
 }
+
+function mapDoesExternalWork(
+  planMap: ExecutionPlan['maps'][number] | undefined,
+  plan: ExecutionPlan | null,
+): boolean {
+  if (Array.isArray(planMap?.externalStepFields)) {
+    return planMap.externalStepFields.length > 0;
+  }
+  if (!plan?.toolDeclarations.length) {
+    return false;
+  }
+  if (!planMap) {
+    return true;
+  }
+  const outputFields = new Set(planMap.outputFields);
+  const mapFields = new Set([
+    planMap.mapName,
+    planMap.tableNamespace,
+    ...planMap.outputFields,
+    ...(planMap.stepFields ?? []),
+    ...(planMap.externalStepFields ?? []),
+    ...planMap.waterfallStages.flatMap((stage) => [
+      stage.waterfallId,
+      ...stage.stageIds,
+    ]),
+  ]);
+  return plan.toolDeclarations.some((tool) => {
+    const field = tool.field?.trim();
+    if (!field) {
+      return false;
+    }
+    if (mapFields.has(field)) {
+      return true;
+    }
+    if (!field.includes('.')) {
+      return false;
+    }
+    const firstSegment = field.slice(0, field.indexOf('.'));
+    const lastSegment = field.slice(field.lastIndexOf('.') + 1);
+    return outputFields.has(firstSegment) || outputFields.has(lastSegment);
+  });
+}

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

@@ -362,6 +362,17 @@ export type ConditionalStepResolver<Row, Value, Else = null> = {
 export type StepOptions<Row, Value = unknown> = {
   /** Optional row-level gate. Skipped rows produce `null` for this column. */
   readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>;
+  /**
+   * 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`).
+   */
+  readonly recompute?: boolean;
+  /** Legacy error-recompute flag accepted for older authored plays. */
+  readonly recomputeOnError?: boolean;
+  /** Legacy cell staleness metadata accepted for older authored plays. */
+  readonly staleAfterSeconds?: number;
 };
 
 export type StepProgram<Input, Output, Return = Output> = {
@@ -395,6 +406,9 @@ export type StepProgramResolver<Input, Return> = {
 
 export type PlayStepProgramStep = {
   readonly name: string;
+  readonly recompute?: boolean;
+  readonly recomputeOnError?: boolean;
+  readonly staleAfterSeconds?: number;
   readonly resolver:
     | StepResolver<Record<string, unknown>, unknown>
     | ConditionalStepResolver<Record<string, unknown>, unknown>
@@ -1184,6 +1198,13 @@ class DeeplineStepProgram<Input, Output, ReturnValue> implements StepProgram<
         ...this.steps,
         {
           name,
+          ...(options?.recompute === true ? { recompute: true } : {}),
+          ...(options?.recomputeOnError === true
+            ? { recomputeOnError: true }
+            : {}),
+          ...(typeof options?.staleAfterSeconds === 'number'
+            ? { staleAfterSeconds: options.staleAfterSeconds }
+            : {}),
           resolver: stepResolver as PlayStepProgramStep['resolver'],
         },
       ],

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

@@ -104,10 +104,10 @@ export const SDK_RELEASE = {
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
-  version: '0.1.156',
+  version: '0.1.158',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.156',
+    latest: '0.1.158',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

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

@@ -128,6 +128,13 @@ class WorkerStepProgram<Input, Output, ReturnValue> implements StepProgram<
         ...this.steps,
         {
           name,
+          ...(options?.recompute === true ? { recompute: true } : {}),
+          ...(options?.recomputeOnError === true
+            ? { recomputeOnError: true }
+            : {}),
+          ...(typeof options?.staleAfterSeconds === 'number'
+            ? { staleAfterSeconds: options.staleAfterSeconds }
+            : {}),
           resolver: stepResolver as PlayStepProgramStep['resolver'],
         },
       ],

package/dist/bundling-sources/shared_libs/play-data-plane/sheet-contract.ts

@@ -135,7 +135,7 @@ export function augmentSheetContractWithDatasetFields(input: {
     }
   }
 
-  const existingFields = new Set<string>();
+  const existingDatasetPayloadFields = new Set<string>();
   const existingSqlNames = new Set<string>();
   const inputColumns: PlaySheetContract['columns'] = [];
   const outputColumns: PlaySheetContract['columns'] = [];
@@ -145,15 +145,19 @@ export function augmentSheetContractWithDatasetFields(input: {
   ) => {
     const field = typeof column.field === 'string' ? column.field : column.id;
     const sqlName = column.sqlName.trim();
+    const isDatasetPayloadColumn =
+      column.source === 'input' || column.source === 'datasetColumn';
     if (
       !field ||
       !sqlName ||
-      existingFields.has(field) ||
+      (isDatasetPayloadColumn && existingDatasetPayloadFields.has(field)) ||
       existingSqlNames.has(sqlName)
     ) {
       return;
     }
-    existingFields.add(field);
+    if (isDatasetPayloadColumn) {
+      existingDatasetPayloadFields.add(field);
+    }
     existingSqlNames.add(sqlName);
     target.push(column);
   };
@@ -175,7 +179,7 @@ export function augmentSheetContractWithDatasetFields(input: {
   }
 
   for (const field of candidateFields) {
-    if (existingFields.has(field)) continue;
+    if (existingDatasetPayloadFields.has(field)) continue;
     const sqlName = sqlSafePlayColumnName(field);
     if (existingSqlNames.has(sqlName)) continue;
     appendColumn(outputFields.has(field) ? outputColumns : inputColumns, {

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -654,6 +654,9 @@ export type RuntimeConditionalStepResolver<
 
 export type RuntimeStepProgramStep = {
   name: string;
+  recompute?: boolean;
+  recomputeOnError?: boolean;
+  staleAfterSeconds?: number;
   resolver:
     | RuntimeStepResolver
     | RuntimeConditionalStepResolver

package/dist/bundling-sources/shared_libs/play-runtime/execution-plan.ts

@@ -1,5 +1,6 @@
 import {
   flattenStaticPipeline,
+  flattenStaticSubsteps,
   type PlayStaticPipeline,
   type PlayStaticSubstep,
 } from '../plays/static-pipeline';
@@ -28,6 +29,8 @@ export type ExecutionPlanMap = {
   mapName: string;
   tableNamespace: string;
   outputFields: string[];
+  stepFields: string[];
+  externalStepFields: string[];
   waterfallStages: Array<{
     waterfallId: string;
     stageIds: string[];
@@ -198,52 +201,166 @@ function extractPlanMaps(
     (substep): substep is Extract<PlayStaticSubstep, { type: 'step_suite' }> =>
       substep.type === 'step_suite',
   );
-  return substeps
-    .filter(
-      (substep): substep is Extract<PlayStaticSubstep, { type: 'dataset' }> =>
-        substep.type === 'dataset',
-    )
-    .map((mapSubstep) => {
-      const waterfalls = fallbackWaterfalls.filter((waterfall) => {
-        if (!mapSubstep.waterfallIds?.length) return true;
+  const datasetSubsteps = substeps.filter(
+    (substep): substep is Extract<PlayStaticSubstep, { type: 'dataset' }> =>
+      substep.type === 'dataset',
+  );
+  const hasSiblingMaps = datasetSubsteps.length > 1;
+  return datasetSubsteps.map((mapSubstep) => {
+    const waterfalls = fallbackWaterfalls.filter((waterfall) => {
+      if (!mapSubstep.waterfallIds?.length) {
         return (
-          (waterfall.id && mapSubstep.waterfallIds.includes(waterfall.id)) ||
-          mapSubstep.waterfallIds.includes(waterfall.field)
+          !hasSiblingMaps ||
+          substepFieldBelongsToMap(waterfall.field, mapSubstep)
         );
-      });
-      const waterfallStages = waterfalls.map((waterfall) => ({
-        waterfallId: waterfall.id ?? waterfall.field,
-        stageIds: waterfall.steps?.map((step) => step.id) ?? [],
-      }));
-      const stepSuites = fallbackStepSuites.filter((stepSuite) => {
-        if (!mapSubstep.waterfallIds?.length) return true;
-        return mapSubstep.waterfallIds.includes(stepSuite.field);
-      });
-      const stepSuiteStepsPerChunk = stepSuites.reduce(
-        (max, stepSuite) => Math.max(max, stepSuite.steps.length),
-        0,
-      );
-      const waterfallStepsPerChunk = waterfallStages.reduce(
-        (max, waterfall) => Math.max(max, waterfall.stageIds.length),
-        0,
-      );
-      const stepsPerChunk = Math.max(
-        1,
-        waterfallStepsPerChunk,
-        stepSuiteStepsPerChunk,
+      }
+      return (
+        (waterfall.id && mapSubstep.waterfallIds.includes(waterfall.id)) ||
+        mapSubstep.waterfallIds.includes(waterfall.field)
       );
-      return {
-        mapName: mapSubstep.name ?? mapSubstep.field,
-        tableNamespace: mapSubstep.tableNamespace ?? mapSubstep.field,
-        outputFields: mapSubstep.outputFields ?? [],
-        waterfallStages,
-        defaultChunkSize:
-          stepsPerChunk > 1
-            ? EXECUTION_PLAN_DEFAULTS.complexMapChunkSize
-            : EXECUTION_PLAN_DEFAULTS.largeMapChunkSize,
-        stepsPerChunk,
-      };
     });
+    const waterfallStages = waterfalls.map((waterfall) => ({
+      waterfallId: waterfall.id ?? waterfall.field,
+      stageIds: waterfall.steps?.map((step) => step.id) ?? [],
+    }));
+    const stepSuites = fallbackStepSuites.filter((stepSuite) => {
+      if (!mapSubstep.waterfallIds?.length) {
+        return (
+          !hasSiblingMaps ||
+          substepFieldBelongsToMap(stepSuite.field, mapSubstep)
+        );
+      }
+      return mapSubstep.waterfallIds.includes(stepSuite.field);
+    });
+    const looseMapSubsteps = substeps.filter((substep) => {
+      if (!isLooseMapExecutionSubstep(substep)) {
+        return false;
+      }
+      return substepFieldBelongsToMap(substep.field, mapSubstep);
+    });
+    const stepSuiteStepsPerChunk = stepSuites.reduce(
+      (max, stepSuite) => Math.max(max, stepSuite.steps.length),
+      0,
+    );
+    const waterfallStepsPerChunk = waterfallStages.reduce(
+      (max, waterfall) => Math.max(max, waterfall.stageIds.length),
+      0,
+    );
+    const directMapStepsPerChunk = maxExecutionSubstepsPerChunk(
+      mapSubstep.steps ?? [],
+    );
+    const stepsPerChunk = Math.max(
+      1,
+      directMapStepsPerChunk,
+      looseMapSubsteps.length,
+      waterfallStepsPerChunk,
+      stepSuiteStepsPerChunk,
+    );
+    const mapExecutionSubsteps = [
+      ...(mapSubstep.steps ?? []),
+      ...looseMapSubsteps,
+      ...stepSuites,
+      ...waterfalls,
+    ];
+    return {
+      mapName: mapSubstep.name ?? mapSubstep.field,
+      tableNamespace: mapSubstep.tableNamespace ?? mapSubstep.field,
+      outputFields: mapSubstep.outputFields ?? [],
+      stepFields: collectPlanMapStepFields(mapExecutionSubsteps),
+      externalStepFields:
+        collectPlanMapExternalStepFields(mapExecutionSubsteps),
+      waterfallStages,
+      defaultChunkSize:
+        stepsPerChunk > 1
+          ? EXECUTION_PLAN_DEFAULTS.complexMapChunkSize
+          : EXECUTION_PLAN_DEFAULTS.largeMapChunkSize,
+      stepsPerChunk,
+    };
+  });
+}
+
+function maxExecutionSubstepsPerChunk(substeps: PlayStaticSubstep[]): number {
+  return substeps.reduce((max, substep) => {
+    if (substep.type === 'step_suite') {
+      return Math.max(max, substep.steps.length);
+    }
+    if (substep.type === 'waterfall') {
+      return Math.max(max, substep.steps?.length ?? 0);
+    }
+    if (substep.type === 'control_flow') {
+      return Math.max(max, maxExecutionSubstepsPerChunk(substep.steps));
+    }
+    return Math.max(max, 1);
+  }, 0);
+}
+
+function isLooseMapExecutionSubstep(
+  substep: PlayStaticSubstep,
+): substep is Extract<
+  PlayStaticSubstep,
+  { type: 'tool' | 'play_call' | 'control_flow' | 'code' }
+> {
+  return (
+    substep.type === 'tool' ||
+    substep.type === 'play_call' ||
+    substep.type === 'control_flow' ||
+    substep.type === 'code'
+  );
+}
+
+function substepFieldBelongsToMap(
+  substepField: string,
+  mapSubstep: Extract<PlayStaticSubstep, { type: 'dataset' }>,
+): boolean {
+  const field = substepField.trim();
+  if (!field) {
+    return false;
+  }
+  const mapFields = [
+    mapSubstep.field,
+    mapSubstep.name,
+    mapSubstep.tableNamespace,
+    ...(mapSubstep.outputFields ?? []),
+  ].filter((candidate): candidate is string => Boolean(candidate?.trim()));
+  return mapFields.some((mapField) => {
+    const normalized = mapField.trim();
+    return field === normalized || field.startsWith(`${normalized}.`);
+  });
+}
+
+function collectPlanMapStepFields(substeps: PlayStaticSubstep[]): string[] {
+  const fields = new Set<string>();
+  for (const substep of flattenStaticSubsteps(substeps)) {
+    if ('field' in substep && typeof substep.field === 'string') {
+      const field = substep.field.trim();
+      if (field) {
+        fields.add(field);
+      }
+    }
+  }
+  return [...fields];
+}
+
+function collectPlanMapExternalStepFields(
+  substeps: PlayStaticSubstep[],
+): string[] {
+  const fields = new Set<string>();
+  for (const substep of flattenStaticSubsteps(substeps)) {
+    if (
+      substep.type !== 'tool' &&
+      substep.type !== 'play_call' &&
+      substep.type !== 'waterfall'
+    ) {
+      continue;
+    }
+    if ('field' in substep && typeof substep.field === 'string') {
+      const field = substep.field.trim();
+      if (field) {
+        fields.add(field);
+      }
+    }
+  }
+  return [...fields];
 }
 
 function extractToolDeclarations(

package/dist/bundling-sources/shared_libs/play-runtime/map-chunk-limits.ts

@@ -0,0 +1 @@
+export const TOOL_CALLING_MAP_CHUNK_SIZE = 25;

package/dist/bundling-sources/shared_libs/play-runtime/runtime-api.ts

@@ -2425,7 +2425,6 @@ async function markRuntimeRowsPendingForRecompute(
             _version = ${nextRuntimeSheetVersionExpression(session)}
         FROM target_rows
       WHERE target._key = target_rows._key
-         AND (target._run_id IS NULL OR target._run_id <= $2::text)
          AND (
            target._status <> 'pending'
            OR target._run_id IS DISTINCT FROM $2::text