deepline 0.1.161 → 0.1.163

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

@@ -169,6 +169,7 @@ import {
 // re-bundle harness internals into per-play. Keep that in mind.
 import {
   harnessPersistCompletedSheetRows,
+  harnessReadSheetDatasetRowKeys,
   harnessReadSheetDatasetRows,
   harnessReadStagedFileChunk,
   harnessStartSheetDataset,
@@ -183,7 +184,6 @@ import {
 import { collectStableResultDatasetPersistenceContract } from './runtime/result-dataset-persistence';
 import {
   runtimeCsvExecutionRow,
-  publicCsvInputRow,
   publicCsvOutputRow,
   publicCsvStorageRow,
   runtimeCsvStorageRow,
@@ -191,6 +191,7 @@ import {
 import {
   completedMapRowOutcome,
   failedMapRowOutcome,
+  MAP_ROW_OUTCOME_RUNTIME_FIELDS,
   mapRowOutcomeRuntimeRow,
   mapRowOutcomeRuntimeFields,
   resolveMapRowOutcomeKey,
@@ -201,6 +202,7 @@ import { chooseWorkerMapRowsPerChunk } from './runtime/map-chunk-plan';
 import {
   applyCsvRenameProjection,
   cloneCsvAliasedRow,
+  toSerializableCsvAliasedRow,
   type CsvRenameOptions,
 } from '../../../shared_libs/play-runtime/csv-rename';
 import { coordinatorRequestHeaders } from '../../../shared_libs/play-runtime/coordinator-headers';
@@ -1515,6 +1517,7 @@ type RecordedStepProgramOutput = {
   columnName: string;
   stepId: string;
   value: unknown;
+  durationMs: number;
   status?: 'skipped';
 };
 
@@ -2536,6 +2539,8 @@ type WorkerMapChunkSummary<T extends Record<string, unknown>> = {
   rowsFailed: number;
   /** Bounded sample of row failures for the partial-failure summary. */
   rowFailureSamples: Array<{ rowKey: string; error: string }>;
+  stepCellsCompleted: number;
+  stepCellsSkipped: number;
   outputDatasetId: string;
   hash: string;
   preview: T[];
@@ -2763,7 +2768,9 @@ async function executeWorkerStepProgram(
             ) => Promise<WorkerStepResolution>
           )(stepId, runStep)
         : await runStep();
+    const stepStartedAt = nowMs();
     const resolution = await executeStep();
+    const durationMs = nowMs() - stepStartedAt;
     const value = deserializeDurableStepValue(resolution.value);
     currentRow = cloneCsvAliasedRow(currentRow, { [step.name]: value });
     if (recorder) {
@@ -2772,6 +2779,7 @@ async function executeWorkerStepProgram(
         columnName: stepProgramColumnName(recorder.parentField, stepId),
         stepId,
         value,
+        durationMs,
         ...(resolution.status ? { status: resolution.status } : {}),
       };
       recorder.outputs.push(output);
@@ -3581,32 +3589,115 @@ async function persistCompletedMapRows(input: {
   rows: Record<string, unknown>[];
   outputFields: string[];
   extraOutputFields?: string[];
-}): Promise<void> {
-  if (input.rows.length === 0) return;
+}): Promise<{
+  rows: number;
+  written: number;
+  visible: number;
+  retryWritten: number | null;
+  retryVisible: number | null;
+}> {
+  if (input.rows.length === 0) {
+    return {
+      rows: 0,
+      written: 0,
+      visible: 0,
+      retryWritten: null,
+      retryVisible: null,
+    };
+  }
+  const { req, tableNamespace } = input;
   const outputFields = [
     ...input.outputFields,
     ...(input.extraOutputFields ?? []).filter(
       (field) => !input.outputFields.includes(field),
     ),
   ];
-  const sessionScope = runtimeSheetSessionScope(input.req);
+  const sessionScope = runtimeSheetSessionScope(req);
   const rows = input.rows.map((row) => publicCsvStorageRow(row));
-  const result = await harnessPersistCompletedSheetRows({
-    ...sessionScope,
-    tableNamespace: input.tableNamespace,
-    sheetContract: augmentSheetContractWithDatasetFields({
-      contract: requireSheetContract(input.req, input.tableNamespace),
-      rows,
-      outputFields,
-    }),
+  const sheetContract = augmentSheetContractWithDatasetFields({
+    contract: requireSheetContract(req, tableNamespace),
     rows,
     outputFields,
   });
+  const persistRequest = {
+    ...sessionScope,
+    tableNamespace,
+    sheetContract,
+    rows,
+    outputFields,
+  };
+  const expectedKeys = [
+    ...new Set(
+      input.rows
+        .map((row) => resolveMapRowOutcomeKey(row))
+        .filter((key): key is string => Boolean(key)),
+    ),
+  ];
+  const readVisibleRowCount = async () => {
+    if (expectedKeys.length > 0) {
+      const result = await harnessReadSheetDatasetRowKeys({
+        ...sessionScope,
+        tableNamespace,
+        runId: req.runId,
+        rowMode: 'all',
+        keys: expectedKeys,
+      });
+      return result.keys.length;
+    }
+    const result = await harnessReadSheetDatasetRows({
+      ...sessionScope,
+      tableNamespace,
+      runId: req.runId,
+      rowMode: 'all',
+      limit: rows.length,
+      offset: 0,
+    });
+    return result.rows.length;
+  };
+  const result = await harnessPersistCompletedSheetRows(persistRequest);
+  let visibleRows = -1;
+  let retryWritten: number | null = null;
+  let retryVisible: number | null = null;
+  if (rows.length <= MAP_INCREMENTAL_PERSIST_CHUNK_ROWS) {
+    visibleRows = await readVisibleRowCount();
+    if (visibleRows < rows.length) {
+      await harnessStartSheetDataset({
+        ...sessionScope,
+        tableNamespace,
+        sheetContract,
+        rows: input.rows.map((row) => runtimeCsvStorageRow(row)),
+        runId: req.runId,
+        inputOffset: 0,
+      });
+      const retry = await harnessPersistCompletedSheetRows(persistRequest);
+      retryWritten = retry.rowsWritten;
+      retryVisible = await readVisibleRowCount();
+      if (retryVisible >= rows.length) {
+        return {
+          rows: rows.length,
+          written: result.rowsWritten,
+          visible: visibleRows,
+          retryWritten,
+          retryVisible,
+        };
+      }
+      throw new Error(
+        `Runtime sheet persistence mismatch for ${tableNamespace}: wrote ${result.rowsWritten}/${rows.length}; visible ${visibleRows}; retry wrote ${retryWritten}/${rows.length}; retry visible ${retryVisible}; run ${req.runId}.`,
+      );
+    }
+  }
   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}.`,
+      `Runtime sheet persistence mismatch for ${tableNamespace}: wrote ${result.rowsWritten}/${rows.length}; run ${req.runId}.`,
     );
   }
+  return {
+    rows: rows.length,
+    written: result.rowsWritten,
+    visible: visibleRows,
+    retryWritten,
+    retryVisible,
+  };
 }
 
 async function applyLiveMapRowUpdates(input: {
@@ -4270,13 +4361,50 @@ function createMinimalWorkerCtx(
       startedAt: mapStartedAt,
       message: formatMapPreparingMessage(rowCountHint ?? undefined),
     });
+    const stableMapInputRow = (row: Record<string, unknown>) => {
+      const stableRow = toSerializableCsvAliasedRow(row);
+      for (const fieldName of outputFields) {
+        delete stableRow[fieldName];
+      }
+      return stableRow;
+    };
+    const stableDefaultMapIdentityRow = (
+      row: Record<string, unknown>,
+      index: number,
+      chunkIndex?: number,
+      chunkLocalIndex?: number,
+    ) => ({
+      __deeplineMapRunId: req.runId,
+      ...stableMapInputRow(row),
+      __deeplineMapInputIndex: index,
+      ...(chunkIndex === undefined ? {} : { ci: chunkIndex }),
+      ...(chunkLocalIndex === undefined ? {} : { li: chunkLocalIndex }),
+    });
+    const resolveRuntimeInputIndex = (
+      row: Record<string, unknown>,
+    ): number | null => {
+      const value = row[MAP_ROW_OUTCOME_RUNTIME_FIELDS.inputIndex];
+      return typeof value === 'number' && Number.isFinite(value)
+        ? value
+        : null;
+    };
+    const deriveDefaultMapRowIdentity = (
+      row: Record<string, unknown>,
+      index: number,
+      chunkIndex?: number,
+      chunkLocalIndex?: number,
+    ) =>
+      derivePlayRowIdentity(
+        stableDefaultMapIdentityRow(row, index, chunkIndex, chunkLocalIndex),
+        name,
+      );
     const explicitRowKeysSeen =
       opts?.key === undefined ? null : new Map<string, number>();
     const resolveExplicitKeyValue = (
       row: Record<string, unknown>,
       index: number,
     ): string | null => {
-      const inputRow = publicCsvInputRow(row);
+      const inputRow = stableMapInputRow(row);
       const keyOption = opts?.key;
       if (keyOption === undefined) {
         return null;
@@ -4315,11 +4443,17 @@ function createMinimalWorkerCtx(
     const resolveRowKey = (
       row: Record<string, unknown>,
       index: number,
+      chunkIndex?: number,
+      chunkLocalIndex?: number,
     ): string => {
-      const inputRow = publicCsvInputRow(row);
       const explicitKeyValue = resolveExplicitKeyValue(row, index);
       return explicitKeyValue == null
-        ? derivePlayRowIdentity(inputRow, name)
+        ? deriveDefaultMapRowIdentity(
+            row,
+            index,
+            chunkIndex,
+            chunkLocalIndex,
+          )
         : derivePlayRowIdentityFromKey(explicitKeyValue, name);
     };
     // Cross-chunk dedupe accumulators for the single end-of-map log line.
@@ -4387,7 +4521,12 @@ function createMinimalWorkerCtx(
       const keyStartedAt = nowMs();
       const chunkEntries = chunkRows.map((row, localIndex) => {
         const absoluteIndex = baseOffset + chunkStart + localIndex;
-        const rowKey = resolveRowKey(row, absoluteIndex);
+        const rowKey = resolveRowKey(
+          row,
+          absoluteIndex,
+          chunkIndex,
+          localIndex,
+        );
         return { row, absoluteIndex, rowKey };
       });
       recordRunnerPerfTrace({
@@ -4443,7 +4582,7 @@ function createMinimalWorkerCtx(
       for (const row of prepared.pendingRows) {
         const key =
           resolveMapRowOutcomeKey(row) ??
-          derivePlayRowIdentity(publicCsvInputRow(row), name);
+          deriveDefaultMapRowIdentity(row, resolveRuntimeInputIndex(row) ?? 0);
         if (key) {
           pendingKeys.add(key);
           pendingRowsByKey.set(key, row);
@@ -4453,7 +4592,7 @@ function createMinimalWorkerCtx(
       for (const row of prepared.completedRows) {
         const key =
           resolveMapRowOutcomeKey(row) ??
-          derivePlayRowIdentity(publicCsvInputRow(row), name);
+          deriveDefaultMapRowIdentity(row, resolveRuntimeInputIndex(row) ?? 0);
         if (key) {
           completedKeys.add(key);
           preparedKeys.add(key);
@@ -4592,6 +4731,8 @@ function createMinimalWorkerCtx(
         receiptStore,
         false,
       );
+      let stepCellsCompleted = 0;
+      let stepCellsSkipped = 0;
       const generatedOutputFields = new Set<string>();
       const pendingLiveRowUpdates: Array<
         Omit<PlayRowUpdate, 'rowId'> & { runId?: string }
@@ -4663,7 +4804,7 @@ function createMinimalWorkerCtx(
         if (rowsToPersist.length === 0 && failedRowsToPersist.length === 0) {
           return;
         }
-        await persistCompletedMapRows({
+        const persistStats = await persistCompletedMapRows({
           req,
           tableNamespace: name,
           outputFields,
@@ -4673,6 +4814,8 @@ function createMinimalWorkerCtx(
               mapRowOutcomeRuntimeRow(
                 completedMapRowOutcome({
                   key: uniqueRowsToExecuteEntries[executedIndex]!.rowKey,
+                  inputIndex:
+                    uniqueRowsToExecuteEntries[executedIndex]!.absoluteIndex,
                   data: row,
                   cellMetaPatch: executedCellMetaPatches[executedIndex],
                 }),
@@ -4684,6 +4827,8 @@ function createMinimalWorkerCtx(
               mapRowOutcomeRuntimeRow(
                 failedMapRowOutcome({
                   key: uniqueRowsToExecuteEntries[executedIndex]!.rowKey,
+                  inputIndex:
+                    uniqueRowsToExecuteEntries[executedIndex]!.absoluteIndex,
                   data: failure.row,
                   cellMetaPatch: executedCellMetaPatches[executedIndex],
                   error: failure.error,
@@ -4692,6 +4837,23 @@ function createMinimalWorkerCtx(
             ),
           ],
         });
+        if (persistStats.rows > 0) {
+          emitEvent({
+            type: 'log',
+            level: 'info',
+            message:
+              `Runtime sheet persisted ${persistStats.rows} rows for ctx.dataset("${name}") ` +
+              `(written=${persistStats.written}, visible=${persistStats.visible}` +
+              (persistStats.retryWritten === null
+                ? ''
+                : `, retryWritten=${persistStats.retryWritten}`) +
+              (persistStats.retryVisible === null
+                ? ''
+                : `, retryVisible=${persistStats.retryVisible}`) +
+              ')',
+            ts: nowMs(),
+          });
+        }
         for (const { executedIndex } of rowsToPersist) {
           persistedExecutedIndexes.add(executedIndex);
         }
@@ -4881,6 +5043,8 @@ function createMinimalWorkerCtx(
                             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,
                                 tableNamespace: name,
@@ -5096,7 +5260,10 @@ function createMinimalWorkerCtx(
       for (const completedRow of prepared.completedRows) {
         const key =
           resolveMapRowOutcomeKey(completedRow) ??
-          derivePlayRowIdentity(publicCsvInputRow(completedRow), name);
+          deriveDefaultMapRowIdentity(
+            completedRow,
+            resolveRuntimeInputIndex(completedRow) ?? 0,
+          );
         if (key) {
           const cleanedRow = stripMapRowOutcomeRuntimeFields(
             publicCsvOutputRow(completedRow),
@@ -5115,12 +5282,28 @@ function createMinimalWorkerCtx(
         // dataset (their recoverable state lives in the runtime sheet).
         if (key && executedRow) resultByKey.set(key, executedRow);
       }
-      const out = chunkRows
+      const outEntries = chunkRows
         .map((_row, index) => {
-          const key = chunkEntries[index]!.rowKey;
-          return resultByKey.get(key);
+          const entry = chunkEntries[index]!;
+          const row = resultByKey.get(entry.rowKey);
+          return row
+            ? {
+                key: entry.rowKey,
+                inputIndex: entry.absoluteIndex,
+                row,
+              }
+            : null;
         })
-        .filter((row): row is T & Record<string, unknown> => Boolean(row));
+        .filter(
+          (
+            entry,
+          ): entry is {
+            key: string;
+            inputIndex: number;
+            row: T & Record<string, unknown>;
+          } => entry !== null,
+        );
+      const out = outEntries.map((entry) => entry.row);
       const executedSuccessCount = Math.max(
         0,
         executedRows.length - failedExecutedRows,
@@ -5140,6 +5323,10 @@ function createMinimalWorkerCtx(
         )
         .slice(0, MAP_ROW_FAILURE_SAMPLE_LIMIT);
       const publicOut = out.map((row) => publicCsvOutputRow(row));
+      const keyedOut = outEntries.map(({ key, inputIndex, row }) => ({
+        ...row,
+        ...mapRowOutcomeRuntimeFields({ key, inputIndex }),
+      }));
       const hashStartedAt = nowMs();
       const hash = await hashJson(publicOut);
       const includeCachedRowsInChunkResult = !workflowStep;
@@ -5150,7 +5337,7 @@ function createMinimalWorkerCtx(
       ) {
         volatileWorkflowChunkRows.set(
           chunkIndex,
-          serializeDurableStepValue(out),
+          serializeDurableStepValue(keyedOut),
         );
       }
       recordRunnerPerfTrace({
@@ -5186,6 +5373,8 @@ function createMinimalWorkerCtx(
         rowsSkipped,
         rowsFailed: failedExecutedRows,
         rowFailureSamples,
+        stepCellsCompleted,
+        stepCellsSkipped,
         outputDatasetId: `map:${name}`,
         hash,
         // Runtime Sheet owns the full row payloads. Native Workflow step
@@ -5196,7 +5385,7 @@ function createMinimalWorkerCtx(
         cachedRows:
           includeCachedRowsInChunkResult &&
           out.length <= WORKER_DATASET_IN_MEMORY_ROWS
-            ? serializeDurableStepValue(out)
+            ? serializeDurableStepValue(keyedOut)
             : undefined,
       };
     };
@@ -5210,6 +5399,8 @@ function createMinimalWorkerCtx(
     let totalRowsInserted = 0;
     let totalRowsSkipped = 0;
     let totalRowsFailed = 0;
+    let totalStepCellsCompleted = 0;
+    let totalStepCellsSkipped = 0;
     const totalRowFailureSamples: Array<{ rowKey: string; error: string }> = [];
 
     const runChunkStep = async (
@@ -5256,7 +5447,7 @@ function createMinimalWorkerCtx(
       return result.rows as Array<T & Record<string, unknown>>;
     };
 
-    const finalize = (totalRowsWritten: number) => {
+    const finalize = async (totalRowsWritten: number) => {
       const failureSampleSummary =
         totalRowFailureSamples.length > 0
           ? ` First error: ${totalRowFailureSamples[0]!.error}`
@@ -5271,6 +5462,11 @@ function createMinimalWorkerCtx(
             `(${totalRowsExecuted} executed, ${totalRowsCached} already satisfied) ` +
             `inserted=${totalRowsInserted} skipped=${totalRowsSkipped}`;
       const completedAt = nowMs();
+      const totalStepCells = totalStepCellsCompleted + totalStepCellsSkipped;
+      const mapDiag =
+        totalStepCells > 0
+          ? ` cells=${totalStepCells}/${totalStepCellsCompleted}/${totalStepCellsSkipped}`
+          : '';
       callbacks?.onMapCompleted?.(mapNodeId, completedAt);
       void updateMapProgress({
         completed: totalRowsWritten,
@@ -5286,9 +5482,45 @@ function createMinimalWorkerCtx(
       emitEvent({
         type: 'log',
         level: totalRowsFailed > 0 ? 'warn' : 'info',
-        message: cacheSummary,
+        message: cacheSummary + mapDiag,
         ts: nowMs(),
       });
+      if (
+        totalRowsWritten > 0 &&
+        totalRowsFailed === 0 &&
+        canCacheRows &&
+        cachedRows.length === totalRowsWritten
+      ) {
+        const persistedRows = await readPersistedRows({
+          limit: totalRowsWritten,
+          offset: 0,
+        });
+        if (persistedRows.length < totalRowsWritten) {
+          const repair = await persistCompletedMapRows({
+            req,
+            tableNamespace: name,
+            outputFields,
+            extraOutputFields: [],
+            rows: cachedRows,
+          });
+          emitEvent({
+            type: 'log',
+            level: 'warn',
+            message:
+              `Runtime sheet finalization repaired ctx.dataset("${name}") ` +
+              `from ${persistedRows.length}/${totalRowsWritten} visible row(s) ` +
+              `(written=${repair.written}, visible=${repair.visible}` +
+              (repair.retryWritten === null
+                ? ''
+                : `, retryWritten=${repair.retryWritten}`) +
+              (repair.retryVisible === null
+                ? ''
+                : `, retryVisible=${repair.retryVisible}`) +
+              ')',
+            ts: nowMs(),
+          });
+        }
+      }
       return createPersistedDatasetHandle({
         playName: req.playName,
         name,
@@ -5345,6 +5577,8 @@ function createMinimalWorkerCtx(
       totalRowsInserted += chunkResult.rowsInserted;
       totalRowsSkipped += chunkResult.rowsSkipped;
       totalRowsFailed += chunkResult.rowsFailed ?? 0;
+      totalStepCellsCompleted += chunkResult.stepCellsCompleted ?? 0;
+      totalStepCellsSkipped += chunkResult.stepCellsSkipped ?? 0;
       for (const sample of chunkResult.rowFailureSamples ?? []) {
         if (totalRowFailureSamples.length >= MAP_ROW_FAILURE_SAMPLE_LIMIT) {
           break;

package/dist/bundling-sources/sdk/src/plays/harness-stub.ts

@@ -40,6 +40,8 @@ import type {
   RuntimeApiCallResult,
   RuntimeReceiptInput,
   RuntimeReceiptsInput,
+  SheetDatasetRowKeysInput,
+  SheetDatasetRowKeysResult,
   SheetDatasetRowsInput,
   SheetDatasetRowsResult,
   StagedFileChunkInput,
@@ -189,6 +191,12 @@ export async function harnessReadSheetDatasetRows(
   return requireBinding().readSheetDatasetRows(input);
 }
 
+export async function harnessReadSheetDatasetRowKeys(
+  input: SheetDatasetRowKeysInput,
+): Promise<SheetDatasetRowKeysResult> {
+  return requireBinding().readSheetDatasetRowKeys(input);
+}
+
 /**
  * Warm Postgres sessions in the long-lived harness Worker. This preserves the
  * map fast path without bundling the Neon client into every dynamic play.

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.161',
+  version: '0.1.163',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.161',
+    latest: '0.1.163',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

package/dist/bundling-sources/shared_libs/play-runtime/map-row-outcome.ts

@@ -2,6 +2,7 @@ import type { MapRowOutcome, MapRowOutcomeStatus } from './durability-store';
 
 export const MAP_ROW_OUTCOME_RUNTIME_FIELDS = {
   rowKey: '__deeplineRowKey',
+  inputIndex: '__deeplineInputIndex',
   cellMetaPatch: '__deeplineCellMetaPatch',
   rowStatus: '__deeplineRowStatus',
   rowError: '__deeplineRowError',
@@ -26,12 +27,16 @@ export function resolveMapRowOutcomeKey(
 
 export function mapRowOutcomeRuntimeFields(input: {
   key: string;
+  inputIndex?: number | null;
   cellMetaPatch?: Record<string, unknown> | null;
   status?: MapRowOutcomeStatus | null;
   error?: string | null;
 }): Record<string, unknown> {
   return {
     [MAP_ROW_OUTCOME_RUNTIME_FIELDS.rowKey]: input.key,
+    ...(typeof input.inputIndex === 'number' && Number.isFinite(input.inputIndex)
+      ? { [MAP_ROW_OUTCOME_RUNTIME_FIELDS.inputIndex]: input.inputIndex }
+      : {}),
     ...(input.cellMetaPatch
       ? { [MAP_ROW_OUTCOME_RUNTIME_FIELDS.cellMetaPatch]: input.cellMetaPatch }
       : {}),
@@ -79,6 +84,7 @@ export function mapRowOutcomeRuntimeRow(
     ...outcome.data,
     ...mapRowOutcomeRuntimeFields({
       key: outcome.key,
+      inputIndex: outcome.inputIndex,
       cellMetaPatch: outcome.cellMetaPatch,
       status: outcome.status,
       error: outcome.error,
@@ -120,9 +126,13 @@ export function mapRowOutcomeFromRuntimeRow(
   row: MapRowOutcomeRuntimeRow,
 ): MapRowOutcome | null {
   if (typeof row.key === 'string' && isRecord(row.data)) {
+    const inputIndex = row.inputIndex;
     return {
       key: row.key,
       data: row.data,
+      ...(typeof inputIndex === 'number' && Number.isFinite(inputIndex)
+        ? { inputIndex }
+        : {}),
       ...(isRecord(row.cellMetaPatch)
         ? { cellMetaPatch: row.cellMetaPatch }
         : {}),
@@ -137,11 +147,15 @@ export function mapRowOutcomeFromRuntimeRow(
 
   const key = resolveMapRowOutcomeKey(row);
   if (!key) return null;
+  const inputIndex = row[MAP_ROW_OUTCOME_RUNTIME_FIELDS.inputIndex];
   const cellMetaPatch = row[MAP_ROW_OUTCOME_RUNTIME_FIELDS.cellMetaPatch];
   const rowStatus = row[MAP_ROW_OUTCOME_RUNTIME_FIELDS.rowStatus];
   const rowError = row[MAP_ROW_OUTCOME_RUNTIME_FIELDS.rowError];
   return {
     key,
+    ...(typeof inputIndex === 'number' && Number.isFinite(inputIndex)
+      ? { inputIndex }
+      : {}),
     data: stripMapRowOutcomeRuntimeFields(row),
     ...(isRecord(cellMetaPatch) ? { cellMetaPatch } : {}),
     ...(rowStatus === 'failed'