deepline 0.1.295 → 0.1.297

package/dist/bundling-sources/shared_libs/play-runtime/resource-governor.ts

@@ -30,10 +30,7 @@ export type RuntimeResourceSnapshot = {
   };
   sheetFlush: {
     acquired: number;
-    active: number;
-    waiting: number;
     bytes: number;
-    admissionWaitMsEwma: number | null;
     latencyMsEwma: number | null;
   };
   providers: Record<
@@ -62,11 +59,6 @@ export interface RuntimeResourceGovernor {
     toolId: string;
     signal?: AbortSignal;
   }): Promise<RuntimeResourceLease>;
-  acquireSheetFlush(input?: {
-    estimatedBytes?: number | null;
-    rowCount?: number | null;
-    signal?: AbortSignal;
-  }): Promise<RuntimeResourceLease>;
   suggestedToolParallelism(toolId: string, fallback: number): Promise<number>;
   resolveRowConcurrency(requested?: number): number;
   reportProviderBackpressure(input: {
@@ -98,76 +90,6 @@ function createEwma(alpha = 0.2): Ewma {
   };
 }
 
-// Sheet persistence has its own local admission lane. Receipt lifecycle calls
-// are admitted by the receipt sink/gateway and must not queue behind a large
-// Runtime Sheet flush in the runner. Two flushes keep the database busy while
-// bounding resident payloads and gateway/pool pressure (ADR 0012).
-const MAX_CONCURRENT_SHEET_FLUSHES = 2;
-
-type SheetFlushWaiter = {
-  resolve: (lease: RuntimeResourceLease) => void;
-  reject: (error: unknown) => void;
-  signal?: AbortSignal;
-  onAbort?: () => void;
-};
-
-class SheetFlushAdmission {
-  #active = 0;
-  #waiters: SheetFlushWaiter[] = [];
-
-  get active(): number {
-    return this.#active;
-  }
-
-  get waiting(): number {
-    return this.#waiters.length;
-  }
-
-  acquire(signal?: AbortSignal): Promise<RuntimeResourceLease> {
-    if (signal?.aborted) {
-      return Promise.reject(signal.reason ?? new Error('Sheet flush aborted'));
-    }
-    if (this.#active < MAX_CONCURRENT_SHEET_FLUSHES) {
-      this.#active += 1;
-      return Promise.resolve(this.#lease());
-    }
-    return new Promise((resolve, reject) => {
-      const waiter: SheetFlushWaiter = {
-        resolve,
-        reject,
-        ...(signal ? { signal } : {}),
-      };
-      if (signal) {
-        waiter.onAbort = () => {
-          const index = this.#waiters.indexOf(waiter);
-          if (index >= 0) this.#waiters.splice(index, 1);
-          reject(signal.reason ?? new Error('Sheet flush aborted'));
-        };
-        signal.addEventListener('abort', waiter.onAbort, { once: true });
-      }
-      this.#waiters.push(waiter);
-    });
-  }
-
-  #lease(): RuntimeResourceLease {
-    let released = false;
-    return {
-      release: () => {
-        if (released) return;
-        released = true;
-        while (this.#waiters.length > 0) {
-          const waiter = this.#waiters.shift()!;
-          waiter.signal?.removeEventListener('abort', waiter.onAbort!);
-          if (waiter.signal?.aborted) continue;
-          waiter.resolve(this.#lease());
-          return;
-        }
-        this.#active = Math.max(0, this.#active - 1);
-      },
-    };
-  }
-}
-
 function elapsedSince(startedAt: number): number {
   return Math.max(0, Date.now() - startedAt);
 }
@@ -183,8 +105,6 @@ export function createRuntimeResourceGovernor(input: {
   const rowAdmissionWait = createEwma();
   const toolAdmissionWait = createEwma();
   const sheetFlushLatency = createEwma();
-  const sheetFlushAdmissionWait = createEwma();
-  const sheetFlushAdmission = new SheetFlushAdmission();
   const providers = new Map<
     string,
     {
@@ -223,6 +143,9 @@ export function createRuntimeResourceGovernor(input: {
     rowAdmissionWait.observe(observation.rowAdmissionWaitMs);
     toolAdmissionWait.observe(observation.toolAdmissionWaitMs);
     sheetFlushLatency.observe(observation.sheetFlushLatencyMs);
+    if (observation.sheetFlushLatencyMs != null) {
+      sheetFlushCounters.acquired += 1;
+    }
     if (observation.rowEstimatedBytes != null) {
       rowCounters.estimatedBytes += Math.max(
         0,
@@ -301,17 +224,6 @@ export function createRuntimeResourceGovernor(input: {
       );
     },
 
-    async acquireSheetFlush(sheetInput) {
-      const startedAt = Date.now();
-      const lease = await sheetFlushAdmission.acquire(sheetInput?.signal);
-      sheetFlushCounters.acquired += 1;
-      sheetFlushAdmissionWait.observe(elapsedSince(startedAt));
-      observe({
-        sheetFlushBytes: sheetInput?.estimatedBytes ?? null,
-      });
-      return lease;
-    },
-
     suggestedToolParallelism(toolId, fallback) {
       return input.executionGovernor.suggestedParallelism(toolId, fallback);
     },
@@ -344,10 +256,7 @@ export function createRuntimeResourceGovernor(input: {
         },
         sheetFlush: {
           acquired: sheetFlushCounters.acquired,
-          active: sheetFlushAdmission.active,
-          waiting: sheetFlushAdmission.waiting,
           bytes: sheetFlushCounters.bytes,
-          admissionWaitMsEwma: sheetFlushAdmissionWait.value,
           latencyMsEwma: sheetFlushLatency.value,
         },
         providers: Object.fromEntries(

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

@@ -6456,12 +6456,44 @@ type CompleteRuntimeMapRowChunksInput = {
 };
 
 export type RuntimeMapRowsWriteResult = {
+  /** Submitted row identities durably accepted, including idempotent replays. */
+  committedKeys: string[];
+  /** Submitted row identities rejected because a newer write owns the row. */
+  staleKeys: string[];
+  /** Physical row mutations. Idempotent commits do not increment this count. */
   updated: number;
+  /** Compatibility alias retained for callers that still call stale rows fenced. */
   fencedKeys: string[];
   staleDropped?: number;
   staleDroppedKeys?: string[];
 };
 
+type RuntimeMapRowsMutationResult = {
+  updated: number;
+  fencedKeys: string[];
+  conflictKeys: string[];
+};
+
+function classifyRuntimeMapRowsWrite(input: {
+  submittedKeys: Iterable<string>;
+  updated: number;
+  fencedKeys: Iterable<string>;
+}): RuntimeMapRowsWriteResult {
+  const staleKeys = [...new Set(input.fencedKeys)];
+  const staleSet = new Set(staleKeys);
+  const committedKeys = [...new Set(input.submittedKeys)].filter(
+    (key) => !staleSet.has(key),
+  );
+  return {
+    committedKeys,
+    staleKeys,
+    updated: input.updated,
+    fencedKeys: staleKeys,
+    staleDropped: staleKeys.length,
+    staleDroppedKeys: staleKeys,
+  };
+}
+
 function writableEnrichedRuntimeSheetAttemptSql(
   tableAlias: string,
   attemptOwnerRunIdExpression: string,
@@ -6480,9 +6512,10 @@ async function completeRuntimeMapRowChunks(
   client: RuntimeQueryClient,
   session: RuntimePostgresSession,
   input: CompleteRuntimeMapRowChunksInput,
-): Promise<RuntimeMapRowsWriteResult> {
+): Promise<RuntimeMapRowsMutationResult> {
   let updated = 0;
   const fencedKeys: string[] = [];
+  const conflictKeys: string[] = [];
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
@@ -6515,6 +6548,7 @@ async function completeRuntimeMapRowChunks(
       updated: number;
       matched_keys: string[];
       fenced_keys: string[];
+      conflict_keys: string[];
     }>(
       `WITH updates AS (
          SELECT key_values._key,
@@ -6540,6 +6574,31 @@ async function completeRuntimeMapRowChunks(
            JOIN ${sheetTable(session)} AS target
              ON target._key = updates._key
        ),
+       same_version_conflicts AS (
+         SELECT updates.matched_key AS _key
+           FROM matched_updates AS updates
+           JOIN ${sheetTable(session)} AS target
+             ON target._key = updates.matched_key
+          WHERE $13::bigint IS NOT NULL
+            AND target._write_version = $13::bigint
+            AND target._run_id = $5::text
+            AND target._status IN ('enriched', 'failed')
+            AND (
+              EXISTS (
+                SELECT 1
+                  FROM unnest($8::text[]) AS field_values(field)
+                 WHERE target._cell_meta -> field_values.field ->> 'runId' = $5::text
+              )
+              OR (
+                coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
+                AND COALESCE(target._attempt_seq, 0) = $12::integer
+              )
+            )
+            AND (
+              target._status <> 'enriched'
+              OR (${targetChangedPatchedCellSql})
+            )
+       ),
        applied_rows AS (
          UPDATE ${sheetTable(session)} AS target
          SET _status = 'enriched',
@@ -6556,6 +6615,7 @@ async function completeRuntimeMapRowChunks(
              _cell_meta = ${mergeRuntimeCellMetaPatchSql('target._cell_meta', 'updates.cell_meta_patch')}${input.physicalUpdateSetSql}
          FROM matched_updates AS updates
          WHERE target._key = updates.matched_key
+                   AND NOT EXISTS (SELECT 1 FROM same_version_conflicts)
 		           AND ($13::bigint IS NULL OR target._write_version = $13::bigint)
                    AND ($13::bigint IS NOT NULL OR target._status <> 'enriched')
 		           AND NOT (${newerTerminalRuntimeSheetRowSql('target', '$11::timestamptz', '$12::integer', '$9::text', '$10::text')})
@@ -6691,6 +6751,7 @@ async function completeRuntimeMapRowChunks(
          (SELECT count(*)::int FROM applied_rows) AS updated,
          coalesce((SELECT array_agg(matched_key) FROM matched_updates), '{}'::text[]) AS matched_keys,
          coalesce((SELECT array_agg(_key) FROM fenced_rows), '{}'::text[]) AS fenced_keys,
+         coalesce((SELECT array_agg(_key) FROM same_version_conflicts), '{}'::text[]) AS conflict_keys,
          (SELECT count(*)::int FROM summary_delta) AS summary_delta_count,
          (SELECT count(*)::int FROM column_delta) AS column_delta_count`,
       [
@@ -6711,12 +6772,18 @@ async function completeRuntimeMapRowChunks(
     );
     const matchedKeys = new Set(rows[0]?.matched_keys ?? []);
     const chunkFencedKeys = rows[0]?.fenced_keys ?? [];
+    const chunkConflictKeys = rows[0]?.conflict_keys ?? [];
     // An exact-version replay that already produced the same terminal value is
     // accepted idempotently even when SQL has no physical mutation to apply.
     // Stale versions remain excluded through fenced_keys.
     const appliedCount = Number(rows[0]?.updated ?? 0);
     updated += appliedCount;
     fencedKeys.push(...chunkFencedKeys);
+    conflictKeys.push(...chunkConflictKeys);
+
+    if (chunkConflictKeys.length > 0) {
+      continue;
+    }
 
     if (matchedKeys.size === chunk.length) {
       continue;
@@ -6735,17 +6802,19 @@ async function completeRuntimeMapRowChunks(
     );
     updated += repaired.updated;
     fencedKeys.push(...repaired.fencedKeys);
+    conflictKeys.push(...repaired.conflictKeys);
   }
-  return { updated, fencedKeys };
+  return { updated, fencedKeys, conflictKeys };
 }
 
 async function completeRuntimeMapRowChunksWithInputIndexRepair(
   client: RuntimeQueryClient,
   session: RuntimePostgresSession,
   input: CompleteRuntimeMapRowChunksInput,
-): Promise<RuntimeMapRowsWriteResult> {
+): Promise<RuntimeMapRowsMutationResult> {
   let updated = 0;
   const fencedKeys: string[] = [];
+  const conflictKeys: string[] = [];
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
@@ -6770,6 +6839,7 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
     const { rows } = await client.query<{
       _key?: string;
       fenced_keys?: string[];
+      conflict_keys?: string[];
       updated?: number;
     }>(
       `WITH updates AS (
@@ -6788,6 +6858,7 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
        matched_updates AS (
          SELECT DISTINCT ON (target._key)
                 target._key AS matched_key,
+                updates._key AS submitted_key,
                 updates.data_patch,
                 updates.cell_meta_patch
            FROM updates
@@ -6800,10 +6871,37 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
              )
           ORDER BY target._key, (target._key = updates._key) DESC
        ),
+       same_version_conflicts AS (
+         SELECT updates.submitted_key AS _key
+           FROM matched_updates AS updates
+           JOIN ${sheetTable(session)} AS target
+             ON target._key = updates.matched_key
+          WHERE $13::bigint IS NOT NULL
+            AND target._write_version = $13::bigint
+            AND target._run_id = $5::text
+            AND target._status IN ('enriched', 'failed')
+            AND (
+              EXISTS (
+                SELECT 1
+                  FROM unnest($8::text[]) AS field_values(field)
+                 WHERE target._cell_meta -> field_values.field ->> 'runId' = $5::text
+              )
+              OR (
+                coalesce(target._attempt_owner_run_id, target._run_id) = $10::text
+                AND COALESCE(target._attempt_seq, 0) = $12::integer
+              )
+            )
+            AND (
+              target._status <> 'enriched'
+              OR (${targetChangedPatchedCellSql})
+            )
+       ),
        applied_rows AS (
          UPDATE ${sheetTable(session)} AS target
          SET _status = 'enriched',
              _run_id = $5::text,
+             _writer_run_id = $5::text,
+             _write_version = COALESCE($13::bigint, target._write_version),
              _error = NULL,
              _attempt_id = $9::text,
              _attempt_owner_run_id = $10::text,
@@ -6815,6 +6913,9 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
          FROM matched_updates AS updates, ${sheetTable(session)} AS prev
          WHERE target._key = updates.matched_key
            AND prev._key = target._key
+           AND NOT EXISTS (SELECT 1 FROM same_version_conflicts)
+           AND ($13::bigint IS NULL OR target._write_version = $13::bigint)
+           AND ($13::bigint IS NOT NULL OR target._status <> 'enriched')
 		           AND NOT (${newerTerminalRuntimeSheetRowSql('target', '$11::timestamptz', '$12::integer', '$9::text', '$10::text')})
            AND NOT (${sameOwnerTerminalEpochSql})
            AND (
@@ -6842,15 +6943,17 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
            FROM applied_rows
        ),
        fenced_rows AS (
-         SELECT updates.matched_key AS _key
+         SELECT updates.submitted_key AS _key
            FROM matched_updates AS updates
            JOIN ${sheetTable(session)} AS target
              ON target._key = updates.matched_key
           WHERE NOT EXISTS (
                   SELECT 1 FROM applied_rows WHERE applied_rows._key = updates.matched_key
-                )
+            )
             AND (
-              (${newerTerminalRuntimeSheetRowSql('target', '$11::timestamptz', '$12::integer', '$9::text', '$10::text')})
+              ($13::bigint IS NOT NULL AND target._write_version <> $13::bigint)
+              OR ($13::bigint IS NULL AND target._status = 'enriched')
+              OR (${newerTerminalRuntimeSheetRowSql('target', '$11::timestamptz', '$12::integer', '$9::text', '$10::text')})
               OR NOT (
                 ($9::text IS NULL AND target._run_id = $5::text)
                 OR ($9::text IS NOT NULL AND ${activeRuntimeSheetAttemptFenceSql('target', '$9::text', '$10::text', '$11::timestamptz', '$12::integer')})
@@ -6941,7 +7044,8 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
        )
        SELECT
          (SELECT count(*)::int FROM applied_rows) AS updated,
-         coalesce((SELECT array_agg(_key) FROM fenced_rows), '{}'::text[]) AS fenced_keys`,
+         coalesce((SELECT array_agg(_key) FROM fenced_rows), '{}'::text[]) AS fenced_keys,
+         coalesce((SELECT array_agg(_key) FROM same_version_conflicts), '{}'::text[]) AS conflict_keys`,
       [
         chunkKeys,
         chunkInputIndexes,
@@ -6955,12 +7059,14 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
         input.attemptOwnerRunId,
         input.attemptExpiresAt,
         input.attemptSeq,
+        input.writeVersion,
       ],
     );
     updated += Number(rows[0]?.updated ?? 0);
     fencedKeys.push(...(rows[0]?.fenced_keys ?? []));
+    conflictKeys.push(...(rows[0]?.conflict_keys ?? []));
   }
-  return { updated, fencedKeys };
+  return { updated, fencedKeys, conflictKeys };
 }
 
 async function insertMissingCompletedMapRowChunks(
@@ -7140,6 +7246,7 @@ async function failRuntimeMapRowChunks(
   input: {
     chunks: RuntimePreparedFailedRow[][];
     physicalUpdateSetSql: string;
+    physicalColumnProjections: PhysicalSheetColumnProjection[];
     forceTerminal?: boolean;
     runId: string;
     attemptId: string | null;
@@ -7150,15 +7257,21 @@ async function failRuntimeMapRowChunks(
     normalizedPlayName: string;
     normalizedTableNamespace: string;
   },
-): Promise<RuntimeMapRowsWriteResult> {
+): Promise<RuntimeMapRowsMutationResult> {
   let updated = 0;
   const fencedKeys: string[] = [];
+  const conflictKeys: string[] = [];
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
     const chunkDataPatches = chunk.map((row) => row.data_patch_json);
     const chunkCellMetaPatches = chunk.map((row) => row.cell_meta_patch_json);
     const chunkErrors = chunk.map((row) => row.error);
+    const targetChangedPatchedCellSql = changedPatchedCellSql(
+      'target',
+      'updates.data_patch',
+      input.physicalColumnProjections,
+    );
     // Per-field failed-cell counts for the column summary, computed from the
     // cell meta patches (a failed row records exactly which cell failed).
     const failedCellCounts = new Map<string, number>();
@@ -7180,6 +7293,7 @@ async function failRuntimeMapRowChunks(
     const { rows } = await client.query<{
       updated?: number;
       fenced_keys?: string[];
+      conflict_keys?: string[];
     }>(
       `WITH updates AS (
          SELECT key_values._key,
@@ -7213,6 +7327,32 @@ async function failRuntimeMapRowChunks(
              )
           ORDER BY target._key, (target._key = updates._key) DESC
        ),
+       same_version_conflicts AS (
+         SELECT updates.matched_key AS _key
+           FROM matched_updates AS updates
+           JOIN ${sheetTable(session)} AS target
+             ON target._key = updates.matched_key
+          WHERE $16::bigint IS NOT NULL
+            AND target._write_version = $16::bigint
+            AND target._run_id = $6::text
+            AND target._status IN ('enriched', 'failed')
+            AND (
+              EXISTS (
+                SELECT 1
+                  FROM unnest($9::text[]) AS field_values(field)
+                 WHERE target._cell_meta -> field_values.field ->> 'runId' = $6::text
+              )
+              OR (
+                coalesce(target._attempt_owner_run_id, target._run_id) = $12::text
+                AND COALESCE(target._attempt_seq, 0) = $14::integer
+              )
+            )
+            AND (
+              target._status <> 'failed'
+              OR target._error IS DISTINCT FROM updates.error
+              OR (${targetChangedPatchedCellSql})
+            )
+       ),
        applied_rows AS (
          UPDATE ${sheetTable(session)} AS target
          SET _status = 'failed',
@@ -7229,6 +7369,7 @@ async function failRuntimeMapRowChunks(
              _cell_meta = ${mergeRuntimeCellMetaPatchSql('target._cell_meta', 'updates.cell_meta_patch')}${input.physicalUpdateSetSql}
          FROM matched_updates AS updates, ${sheetTable(session)} AS prev
          WHERE target._key = updates.matched_key
+           AND NOT EXISTS (SELECT 1 FROM same_version_conflicts)
            AND ($16::bigint IS NULL OR target._write_version = $16::bigint)
            AND prev._key = target._key
            AND ($15::boolean OR target._status <> 'enriched')
@@ -7237,6 +7378,14 @@ async function failRuntimeMapRowChunks(
              ($11::text IS NULL AND target._run_id = $6::text)
              OR ($11::text IS NOT NULL AND ${activeRuntimeSheetAttemptFenceSql('target', '$11::text', '$12::text', '$13::timestamptz', '$14::integer')})
 	           )
+           AND NOT (
+             $16::bigint IS NOT NULL
+             AND target._write_version = $16::bigint
+             AND target._run_id = $6::text
+             AND target._status = 'failed'
+             AND target._error IS NOT DISTINCT FROM updates.error
+             AND NOT (${targetChangedPatchedCellSql})
+           )
          RETURNING target._key, prev._status AS prev_status
        ),
        applied_count AS (
@@ -7326,7 +7475,8 @@ async function failRuntimeMapRowChunks(
        )
        SELECT
          (SELECT count(*)::int FROM applied_rows) AS updated,
-         coalesce((SELECT array_agg(_key) FROM fenced_rows), '{}'::text[]) AS fenced_keys`,
+         coalesce((SELECT array_agg(_key) FROM fenced_rows), '{}'::text[]) AS fenced_keys,
+         coalesce((SELECT array_agg(_key) FROM same_version_conflicts), '{}'::text[]) AS conflict_keys`,
       [
         chunkKeys,
         chunkInputIndexes,
@@ -7348,8 +7498,9 @@ async function failRuntimeMapRowChunks(
     );
     updated += Number(rows[0]?.updated ?? 0);
     fencedKeys.push(...(rows[0]?.fenced_keys ?? []));
+    conflictKeys.push(...(rows[0]?.conflict_keys ?? []));
   }
-  return { updated, fencedKeys };
+  return { updated, fencedKeys, conflictKeys };
 }
 
 /**
@@ -7382,6 +7533,13 @@ export async function completeRuntimeMapRows(
     forceFailedRows?: boolean;
   },
 ): Promise<RuntimeMapRowsWriteResult> {
+  if (input.rows.length === 0) {
+    return classifyRuntimeMapRowsWrite({
+      submittedKeys: [],
+      updated: 0,
+      fencedKeys: [],
+    });
+  }
   if (context.dbSessionStrategy === 'gateway_only') {
     const keyedRows = input.rows.map((row) => {
       if (row.key) return row;
@@ -7395,13 +7553,27 @@ export async function completeRuntimeMapRows(
       runId: input.runId,
       outputFields: input.outputFields ?? [],
     });
-    return await postRuntimeApi<RuntimeMapRowsWriteResult>(context, {
+    const result = await postRuntimeApi<
+      Partial<RuntimeMapRowsWriteResult> &
+        Pick<RuntimeMapRowsWriteResult, 'updated' | 'fencedKeys'>
+    >(context, {
       action: 'runtime_sheet_complete_map_rows',
       input: { ...input, rows },
     });
-  }
-  if (input.rows.length === 0) {
-    return { updated: 0, fencedKeys: [] };
+    const submittedKeys = keyedRows
+      .map((row) => row.key)
+      .filter((key): key is string => Boolean(key));
+    const staleKeys =
+      result.staleKeys ?? result.staleDroppedKeys ?? result.fencedKeys;
+    return {
+      ...classifyRuntimeMapRowsWrite({
+        submittedKeys,
+        updated: result.updated,
+        fencedKeys: staleKeys,
+      }),
+      // Preserve the gateway's compatibility classification during rollout.
+      fencedKeys: result.fencedKeys,
+    };
   }
   const sheetContract = augmentSheetContractWithDatasetFields({
     contract: input.sheetContract,
@@ -7441,7 +7613,11 @@ export async function completeRuntimeMapRows(
     uniqueRows.set(resolvedKey, { ...row, key: resolvedKey });
   }
   if (uniqueRows.size === 0) {
-    return { updated: 0, fencedKeys: [] };
+    return classifyRuntimeMapRowsWrite({
+      submittedKeys: [],
+      updated: 0,
+      fencedKeys: [],
+    });
   }
 
   const projections = physicalSheetColumnProjections(sheetContract);
@@ -7526,14 +7702,16 @@ export async function completeRuntimeMapRows(
               return {
                 updated: updated.updated + inserted.inserted,
                 fencedKeys: updated.fencedKeys,
+                conflictKeys: updated.conflictKeys,
               };
             })()
-          : { updated: 0, fencedKeys: [] };
+          : { updated: 0, fencedKeys: [], conflictKeys: [] };
       const failed =
         failedRows.length > 0
           ? await failRuntimeMapRowChunks(client, session, {
               chunks: failedChunks,
               physicalUpdateSetSql,
+              physicalColumnProjections: projections,
               forceTerminal: input.forceFailedRows === true,
               runId: input.runId,
               attemptId,
@@ -7546,13 +7724,22 @@ export async function completeRuntimeMapRows(
                 input.tableNamespace,
               ),
             })
-          : { updated: 0, fencedKeys: [] };
-      return {
+          : { updated: 0, fencedKeys: [], conflictKeys: [] };
+      const conflictKeys = [...completed.conflictKeys, ...failed.conflictKeys];
+      if (conflictKeys.length > 0) {
+        throw new Error(
+          `Runtime Sheet received the same write version with a different terminal payload for row(s): ${[
+            ...new Set(conflictKeys),
+          ]
+            .slice(0, 10)
+            .join(', ')}.`,
+        );
+      }
+      return classifyRuntimeMapRowsWrite({
+        submittedKeys: uniqueRows.keys(),
         updated: completed.updated + failed.updated,
         fencedKeys: [...completed.fencedKeys, ...failed.fencedKeys],
-        staleDropped: completed.fencedKeys.length + failed.fencedKeys.length,
-        staleDroppedKeys: [...completed.fencedKeys, ...failed.fencedKeys],
-      };
+      });
     },
   );
 }