deepline 0.3.315 → 0.3.317

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

@@ -4,6 +4,9 @@ import type {
   PlayCheckpoint,
   PlayExecutionEvent,
 } from './ctx-types';
+import type { MapRowOutcome, MapRowOutcomeStatus } from './durability-store';
+import { cloneCsvAliasedRow } from './csv-rename';
+import { RuntimeSheetAttemptSupersededError } from './runtime-sheet-errors';
 
 export function cloneMapFrame(frame: MapExecutionFrame): MapExecutionFrame {
   return {
@@ -14,7 +17,7 @@ export function cloneMapFrame(frame: MapExecutionFrame): MapExecutionFrame {
       ? {
           suspendedInputRows: frame.suspendedInputRows.map((row) => ({
             inputIndex: row.inputIndex,
-            data: { ...row.data },
+            data: cloneCsvAliasedRow(row.data),
             ...(row.authoredInputDigest
               ? { authoredInputDigest: row.authoredInputDigest }
               : {}),
@@ -71,63 +74,453 @@ export class MapExecutionFrameStore {
     });
   }
 
-  updateProgress(input: {
-    scope: MapExecutionScope;
-    totalRows: number;
-    status?: MapExecutionFrame['status'];
-    completedRowKey?: string | null;
-    pendingRowKey?: string | null;
-    failedDelta?: number;
-    activeBoundaryId?: string | null;
-    emitEventType?: PlayExecutionEvent['type'];
-  }): void {
-    const existing =
-      this.checkpoint.mapFrames?.[input.scope.mapInvocationId] ?? null;
-    if (!existing) {
-      return;
+  /**
+   * Open one resolver pool's progress. Restored keys are seeded once; offsets
+   * never add that same restored baseline again. Sources stay live because a
+   * streaming feed admits pages and changes latest-view visibility during execution.
+   */
+  progress(
+    scope: MapExecutionScope,
+    source: MapProgressSource,
+  ): MapExecutionProgress {
+    return new MapExecutionProgress(
+      this.checkpoint,
+      (frame) => this.set(frame),
+      this.emitExecutionEvent,
+      scope,
+      source,
+    );
+  }
+
+  /**
+   * Restore visible success identities and their logical input count together.
+   * Superseded frames can contain historical keys even when their scalar count
+   * appears consistent, so the run-filtered sheet reader checks every such key.
+   * An explicit success count stays authoritative; its excess over visible keys
+   * represents reused inputs. Older materialized suspension plans prove a
+   * missing count by conservation of successful, failed, superseded and pending
+   * inputs. Frames without that plan keep the historical key-count default.
+   */
+  async restoreCompletedRows(
+    frame: MapExecutionFrame,
+    readVisibleKeys:
+      | ((keys: string[]) => Promise<readonly string[]>)
+      | undefined,
+    maxReadKeys: number,
+  ): Promise<{
+    completedRowKeys: string[];
+    completedRowsCount: number;
+    reusedRowsCount: number;
+  }> {
+    const completedRowKeys =
+      (frame.supersededRows ?? 0) > 0 &&
+      frame.completedRowKeys.length > 0 &&
+      readVisibleKeys
+        ? await this.visibleRestoredKeys(
+            frame.completedRowKeys,
+            readVisibleKeys,
+            maxReadKeys,
+          )
+        : [...frame.completedRowKeys];
+    const completedRowsCount =
+      frame.completedRowsCount ??
+      (Array.isArray(frame.suspendedInputRows)
+        ? frame.totalRows -
+          (frame.failedRowsCount ?? 0) -
+          (frame.supersededRows ?? 0) -
+          new Set(frame.pendingRowKeys).size
+        : completedRowKeys.length);
+    if (
+      !Number.isSafeInteger(completedRowsCount) ||
+      completedRowsCount < completedRowKeys.length
+    ) {
+      throw new Error(
+        `Cannot restore map ${frame.mapInvocationId}: successful input count ${completedRowsCount} contradicts ${completedRowKeys.length} visible success keys.`,
+      );
     }
-    const completedRowKeys = new Set(existing.completedRowKeys);
-    const pendingRowKeys = new Set(existing.pendingRowKeys);
-    const completedBefore = completedRowKeys.size;
-    if (input.completedRowKey?.trim()) {
-      const completedRowKey = input.completedRowKey.trim();
-      completedRowKeys.add(completedRowKey);
-      pendingRowKeys.delete(completedRowKey);
+    return {
+      completedRowKeys,
+      completedRowsCount,
+      reusedRowsCount: completedRowsCount - completedRowKeys.length,
+    };
+  }
+
+  private async visibleRestoredKeys(
+    keys: readonly string[],
+    readVisibleKeys: (keys: string[]) => Promise<readonly string[]>,
+    maxReadKeys: number,
+  ): Promise<string[]> {
+    if (!Number.isSafeInteger(maxReadKeys) || maxReadKeys <= 0)
+      throw new Error('Restored map key reads require a positive batch size.');
+    const visible: string[] = [];
+    for (let offset = 0; offset < keys.length; offset += maxReadKeys) {
+      const page = keys.slice(offset, offset + maxReadKeys);
+      const matched = new Set(await readVisibleKeys(page));
+      visible.push(...page.filter((key) => matched.has(key)));
     }
-    if (input.pendingRowKey?.trim()) {
-      pendingRowKeys.add(input.pendingRowKey.trim());
+    return visible;
+  }
+}
+
+type LiveCount = number | (() => number);
+const readCount = (value: LiveCount | undefined, fallback = 0): number =>
+  typeof value === 'function' ? value() : (value ?? fallback);
+const FRAME_FLUSH_ROWS = 100;
+const FRAME_FLUSH_MS = 250;
+
+/**
+ * Accepted Runtime Sheet writes decide which terminal rows remain visible.
+ * The account is shared across a map's pools; restored superseded rows need
+ * only their existing scalar because they are absent from restored success keys.
+ * Classification changes and recovery update counts in O(1) per reported key.
+ */
+export class MapExecutionVisibility {
+  private readonly superseded = new Map<string, MapRowOutcomeStatus>();
+  private supersededCompleted = 0;
+  private supersededFailed = 0;
+
+  constructor(private readonly restoredSupersededRows = 0) {}
+
+  /** Consume visibility facts only after the writer accepts the terminal batch. */
+  recordAcceptedWrite(
+    result: unknown,
+    rows: readonly MapRowOutcome[],
+    scope: { tableNamespace: string; runId: string },
+  ): void {
+    if (!result || typeof result !== 'object') return;
+    const facts = result as {
+      supersededKeys?: string[];
+      staleDroppedKeys?: unknown;
+      recoveredStaleKeys?: unknown;
+    };
+    if (facts.supersededKeys?.length) {
+      // An attempt-wide rejection never admits visibility facts or outcomes.
+      throw new RuntimeSheetAttemptSupersededError({
+        tableNamespace: scope.tableNamespace,
+        runId: scope.runId,
+        writeVersionValue: null,
+        submittedRows: rows.length,
+        supersededRows: facts.supersededKeys.map((key) => ({
+          key,
+          reason: 'unreported' as const,
+          rowVersionStamp: null,
+        })),
+      });
     }
-    const failedRowsCount = Math.max(
-      0,
-      (existing.failedRowsCount ?? 0) + Math.max(0, input.failedDelta ?? 0),
+    const statuses = new Map(
+      rows.map((row) => [row.key, row.status ?? 'completed']),
     );
-    const nextFrame: MapExecutionFrame = {
-      ...existing,
-      status: input.status ?? existing.status,
-      completedRowKeys: [...completedRowKeys],
-      pendingRowKeys: [...pendingRowKeys],
-      failedRowsCount,
-      ...(input.activeBoundaryId !== undefined
-        ? { activeBoundaryId: input.activeBoundaryId }
+    if (Array.isArray(facts.staleDroppedKeys)) {
+      for (const key of facts.staleDroppedKeys) {
+        if (typeof key !== 'string' || !key) continue;
+        this.removeSuperseded(key);
+        const status = statuses.get(key) ?? 'completed';
+        this.superseded.set(key, status);
+        if (status === 'failed') this.supersededFailed += 1;
+        else this.supersededCompleted += 1;
+      }
+    }
+    if (Array.isArray(facts.recoveredStaleKeys)) {
+      for (const key of facts.recoveredStaleKeys) {
+        if (typeof key === 'string' && key) this.removeSuperseded(key);
+      }
+    }
+  }
+
+  private removeSuperseded(key: string): void {
+    const previous = this.superseded.get(key);
+    if (previous === undefined) return;
+    this.superseded.delete(key);
+    if (previous === 'failed') this.supersededFailed -= 1;
+    else this.supersededCompleted -= 1;
+  }
+
+  isVisible(key: string): boolean {
+    return !this.superseded.has(key);
+  }
+
+  get supersededRows(): number {
+    return this.restoredSupersededRows + this.superseded.size;
+  }
+
+  /** One successes/failures/superseded split for live and terminal projections. */
+  settlement(completedRows: number, failedRows: number) {
+    return {
+      completedRows: completedRows - this.supersededCompleted,
+      failedRows: failedRows - this.supersededFailed,
+      supersededRows: this.supersededRows,
+    };
+  }
+}
+
+/**
+ * Live offsets are outcomes from earlier pools, before visibility corrections.
+ * The shared visibility account owns corrections for earlier and current-pool
+ * writes. A committed batch is accounted atomically before projecting either.
+ */
+export interface MapProgressSource {
+  totalRows: LiveCount;
+  completedOffset?: LiveCount;
+  failedOffset?: LiveCount;
+  visibility: MapExecutionVisibility;
+  skippedInputs?: LiveCount;
+  /** Fed maps keep only scalars in checkpoints; the Runtime Sheet owns row records. */
+  checkpointRows: 'keys' | 'counts';
+  eventFields?: () => Partial<PlayExecutionEvent>;
+}
+
+type ProgressChange = {
+  status?: MapExecutionFrame['status'];
+  completedRowKey?: string | null;
+  completedRowKeys?: readonly string[];
+  pendingRowKey?: string | null;
+  pendingRowKeys?: readonly string[];
+  failedRowKey?: string | null;
+  failedRowKeys?: readonly string[];
+  failedDelta?: number;
+  activeBoundaryId?: string | null;
+  emitEventType?: PlayExecutionEvent['type'];
+};
+
+/**
+ * Owns the pool's committed outcomes and its scalar progress projection.
+ * Resolver admission is activity, not settlement. Sheet-backed row outcomes
+ * enter through recordCommittedRows after their terminal write commits; pending
+ * keys and lifecycle transitions may update earlier. Failure counts are
+ * explicit, never inferred from sparse pending keys. Terminal sheet
+ * reconciliation remains authoritative.
+ * Keys mutate in place; checkpoint arrays are materialized on a row/time
+ * throttle and on every transition, preserving the existing replay format.
+ * Accepted terminal input indexes also drain the retained suspension plan in
+ * O(1); an empty retained plan remains distinct from an absent plan on replay.
+ */
+export class MapExecutionProgress {
+  private readonly completed: Set<string>;
+  private readonly pending: Set<string>;
+  private failed = 0;
+  private rowsSinceFlush = 0;
+  private lastFlushAt = 0;
+  private started = 0;
+  private active = 0;
+  private tracksActivity = false;
+  private lastActivityKey: string | null = null;
+  private readonly initiallyStarted: number;
+  private readonly initiallySkipped: number;
+  private status: MapExecutionFrame['status'];
+  private activeBoundaryId: string | null | undefined;
+  private suspendedInputs:
+    | Map<number, NonNullable<MapExecutionFrame['suspendedInputRows']>[number]>
+    | undefined;
+
+  constructor(
+    private readonly checkpoint: PlayCheckpoint,
+    private readonly setFrame: (frame: MapExecutionFrame) => void,
+    private readonly emitExecutionEvent: (event: PlayExecutionEvent) => void,
+    private readonly scope: MapExecutionScope,
+    private readonly source: MapProgressSource,
+  ) {
+    const frame = this.frame();
+    this.completed = new Set(frame?.completedRowKeys ?? []);
+    this.pending = new Set(frame?.pendingRowKeys ?? []);
+    this.status = frame?.status ?? 'running';
+    this.activeBoundaryId = frame?.activeBoundaryId;
+    this.suspendedInputs = frame?.suspendedInputRows
+      ? new Map(frame.suspendedInputRows.map((row) => [row.inputIndex, row]))
+      : undefined;
+    // Freeze settled admission once: live superseded facts can include a
+    // resolver already counted in started, whereas skipped inputs are new.
+    const baseline = this.settlement();
+    this.initiallyStarted =
+      baseline.completedRows + baseline.failedRows + baseline.supersededRows;
+    this.initiallySkipped = readCount(source.skippedInputs);
+  }
+
+  private frame(): MapExecutionFrame | undefined {
+    return this.checkpoint.mapFrames?.[this.scope.mapInvocationId];
+  }
+
+  private settlement() {
+    return this.source.visibility.settlement(
+      readCount(this.source.completedOffset) + this.completed.size,
+      readCount(this.source.failedOffset) + this.failed,
+    );
+  }
+
+  /** One fixed-shape view for checkpoints, settlement events and activity samples. */
+  projection() {
+    const startedRows =
+      this.initiallyStarted +
+      readCount(this.source.skippedInputs, this.initiallySkipped) -
+      this.initiallySkipped +
+      this.started;
+    return {
+      ...this.settlement(),
+      totalRows: readCount(this.source.totalRows),
+      ...(this.tracksActivity
+        ? {
+            startedRows,
+            activeRows: this.active,
+            waitingRows: readCount(this.source.totalRows) - startedRows,
+          }
         : {}),
-      updatedAt: Date.now(),
     };
-    this.set(nextFrame);
-    const progressEventType =
+  }
+
+  private emit(type: PlayExecutionEvent['type']): void {
+    const { startedRows, activeRows, waitingRows, ...settled } =
+      this.projection();
+    this.emitExecutionEvent({
+      ...this.source.eventFields?.(),
+      type,
+      mapInvocationId: this.scope.mapInvocationId,
+      mapNodeId: this.scope.mapNodeId ?? null,
+      logicalNamespace: this.scope.logicalNamespace,
+      artifactTableNamespace: this.scope.artifactTableNamespace,
+      ...settled,
+      ...(type === 'map.progress' && this.tracksActivity
+        ? { startedRows, activeRows, waitingRows }
+        : {}),
+      at: Date.now(),
+    } as PlayExecutionEvent);
+  }
+
+  update(input: ProgressChange): void {
+    if (!this.frame()) return;
+    const before = this.completed.size;
+    for (const raw of [
+      input.completedRowKey,
+      ...(input.completedRowKeys ?? []),
+    ]) {
+      const key = raw?.trim();
+      if (!key) continue;
+      this.completed.add(key);
+      this.pending.delete(key);
+    }
+    for (const raw of [input.pendingRowKey, ...(input.pendingRowKeys ?? [])]) {
+      const key = raw?.trim();
+      if (key && !this.completed.has(key)) this.pending.add(key);
+    }
+    for (const raw of [input.failedRowKey, ...(input.failedRowKeys ?? [])]) {
+      const key = raw?.trim();
+      if (key) this.pending.delete(key);
+    }
+    this.failed += Math.max(0, input.failedDelta ?? 0);
+    this.rowsSinceFlush += this.completed.size - before;
+    this.status = input.status ?? this.status;
+    if (input.activeBoundaryId !== undefined)
+      this.activeBoundaryId = input.activeBoundaryId;
+    const transition =
+      input.status !== undefined ||
+      input.activeBoundaryId !== undefined ||
+      input.emitEventType !== undefined;
+    const now = Date.now();
+    const flush =
+      transition ||
+      readCount(this.source.totalRows) <= FRAME_FLUSH_ROWS ||
+      this.rowsSinceFlush >= FRAME_FLUSH_ROWS ||
+      now - this.lastFlushAt >= FRAME_FLUSH_MS;
+    if (flush) this.flush(now);
+    const event =
       input.emitEventType ??
-      (completedRowKeys.size > completedBefore ? 'map.progress' : null);
-    if (progressEventType) {
-      this.emitExecutionEvent({
-        type: progressEventType,
-        mapInvocationId: input.scope.mapInvocationId,
-        mapNodeId: input.scope.mapNodeId ?? null,
-        logicalNamespace: input.scope.logicalNamespace,
-        artifactTableNamespace: input.scope.artifactTableNamespace,
-        completedRows: nextFrame.completedRowKeys.length,
-        failedRows: failedRowsCount,
-        totalRows: input.totalRows,
-        at: Date.now(),
-      } as PlayExecutionEvent);
+      (flush && this.completed.size > before ? 'map.progress' : null);
+    if (event) this.emit(event);
+  }
+
+  /** Consume one durably committed batch, then project all its outcomes together. */
+  recordCommittedRows(rows: readonly MapRowOutcome[]): void {
+    const completed: string[] = [];
+    const failed: string[] = [];
+    for (const row of rows) {
+      if (typeof row.inputIndex === 'number')
+        this.suspendedInputs?.delete(row.inputIndex);
+      (row.status === 'failed' ? failed : completed).push(row.key);
+    }
+    this.update({
+      completedRowKeys: completed,
+      failedRowKeys: failed,
+      failedDelta: failed.length,
+    });
+  }
+
+  private flush(now: number): void {
+    const frame = this.frame();
+    if (!frame) return;
+    const progress = this.projection();
+    this.setFrame({
+      ...frame,
+      status: this.status,
+      totalRows: progress.totalRows,
+      completedRowKeys:
+        this.source.checkpointRows === 'counts'
+          ? []
+          : [...this.completed].filter((key) =>
+              this.source.visibility.isVisible(key),
+            ),
+      pendingRowKeys:
+        this.source.checkpointRows === 'counts' ? [] : [...this.pending],
+      ...(this.source.checkpointRows === 'counts'
+        ? {
+            pendingRowsCount: this.pending.size,
+          }
+        : {}),
+      completedRowsCount: progress.completedRows,
+      failedRowsCount: progress.failedRows,
+      supersededRows: progress.supersededRows,
+      ...(this.suspendedInputs !== undefined
+        ? { suspendedInputRows: [...this.suspendedInputs.values()] }
+        : {}),
+      ...(this.activeBoundaryId !== undefined
+        ? { activeBoundaryId: this.activeBoundaryId }
+        : {}),
+      updatedAt: now,
+    });
+    this.rowsSinceFlush = 0;
+    this.lastFlushAt = now;
+  }
+
+  /** Record the resume plan before publishing the suspension or handing it off. */
+  suspend(input: {
+    pendingRowKeys: readonly string[];
+    suspendedInputRows: MapExecutionFrame['suspendedInputRows'];
+    activeBoundaryId: string | null;
+  }): void {
+    const frame = this.frame();
+    if (!frame)
+      throw new Error('Suspended map lost its durable execution frame.');
+    this.pending.clear();
+    for (const key of input.pendingRowKeys) {
+      this.completed.delete(key);
+      this.pending.add(key);
     }
+    this.suspendedInputs = input.suspendedInputRows
+      ? new Map(input.suspendedInputRows.map((row) => [row.inputIndex, row]))
+      : undefined;
+    this.setFrame({ ...frame, suspendedInputRows: input.suspendedInputRows });
+    this.update({
+      status: 'suspended',
+      activeBoundaryId: input.activeBoundaryId,
+      emitEventType: 'map.suspended',
+    });
+  }
+
+  resolverStarted(): void {
+    this.tracksActivity = true;
+    this.started += 1;
+    this.active += 1;
+  }
+
+  resolverFinished(): void {
+    this.active -= 1;
+  }
+
+  /** Activity never copies key arrays or publishes after a terminal transition. */
+  publishActivity(): void {
+    if (this.status !== 'running') return;
+    this.tracksActivity = true;
+    const counts = this.projection();
+    const key = `${counts.startedRows}:${counts.activeRows}:${counts.waitingRows}`;
+    if (key === this.lastActivityKey) return;
+    this.lastActivityKey = key;
+    this.emit('map.progress');
   }
 }

package/dist/bundling-sources/shared_libs/play-runtime/run-snapshot-stream.ts

@@ -1,4 +1,8 @@
-import { resolveTimingWindow } from './live-events';
+import {
+  projectPlayStepProgressCounters,
+  resolveTimingWindow,
+  type PlayStepProgressCounters,
+} from './live-events';
 import {
   LOG_TAIL_LIMIT,
   hasConfirmedPlayRunLedgerWorkCounters,
@@ -36,18 +40,13 @@ import { stripProvenanceTag } from './log-provenance';
  * Vercel app (dashboard and legacy SSE compatibility) and the SDK REST polling
  * watcher (`packages/sdk/src/runs/watch-polling.ts`), so both use the same
  * event projection from the persisted Run Snapshot. See ADR-0008.
+ * Snapshots, progress signatures and events share one scalar counter projection;
+ * counter changes are significant even when their timestamps are identical.
  */
 
 export type PlayRunLiveStatus = PlayRunLifecycleStatus;
 
-export type PlayRunStreamNodeProgress = {
-  completed?: number;
-  total?: number;
-  failed?: number;
-  startedRows?: number;
-  activeRows?: number;
-  waitingRows?: number;
-  completedRows?: number;
+export type PlayRunStreamNodeProgress = PlayStepProgressCounters & {
   message?: string;
   updatedAt?: number | null;
   startedAt?: number | null;
@@ -241,14 +240,7 @@ function buildSnapshotFromLedger(
       artifactTableNamespace: step.artifactTableNamespace ?? null,
       progress: step.progress
         ? {
-            completed: step.progress.completed,
-            total: step.progress.total,
-            failed: step.progress.failed,
-            startedRows: step.progress.startedRows,
-            activeRows: step.progress.activeRows,
-            waitingRows: step.progress.waitingRows,
-            completedRows: step.progress.completedRows,
-            supersededRows: step.progress.supersededRows,
+            ...projectPlayStepProgressCounters(step.progress),
             message: step.progress.message,
             artifactTableNamespace:
               step.progress.artifactTableNamespace ??
@@ -418,12 +410,9 @@ export type PlayRunStreamEvent =
       'play.step.status'
     >
   | RunStreamEventEnvelope<
-      {
+      PlayStepProgressCounters & {
         runId: string;
         stepId: string;
-        completed?: number;
-        total?: number;
-        failed?: number;
         message?: string;
         artifactTableNamespace: string | null;
         startedAt?: number | null;
@@ -512,21 +501,17 @@ function getStepStatusSignature(snapshot: PlayRunLiveSnapshot): string {
 }
 
 function getStepProgressSignature(snapshot: PlayRunLiveSnapshot): string {
-  return snapshot.nodeStates
-    .map((state) =>
-      [
-        state.nodeId,
-        state.progress?.completed ?? '',
-        state.progress?.total ?? '',
-        state.progress?.failed ?? '',
-        state.progress?.artifactTableNamespace ?? '',
-        state.progress?.startedAt ?? '',
-        state.progress?.completedAt ?? '',
-        state.progress?.updatedAt ?? '',
-        state.progress?.message ?? '',
-      ].join(':'),
-    )
-    .join('|');
+  return JSON.stringify(
+    snapshot.nodeStates.map((state) => [
+      state.nodeId,
+      projectPlayStepProgressCounters(state.progress ?? {}),
+      state.progress?.artifactTableNamespace ?? '',
+      state.progress?.startedAt ?? '',
+      state.progress?.completedAt ?? '',
+      state.progress?.updatedAt ?? '',
+      state.progress?.message ?? '',
+    ]),
+  );
 }
 
 function getSnapshotSignature(snapshot: PlayRunLiveSnapshot): string {
@@ -682,13 +667,7 @@ export function diffPlayRunStreamEvents(input: {
           payload: {
             runId: snapshot.runId,
             stepId: state.nodeId,
-            completed: state.progress.completed,
-            total: state.progress.total,
-            failed: state.progress.failed,
-            startedRows: state.progress.startedRows,
-            activeRows: state.progress.activeRows,
-            waitingRows: state.progress.waitingRows,
-            completedRows: state.progress.completedRows,
+            ...projectPlayStepProgressCounters(state.progress),
             message: state.progress.message,
             artifactTableNamespace:
               state.progress.artifactTableNamespace ??

package/dist/bundling-sources/shared_libs/play-runtime/runner-app/index.ts

@@ -2574,9 +2574,9 @@ async function run(
         runId,
         tableNamespace,
       });
-      // A later source page of a table this runner already admitted keeps the
-      // first page's write version: rows of earlier pages are still executing
-      // and their terminal writes are fenced by it.
+      // The admission owner durably pins one write intent per run/table, also
+      // after a scheduler wake recreates this Map. Retain the local version as
+      // an additional consistency check across pages of this runner.
       const existingAttempt = runtimeSheetAttempts.get(attemptKey);
       const mapStartResult = await retryRuntimeSheetPersistence({
         description: `runtime map start table=${tableNamespace}`,
@@ -2612,6 +2612,7 @@ async function run(
                 columnTypes: mapContext.columnTypes,
               }),
               rows: items,
+              stableWriteIntent: true,
               pendingRerunAdmission: true,
               inputOffset: mapContext.inputOffset,
               mode: mapContext.mode,