deepline 0.3.408 → 0.3.410

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

@@ -1,3 +1,7 @@
+import {
+  DatasetRowInputView,
+  assertDatasetAdmissionHistory,
+} from './dataset-row-input';
 import {
   readRowFailureCounts,
   settledRowFailureKind,
@@ -275,6 +279,7 @@ import { resolveExplicitDurableCallPolicy } from './durable-call-policy';
 import { executeWithFreshnessReceipt } from './freshness-receipt-execution';
 import {
   CtxFetchHttpError,
+  LEGACY_PLAY_AUTHORING_CONTRACT_EDITION,
   PLAY_AUTHORING_CONTRACT_EDITION,
   PlayAuthoringFieldValidationError,
   normalizePlayAuthoringCustomerDbStatement,
@@ -287,6 +292,7 @@ import {
   type PlaySqlQuery,
   type PlayAuthoringRunScope,
   type PlayAuthoringRuntimeContext,
+  type PlayAuthoringRunStepsOptions,
 } from '../plays/authoring-contract';
 import {
   resolvePlayArtifactRuntimeContract,
@@ -681,6 +687,9 @@ const TOOL_RETRY_AFTER_FALLBACK_MS = 1_000;
 export const TOOL_EXECUTE_RESPONSE_BODY_TIMEOUT_MS = 30_000;
 const TOOL_RETRY_HEARTBEAT_INTERVAL_MS = 30_000;
 const TOOL_PROVIDER_RESIDENT_WAIT_BUDGET_MS = 5_000;
+// The call already waited its whole admission budget in this sandbox, so it
+// rejoins the shared lane promptly instead of adding a fixed delay of its own.
+const PROVIDER_ADMISSION_REQUEUE_DELAY_MS = 1_000;
 const AUTHORED_SLEEP_RESIDENT_LIMIT_MS = 10_000;
 const DEEPLINEAGENT_TOOL_RUNTIME_TIMEOUT_MS = 15 * 60 * 1000;
 // Every runtime-API tool fetch needs a client-side deadline. Without one, a
@@ -1316,18 +1325,7 @@ export async function waitForNodeRuntimeMapRowsVisible(input: {
  * __deeplineRowKey and re-derivable output columns — never present on the raw
  * input row — are restored.
  */
-export function persistedFieldsAbsentFromInputRow(
-  inputRow: Record<string, unknown>,
-  persisted: Record<string, unknown>,
-): Record<string, unknown> {
-  const extra: Record<string, unknown> = {};
-  for (const key of Object.keys(persisted)) {
-    if (!Object.prototype.hasOwnProperty.call(inputRow, key)) {
-      extra[key] = persisted[key];
-    }
-  }
-  return extra;
-}
+export { persistedFieldsAbsentFromInputRow } from './dataset-row-input';
 
 export async function reconcileNodeRuntimeMapResultsWithPersistedSheet(input: {
   mapName: string;
@@ -2829,6 +2827,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
   >();
   #options: ContextOptions;
   private readonly rootRuntimeContract: PlayArtifactRuntimeContract;
+  private readonly datasetRowInputs = new DatasetRowInputView();
   private readonly executionScope: RunExecutionScope;
   private readonly logBuffer = new RunLogBuffer();
   private logContextBudgetWarningLogged = false;
@@ -3420,6 +3419,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       resolvePlayArtifactRuntimeContract({
         authoringContractEdition: options.authoringContractEdition,
         slackHitlTimeoutOutcome: options.slackHitlTimeoutOutcome,
+        datasetRowInput: options.datasetRowInput,
         toolResponseContract: options.toolResponseContract,
         toolResponseReceiptRevision: options.toolResponseReceiptRevision,
       });
@@ -7524,6 +7524,12 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     row: Record<string, unknown>,
     fieldName: string,
   ): PreviousCell | undefined {
+    if (this.currentRuntimeContract.datasetRowInput === 'current_run') {
+      const previous = this.datasetRowInputs.previous(row, fieldName);
+      return previous
+        ? { ...previous, value: this.rehydrateCellValue(previous.value) }
+        : undefined;
+    }
     const hasValue =
       Object.prototype.hasOwnProperty.call(row, fieldName) &&
       this.isCompletedFieldValue(row[fieldName]);
@@ -8367,7 +8373,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
   async runSteps<TInput extends Record<string, unknown>, TOutput = unknown>(
     program: RuntimeStepProgram,
     input: TInput,
-    options?: { description?: string },
+    options?: PlayAuthoringRunStepsOptions,
   ): Promise<TOutput> {
     this.assertNoPendingDurableSuspension();
     if (!isRuntimeStepProgram(program)) {
@@ -8380,8 +8386,20 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       );
       this.runtimeLog(options.description);
     }
+    if (
+      this.usesExplicitFreshness &&
+      options?.staleAfterSeconds !== undefined
+    ) {
+      validatePlayAuthoringField(
+        'ctx.runSteps.options.staleAfterSeconds',
+        options.staleAfterSeconds,
+      );
+    }
     return (await this.executeStepProgram(program, input, 0, [], {
       checkpointSteps: true,
+      ...(options?.staleAfterSeconds !== undefined
+        ? { defaultStaleAfterSeconds: options.staleAfterSeconds }
+        : {}),
     })) as TOutput;
   }
 
@@ -8868,6 +8886,15 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             executorToken: this.#options.executorToken,
             staticPipeline: this.currentStaticPipeline,
             forceRefresh: this.#options.cachePolicy?.forceToolRefresh === true,
+            ...(this.currentRuntimeContract.datasetRowInput === 'current_run'
+              ? {
+                  includePreviousCells: true,
+                  previousCellsBudgetBytes: Math.floor(
+                    mapMemoryLimits.materializedBudgetBytes /
+                      NODE_RUNTIME_MAP_MATERIALIZED_MEMORY_MULTIPLIER,
+                  ),
+                }
+              : {}),
             inputOffset: page.offset,
             mode: options?.mode,
             columnTypes: unchangedColumnTypes,
@@ -8876,6 +8903,16 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         resolvedTableNamespace = normalizeTableNamespace(
           mapStartResult.tableNamespace,
         );
+        const previousCellsByKey =
+          this.currentRuntimeContract.datasetRowInput === 'current_run'
+            ? assertDatasetAdmissionHistory(
+                mapStartResult,
+                Math.floor(
+                  mapMemoryLimits.materializedBudgetBytes /
+                    NODE_RUNTIME_MAP_MATERIALIZED_MEMORY_MULTIPLIER,
+                ),
+              )
+            : undefined;
 
         const pendingRowsByKey = new Map<string, Record<string, unknown>>();
         for (
@@ -8900,12 +8937,12 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           const persisted =
             pendingRowsByKey.get(rowKey) ?? completedRowsByKey.get(rowKey);
           return {
-            row: persisted
-              ? cloneCsvAliasedRow(
-                  row,
-                  persistedFieldsAbsentFromInputRow(row, persisted),
-                )
-              : row,
+            row: this.datasetRowInputs.seed(
+              row,
+              persisted,
+              this.currentRuntimeContract.datasetRowInput,
+              previousCellsByKey?.get(rowKey),
+            ),
             index: originalIndex,
           };
         });
@@ -8946,8 +8983,23 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           rows: [],
           rowKeys: [],
           rowIndexes: [],
-          memoryEstimate: pageMemoryEstimate,
+          memoryEstimate:
+            this.currentRuntimeContract.datasetRowInput === 'current_run'
+              ? estimateRuntimeMapRowsMemory(
+                  [...rowsToExecuteByKey.values()].map(({ row }) =>
+                    this.datasetRowInputs.memoryValue(row),
+                  ),
+                )
+              : pageMemoryEstimate,
         };
+        if (prepared.memoryEstimate.estimatedResidentBytes > pageBudgetBytes) {
+          throw new RuntimeMapMemoryLimitError({
+            mapName: normalizedMapNamespace,
+            phase: 'materialize',
+            estimate: prepared.memoryEstimate,
+            budgetBytes: pageBudgetBytes,
+          });
+        }
         for (const [rowKey, entry] of rowsToExecuteByKey) {
           prepared.rows.push(entry.row);
           prepared.rowKeys.push(rowKey);
@@ -9789,6 +9841,15 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           executorToken: this.#options.executorToken,
           staticPipeline: this.currentStaticPipeline,
           forceRefresh: this.#options.cachePolicy?.forceToolRefresh === true,
+          ...(this.currentRuntimeContract.datasetRowInput === 'current_run'
+            ? {
+                includePreviousCells: true,
+                previousCellsBudgetBytes: Math.floor(
+                  mapMemoryLimits.materializedBudgetBytes /
+                    NODE_RUNTIME_MAP_MATERIALIZED_MEMORY_MULTIPLIER,
+                ),
+              }
+            : {}),
           mode: options?.mode,
           columnTypes: unchangedColumnTypes,
         },
@@ -9796,6 +9857,16 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       resolvedTableNamespace = normalizeTableNamespace(
         mapStartResult.tableNamespace,
       );
+      const previousCellsByKey =
+        this.currentRuntimeContract.datasetRowInput === 'current_run'
+          ? assertDatasetAdmissionHistory(
+              mapStartResult,
+              Math.floor(
+                mapMemoryLimits.materializedBudgetBytes /
+                  NODE_RUNTIME_MAP_MATERIALIZED_MEMORY_MULTIPLIER,
+              ),
+            )
+          : undefined;
       const persistedRowIdentity = (row: Record<string, unknown>, index = 0) =>
         resolveMapRowOutcomeKey(row) ?? rowIdentity(row, index);
       const pendingRowsByKey = new Map<string, Record<string, unknown>>();
@@ -9825,25 +9896,13 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           const rowKey = seedRowIdentity(row, index);
           const persisted =
             pendingRowsByKey.get(rowKey) ?? mapStartSeedRowsByKey.get(rowKey);
-          // Restore persisted OUTPUT columns, cell meta, and the carried
-          // __deeplineRowKey so key functions and column resolvers keep seeing
-          // projected values/aliases across the sheet round-trip. But the
-          // CURRENT run's INPUT columns are authoritative and must win: a
-          // persisted row is matched only by the map key, so for a play whose
-          // key does not capture every input column it can be a DIFFERENT run's
-          // row that merely shares that key. Letting its stale input columns
-          // overwrite this run's inputs corrupts input-derived tool arguments
-          // (e.g. scenario 87 vs 78 collide on key `id`='target' but pass
-          // distinct `key` columns to the probe tool, flipping a terminal
-          // failure into a spurious success). Merge only persisted fields
-          // absent from the fresh input row.
           return {
-            row: persisted
-              ? cloneCsvAliasedRow(
-                  row,
-                  persistedFieldsAbsentFromInputRow(row, persisted),
-                )
-              : row,
+            row: this.datasetRowInputs.seed(
+              row,
+              persisted,
+              this.currentRuntimeContract.datasetRowInput,
+              previousCellsByKey?.get(rowKey),
+            ),
             index,
             // `index` already names the authored input, not a position in
             // the pending subset. Looking it up again aliases resumed rows.
@@ -9858,6 +9917,22 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           : seededItems;
       rawItems = admittedItems.map((item) => item.row);
       itemsToProcess = admittedItems.map((item) => item.row);
+      if (this.currentRuntimeContract.datasetRowInput === 'current_run') {
+        const estimate = estimateRuntimeMapRowsMemory(
+          rawItems.map((row) => this.datasetRowInputs.memoryValue(row)),
+        );
+        if (
+          estimate.estimatedResidentBytes >
+          mapMemoryLimits.materializedBudgetBytes
+        ) {
+          throw new RuntimeMapMemoryLimitError({
+            mapName: normalizedMapNamespace,
+            phase: 'materialize',
+            estimate,
+            budgetBytes: mapMemoryLimits.materializedBudgetBytes,
+          });
+        }
+      }
       itemOriginalIndexes = admittedItems.map((item) => item.originalIndex);
       totalInputCount = resumedPendingRowsOnly
         ? Math.max(replayMapFrame?.totalRows ?? 0, admittedItems.length)
@@ -10768,7 +10843,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           name: 'run-row',
           acquire: async ({ baseRow }) =>
             await this.resourceGovernor.acquireRow({
-              estimatedBytes: runtimeMapJsonByteLength(baseRow),
+              estimatedBytes: runtimeMapJsonByteLength(
+                this.datasetRowInputs.memoryValue(baseRow),
+              ),
             }),
         },
       ],
@@ -11309,6 +11386,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         Math.max(0, TOOL_PROVIDER_RESIDENT_WAIT_BUDGET_MS - elapsedMs)
       );
     };
+    const activeRowHistories = new Map<number, Record<string, unknown>>();
     const workers = Array.from({ length: workerCount }, async () => {
       while (firstRowError == null) {
         // A short provider hold must not leave this row behind the entire
@@ -11354,6 +11432,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           continue;
         }
         const idx = providerRetry?.rowIndex ?? nextRowIndex++;
+        let historyRow: Record<string, unknown> | undefined;
         if (!providerRetry) rowFeed?.markDispatched();
         try {
           const waitingRow = providerRetry
@@ -11367,6 +11446,11 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
               `Provider retry row ${idx} lost its resumable input.`,
             );
           }
+          historyRow = baseRow;
+          if (this.currentRuntimeContract.datasetRowInput === 'current_run') {
+            activeRowHistories.set(idx, baseRow);
+            this.datasetRowInputs.retain(baseRow, this.memoryLedger);
+          }
           if (providerRetry) waitingBaseRows.delete(idx);
           else releaseDispatchedInputRow?.(idx);
           const callIndexes =
@@ -11395,6 +11479,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             }
             rowFeed?.wakeWorkersAt(nextProviderRetry(true)!.readyAtMs);
           } else if (settledResults[idx] !== WAITING_ROW) {
+            this.datasetRowInputs.release(baseRow);
             providerIdleWaitStartedAt = null;
           }
           if (mapProgress.activeResolvers === 0) retryWakeFeed.wakeWorkers();
@@ -11407,6 +11492,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           heapAdmission.close(firstRowError);
           retryWakeFeed.fail(firstRowError);
           throw error;
+        } finally {
+          activeRowHistories.delete(idx);
+          if (historyRow && !waitingBaseRows.has(idx))
+            this.datasetRowInputs.release(historyRow);
         }
       }
     });
@@ -11504,6 +11593,15 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       // The retained rows leave this map with the caller; from here they are
       // no longer bytes this runtime is holding on the caller's behalf.
       materializedRows.bytes?.release();
+      for (const item of items) {
+        if (item && typeof item === 'object')
+          this.datasetRowInputs.release(item);
+      }
+      for (const { baseRow } of waitingBaseRows.values())
+        this.datasetRowInputs.release(baseRow);
+      for (const baseRow of activeRowHistories.values())
+        this.datasetRowInputs.release(baseRow);
+      activeRowHistories.clear();
       const heapSnapshot = heapAdmission.close();
       this.resourceGovernor.recordMapAdmission(
         normalizedTableNamespace,
@@ -11805,7 +11903,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     row: Record<string, unknown>,
     index: number,
     path: string[],
-    options?: { checkpointSteps?: boolean },
+    options?: {
+      checkpointSteps?: boolean;
+      defaultStaleAfterSeconds?: number | null;
+    },
   ): Promise<unknown> {
     let currentRow = cloneCsvAliasedRow(row);
     const produced: Record<string, unknown> = {};
@@ -11846,6 +11947,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                   stepPath,
                   undefined,
                   stageExecution,
+                  options,
                 ),
               {
                 semanticKey: stableDigest(
@@ -11857,7 +11959,11 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 ),
                 ...(step.staleAfterSeconds !== undefined
                   ? { staleAfterSeconds: step.staleAfterSeconds }
-                  : {}),
+                  : options?.defaultStaleAfterSeconds !== undefined
+                    ? {
+                        staleAfterSeconds: options.defaultStaleAfterSeconds,
+                      }
+                    : {}),
               },
             )
           : await this.executeStepProgramStep(
@@ -11999,6 +12105,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     path: string[],
     previousCell?: PreviousCell,
     stageExecution?: { skipped: boolean },
+    options?: { defaultStaleAfterSeconds?: number | null },
   ): Promise<unknown> {
     const resolver = step.resolver;
     const store = rowContext.getStore();
@@ -12017,7 +12124,13 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     if (isRuntimeStepProgram(resolver)) {
       return await runWithStepScope(
         async () =>
-          await this.executeStepProgram(resolver, currentRow, index, path),
+          await this.executeStepProgram(resolver, currentRow, index, path, {
+            ...(options?.defaultStaleAfterSeconds !== undefined
+              ? {
+                  defaultStaleAfterSeconds: options.defaultStaleAfterSeconds,
+                }
+              : {}),
+          }),
       );
     }
 
@@ -12253,6 +12366,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     } finally {
       this.pulseProgressHeartbeat(true);
       this.pureMapExecutionActive = false;
+      for (const item of items) {
+        if (item && typeof item === 'object')
+          this.datasetRowInputs.release(item);
+      }
     }
 
     return results;
@@ -12935,9 +13052,12 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
 
   private toOutputRow<T>(item: T): Record<string, unknown> {
     if (item != null && typeof item === 'object' && !Array.isArray(item)) {
-      return copyPlayDatasetSourceRowIdentity(
+      return this.datasetRowInputs.copy(
         item,
-        stripCsvProjectionMetadata(item as Record<string, unknown>),
+        copyPlayDatasetSourceRowIdentity(
+          item,
+          stripCsvProjectionMetadata(item as Record<string, unknown>),
+        ),
       );
     }
 
@@ -13218,8 +13338,6 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       input,
       authScope,
       actionVersion,
-      responseContract: this.currentToolResponseContract,
-      responseRevision: this.currentToolResponseReceiptRevision,
     });
     if (sqlTool && input.operation_key !== undefined) {
       throw new Error(
@@ -13278,7 +13396,8 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           key,
           toolId,
           requestInput,
-          { ...options, force: true, staleAfterSeconds: 0 },
+          { ...options },
+          true,
         );
         if ((await this.resolveToolAuthScopeDigest(toolId)) !== authScope) {
           throw new Error(
@@ -13287,17 +13406,47 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         }
         return value;
       },
-      onOutcome: (value, freshness) =>
-        isToolExecuteResult(value)
-          ? cloneToolExecuteResultWithExecution(value, {
-              ...value._metadata.execution,
-              cached: freshness.source !== 'executed',
-              source: freshness.source === 'executed' ? 'live' : 'cache',
-              resultReceiptKey: freshness.operationReceiptKey,
-              freshness,
-              completedAt: freshness.completedAt,
-            })
-          : value,
+      onOutcome: (value, freshness) => {
+        if (!isToolExecuteResult(value)) return value;
+        if (freshness.source !== 'executed') {
+          const row = rowContext.getStore();
+          if (row?.fieldName && row.tableNamespace && row.rowKey) {
+            this.emitScopedFieldMetaUpdate({
+              rowId: row.rowId,
+              key: row.rowKey,
+              tableNamespace: row.tableNamespace,
+              fieldName: row.fieldName,
+              status: 'cached',
+              rowStatus: 'running',
+              stage: toolId,
+              provider: null,
+              error: null,
+              reused: true,
+              dataPatch: {},
+            });
+          }
+        }
+        const resultReceiptKey =
+          value._metadata.execution.resultReceiptKey ??
+          value._metadata.execution.receiptKey ??
+          freshness.operationReceiptKey;
+        return this.materializeToolExecutionResult(
+          cloneToolExecuteResultWithExecution(value, {
+            ...value._metadata.execution,
+            cached: freshness.source !== 'executed',
+            source: freshness.source === 'executed' ? 'live' : 'cache',
+            ...(freshness.source !== 'executed'
+              ? {
+                  receiptRole: 'follower' as const,
+                  attachedToReceiptKey: resultReceiptKey,
+                }
+              : {}),
+            ...(resultReceiptKey ? { resultReceiptKey } : {}),
+            freshness,
+            completedAt: freshness.completedAt,
+          }),
+        );
+      },
     });
   }
 
@@ -13306,6 +13455,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     toolId: string,
     input: Record<string, unknown>,
     options?: ToolCallOptions,
+    deferResponseMaterialization = false,
   ): Promise<unknown> {
     if (!rowContext.getStore()) this.assertRowAdmissionOpen();
     this.assertNoPendingDurableSuspension();
@@ -13337,6 +13487,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       );
     }
     const normalizedKey = this.normalizeContextKey(key, 'tool');
+    const presentResult = (result: unknown): unknown =>
+      isToolExecuteResult(result) && !deferResponseMaterialization
+        ? this.materializeToolExecutionResult(result)
+        : result;
     const toolCachePolicy = this.effectiveToolCallCachePolicy(options);
     const toolRequestIdentity = deriveToolRequestIdentity({
       toolId,
@@ -13449,9 +13603,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           explicitForce,
           logicalCallId,
         );
-        return isToolExecuteResult(result)
-          ? this.materializeToolExecutionResult(result)
-          : result;
+        return presentResult(result);
       }
       if (toolId === 'run_javascript') {
         throw new Error(DISALLOWED_RUN_JAVASCRIPT_TOOL_MESSAGE);
@@ -13472,7 +13624,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             outcome: 'cached',
             durationMs: 0,
           });
-          return this.materializeToolExecutionResult(sourceRunRecovered);
+          return presentResult(sourceRunRecovered);
         }
       }
       // callToolExecutionAPI charges the tool-call budget before first provider
@@ -13527,7 +13679,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
               outcome: 'cached',
               durationMs: 0,
             });
-            return this.materializeToolExecutionResult(recovered);
+            return presentResult(recovered);
           } finally {
             if (!settled) {
               this.emitToolCallLifecycle('settled', toolId, normalizedKey, {
@@ -13578,9 +13730,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 this.runtimeLog(
                   `Calling tool: ${toolId} recovered from an explicit action compatibility receipt`,
                 );
-                return isToolExecuteResult(recoveredCompatible)
-                  ? this.materializeToolExecutionResult(recoveredCompatible)
-                  : recoveredCompatible;
+                return presentResult(recoveredCompatible);
               }
             }
           }
@@ -13629,9 +13779,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 cacheKey: directCacheKey,
               }),
             );
-            return isToolExecuteResult(recoveredHistorical)
-              ? this.materializeToolExecutionResult(recoveredHistorical)
-              : recoveredHistorical;
+            return presentResult(recoveredHistorical);
           }
           if (
             (!historicalReceipt || !historicalCanServeCurrentContract) &&
@@ -13666,9 +13814,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                   recoveredLegacy,
                 )
               ) {
-                return isToolExecuteResult(recoveredLegacy)
-                  ? this.materializeToolExecutionResult(recoveredLegacy)
-                  : recoveredLegacy;
+                return presentResult(recoveredLegacy);
               }
               bypassDirectResultCache = true;
             }
@@ -13930,7 +14076,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
             );
             this.#options.onBatchComplete?.(this.checkpoint);
           }
-          return this.materializeToolExecutionResult(wrapped);
+          return presentResult(wrapped);
         } catch (error) {
           if (isControlledPlaySuspension(error)) {
             // A durable pause is not a terminal tool failure. Leave the start
@@ -13959,7 +14105,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
           : this.getCachedToolResultCandidate(toolId, checkpointCacheKeys);
       if (cached) {
         this.runtimeLog(`  Row ${rowId} ${toolId}: recovered from checkpoint`);
-        return this.materializeToolExecutionResult(
+        return presentResult(
           await this.wrapToolExecutionResult({
             toolId,
             status: cached.result.result == null ? 'no_result' : 'completed',
@@ -14375,6 +14521,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         toolId,
         status: 'completed',
         result: existing.output,
+        toolResponse: { rawV2: existing.output, view: 'rawV2' },
         execution: toolExecutionMetadataForOutcome({
           kind: 'checkpoint',
           cacheKey: `integration_event:${preparedBoundary.boundaryId}`,
@@ -14450,6 +14597,10 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
         toolId,
         status: 'completed',
         result: boundary.resolvedOutput,
+        toolResponse: {
+          rawV2: boundary.resolvedOutput,
+          view: 'rawV2',
+        },
         execution: toolExecutionMetadataForOutcome({
           kind: 'checkpoint',
           cacheKey: `integration_event:${boundary.boundaryId}`,
@@ -14590,13 +14741,16 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     const childCompatibilitySnapshot =
       resolvedPlay.contractSnapshot?.compatibility ??
       resolvedPlay.artifact?.compatibility ??
-      buildPlayContractCompatibility();
+      buildPlayContractCompatibility({
+        authoringContractEdition: LEGACY_PLAY_AUTHORING_CONTRACT_EDITION,
+      });
     const childCompatibility = normalizePlayContractCompatibility(
       childCompatibilitySnapshot,
     );
     const childRuntimeContract = resolvePlayArtifactRuntimeContract({
       authoringContractEdition: childCompatibility.authoringContractEdition,
       slackHitlTimeoutOutcome: childCompatibility.slackHitlTimeoutOutcome,
+      datasetRowInput: childCompatibility.datasetRowInput,
       toolResponseContract: childCompatibility.toolResponseContract,
       toolResponseReceiptRevision:
         childCompatibility.toolResponseReceiptRevision,
@@ -15694,6 +15848,8 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
               timeouts: this.#options.ctxFetchTimeouts,
               fetchImpl: this.#options.fetchImpl,
               log: (message) => this.runtimeLog(message),
+              reportAmbiguousWrite:
+                this.usesExplicitFreshness && !reusableReadMethod,
             });
             const rawJson = parseJsonOrNull(bodyText);
             const output: PlayFetchResponse =
@@ -15766,6 +15922,7 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     options?: RuntimeStepOptions,
   ): Promise<T> {
     if (!rowContext.getStore()) this.assertRowAdmissionOpen();
+    this.assertNoPendingDurableSuspension();
     validatePlayAuthoringField('ctx.step.id', key);
     validateOptionalPlayAuthoringField(
       'ctx.step.semanticKey',
@@ -18477,6 +18634,11 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
     const providerNoProgressScope = stableDigest(
       `${provider}\u0000${executionAuthScopeDigest ?? ''}`,
     );
+    // Starvation in Deepline's own admission queue is tracked apart from
+    // provider holds so it never settles as a provider no-progress 429.
+    const providerAdmissionNoProgressScope = stableDigest(
+      `admission\u0000${providerNoProgressScope}`,
+    );
     const providerNoProgressError = (retryAtMs: number) =>
       createToolHttpError(
         toolErrorSchemaVersion,
@@ -20040,7 +20202,43 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 throw heartbeatFailure;
               }
               if (error instanceof ProviderAdmissionWaitTimeoutError) {
-                throw providerAdmissionTimeoutError(error);
+                if (!this.#options.durableBoundaries) {
+                  throw providerAdmissionTimeoutError(error);
+                }
+                // A full shared lane is a queue, not a failure: other runs
+                // hold its permits and nothing was sent. Re-queue durably
+                // behind them. Only a lane that grants this call nothing for
+                // the no-progress window settles, as a Deepline admission
+                // timeout rather than a provider 429.
+                const retryAtMs =
+                  Date.now() + PROVIDER_ADMISSION_REQUEUE_DELAY_MS;
+                if (
+                  observeProviderNoProgress({
+                    startedAtMsByScope:
+                      (this.checkpoint.providerNoProgressStartedAtMsByScope ??=
+                        {}),
+                    scope: providerAdmissionNoProgressScope,
+                    retryAtMs,
+                    nowMs: Date.now(),
+                  }).exhausted
+                ) {
+                  throw providerAdmissionTimeoutError(error);
+                }
+                if (
+                  options?.providerBackpressureMapRows ||
+                  rowContext.getStore()
+                ) {
+                  throw new PlayRowProviderBackpressureError(
+                    error.provider,
+                    retryAtMs,
+                    markProviderResidentWaitBudgetExhausted(),
+                  );
+                }
+                await this.waitForProviderBackpressure(
+                  error.provider,
+                  retryAtMs,
+                );
+                continue;
               }
               if (error instanceof ProviderExhaustedError) {
                 const retryAtMs = Date.parse(error.retryAt);
@@ -20666,6 +20864,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
               delete this.checkpoint.providerNoProgressStartedAtMsByScope[
                 providerNoProgressScope
               ];
+              delete this.checkpoint.providerNoProgressStartedAtMsByScope[
+                providerAdmissionNoProgressScope
+              ];
             }
             return receiptOutputRef
               ? { ...resolved, receiptOutputRef }