deepline 0.1.131 → 0.1.132

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

@@ -1466,6 +1466,9 @@ type WorkerToolBatchRequest = {
 
 const WORKER_TOOL_BATCH_GRACE_MS = 250;
 const MAP_EXECUTION_HEARTBEAT_INTERVAL_MS = 5_000;
+const MAP_INCREMENTAL_PERSIST_CHUNK_ROWS = 100;
+const MAP_INCREMENTAL_PERSIST_CHUNK_BYTES = 1 * 1024 * 1024;
+const MAP_INCREMENTAL_PERSIST_INTERVAL_MS = 100;
 /**
  * Bounded number of per-row failure samples carried in chunk summaries and the
  * map's terminal partial-failure log. Every failed row is persisted with its
@@ -3850,6 +3853,153 @@ function createMinimalWorkerCtx(
         reportSettledToolRequests,
       );
       const generatedOutputFields = new Set<string>();
+      const persistedExecutedIndexes = new Set<number>();
+      const persistedFailedIndexes = new Set<number>();
+      let pendingPersistRows = 0;
+      let pendingPersistBytes = 0;
+      let scheduledPersistTimer: ReturnType<typeof setTimeout> | null = null;
+      let persistFlushChain: Promise<void> = Promise.resolve();
+      let persistFailure: unknown = null;
+
+      const clearScheduledPersistTimer = () => {
+        if (scheduledPersistTimer) {
+          clearTimeout(scheduledPersistTimer);
+          scheduledPersistTimer = null;
+        }
+      };
+
+      const persistExecutedRows = async () => {
+        const rowsToPersist = executedRows
+          .map((row, executedIndex) =>
+            row && !persistedExecutedIndexes.has(executedIndex)
+              ? {
+                  row,
+                  executedIndex,
+                }
+              : null,
+          )
+          .filter(
+            (
+              entry,
+            ): entry is {
+              row: T & Record<string, unknown>;
+              executedIndex: number;
+            } => entry !== null,
+          );
+        const allFailedRowsToPersist = failedRowEntries
+          .map((failure, executedIndex) =>
+            failure && !persistedFailedIndexes.has(executedIndex)
+              ? {
+                  failure,
+                  executedIndex,
+                }
+              : null,
+          )
+          .filter(
+            (
+              entry,
+            ): entry is {
+              failure: { row: T & Record<string, unknown>; error: string };
+              executedIndex: number;
+            } => entry !== null,
+          );
+        // Under the default isolation, every failed row persists as a
+        // recoverable `_status='failed'` row (it re-executes free next run).
+        // Under `onRowError: 'fail'` the run dies, so a failed row's partial
+        // data is persisted ONLY as a last-resort recovery: when this chunk has
+        // no other recoverable rows (no successful executed rows and no
+        // already-completed rows). That keeps a partial fail-fast run's export
+        // to the rows that fully committed before the failure, while an
+        // all-rows-failed fail-fast run still exposes the persisted partial
+        // cells instead of advertising an empty, unrecoverable dataset.
+        const failedRowsToPersist =
+          failFastRowErrors &&
+          (rowsToPersist.length > 0 ||
+            persistedExecutedIndexes.size > 0 ||
+            prepared.completedRows.length > 0)
+            ? []
+            : allFailedRowsToPersist;
+        if (rowsToPersist.length === 0 && failedRowsToPersist.length === 0) {
+          return;
+        }
+        await persistCompletedMapRows({
+          req,
+          tableNamespace: name,
+          outputFields,
+          extraOutputFields: Array.from(generatedOutputFields),
+          rows: [
+            ...rowsToPersist.map(({ row, executedIndex }) => ({
+              ...row,
+              ...(executedCellMetaPatches[executedIndex]
+                ? {
+                    __deeplineCellMetaPatch:
+                      executedCellMetaPatches[executedIndex],
+                  }
+                : {}),
+              __deeplineRowKey:
+                uniqueRowsToExecuteEntries[executedIndex]!.rowKey,
+            })),
+            // Failed rows persist as recoverable `_status='failed'` sheet
+            // rows: partial data + per-cell failure meta + the row error.
+            ...failedRowsToPersist.map(({ failure, executedIndex }) => ({
+              ...failure.row,
+              ...(executedCellMetaPatches[executedIndex]
+                ? {
+                    __deeplineCellMetaPatch:
+                      executedCellMetaPatches[executedIndex],
+                  }
+                : {}),
+              __deeplineRowKey:
+                uniqueRowsToExecuteEntries[executedIndex]!.rowKey,
+              __deeplineRowStatus: 'failed',
+              __deeplineRowError: failure.error,
+            })),
+          ],
+        });
+        for (const { executedIndex } of rowsToPersist) {
+          persistedExecutedIndexes.add(executedIndex);
+        }
+        for (const { executedIndex } of failedRowsToPersist) {
+          persistedFailedIndexes.add(executedIndex);
+        }
+      };
+
+      const enqueuePersistExecutedRows = (): Promise<void> => {
+        clearScheduledPersistTimer();
+        pendingPersistRows = 0;
+        pendingPersistBytes = 0;
+        const task = persistFlushChain.then(async () => {
+          if (persistFailure) throw persistFailure;
+          await persistExecutedRows();
+        });
+        persistFlushChain = task.catch((error) => {
+          persistFailure ??= error;
+        });
+        return task;
+      };
+
+      const schedulePersistExecutedRows = () => {
+        if (persistFailure) return;
+        if (
+          pendingPersistRows >= MAP_INCREMENTAL_PERSIST_CHUNK_ROWS ||
+          pendingPersistBytes >= MAP_INCREMENTAL_PERSIST_CHUNK_BYTES
+        ) {
+          void enqueuePersistExecutedRows().catch(() => undefined);
+          return;
+        }
+        if (scheduledPersistTimer) return;
+        scheduledPersistTimer = setTimeout(() => {
+          scheduledPersistTimer = null;
+          void enqueuePersistExecutedRows().catch(() => undefined);
+        }, MAP_INCREMENTAL_PERSIST_INTERVAL_MS);
+      };
+
+      const notePersistableRow = (row: Record<string, unknown>) => {
+        pendingPersistRows += 1;
+        pendingPersistBytes += JSON.stringify(row).length;
+        schedulePersistExecutedRows();
+      };
+
       let idx = 0;
       const workers: Array<Promise<void>> = [];
       for (let w = 0; w < concurrency; w += 1) {
@@ -4025,6 +4175,7 @@ function createMinimalWorkerCtx(
                   executedRows[myIndex] = enriched as T &
                     Record<string, unknown>;
                   completedExecutedRows += 1;
+                  notePersistableRow(enriched);
                   reportChunkProgress(false);
                 } catch (rowError) {
                   // Abort/budget errors stay run-fatal and leave no partial
@@ -4045,19 +4196,19 @@ function createMinimalWorkerCtx(
                     Object.keys(cellMetaPatch).length > 0
                       ? cellMetaPatch
                       : undefined;
-                  // Keep the partially-enriched row so its already-succeeded
-                  // sibling cells (e.g. a contact column that ran before the
-                  // failing column) persist as a recoverable `_status='failed'`
-                  // sheet row. This holds for BOTH the default isolation path
-                  // (row re-executes free on the next run) AND `onRowError:
-                  // 'fail'`: the chunk still persists every recorded row, so the
-                  // failed run advertises a working recovered export even when
-                  // every row fails (see the runMap-level fail-fast throw).
+                  // Keep the partially-enriched row. Default isolation persists
+                  // it as `_status='failed'` so the row can re-execute free on
+                  // the next run. Fail-fast persists failed rows only after the
+                  // chunk settles and only when every row failed; otherwise only
+                  // fully committed successful rows are recoverable.
                   failedRowEntries[myIndex] = {
                     row: enriched as T & Record<string, unknown>,
                     error: message,
                   };
                   failedExecutedRows += 1;
+                  if (!failFastRowErrors) {
+                    notePersistableRow(enriched);
+                  }
                   // Bounded per-chunk samples: every failure is persisted on
                   // its row, but only the first few get a log line so a wide
                   // outage cannot flood the Run Log Stream.
@@ -4069,7 +4220,7 @@ function createMinimalWorkerCtx(
                         `Row ${absoluteIndex} of ctx.dataset("${name}") failed` +
                         `${activeField ? ` at column "${activeField}"` : ''}: ${message} ` +
                         (failFastRowErrors
-                          ? '(row persisted as failed; onRowError:"fail" fails the run after committing it)'
+                          ? '(row recorded as failed; onRowError:"fail" persists it only if every row fails)'
                           : '(row recorded as failed; sibling rows continue and the row re-executes on the next run)'),
                       ts: nowMs(),
                     });
@@ -4098,93 +4249,6 @@ function createMinimalWorkerCtx(
           })(),
         );
       }
-      const persistExecutedRows = async () => {
-        const rowsToPersist = executedRows
-          .map((row, executedIndex) =>
-            row
-              ? {
-                  row,
-                  executedIndex,
-                }
-              : null,
-          )
-          .filter(
-            (
-              entry,
-            ): entry is {
-              row: T & Record<string, unknown>;
-              executedIndex: number;
-            } => entry !== null,
-          );
-        const allFailedRowsToPersist = failedRowEntries
-          .map((failure, executedIndex) =>
-            failure
-              ? {
-                  failure,
-                  executedIndex,
-                }
-              : null,
-          )
-          .filter(
-            (
-              entry,
-            ): entry is {
-              failure: { row: T & Record<string, unknown>; error: string };
-              executedIndex: number;
-            } => entry !== null,
-          );
-        // Under the default isolation, every failed row persists as a
-        // recoverable `_status='failed'` row (it re-executes free next run).
-        // Under `onRowError: 'fail'` the run dies, so a failed row's partial
-        // data is persisted ONLY as a last-resort recovery: when this chunk has
-        // no other recoverable rows (no successful executed rows and no
-        // already-completed rows). That keeps a partial fail-fast run's export
-        // to the rows that fully committed before the failure, while an
-        // all-rows-failed fail-fast run still exposes the persisted partial
-        // cells instead of advertising an empty, unrecoverable dataset.
-        const failedRowsToPersist =
-          failFastRowErrors &&
-          (rowsToPersist.length > 0 || prepared.completedRows.length > 0)
-            ? []
-            : allFailedRowsToPersist;
-        if (rowsToPersist.length === 0 && failedRowsToPersist.length === 0) {
-          return;
-        }
-        await persistCompletedMapRows({
-          req,
-          tableNamespace: name,
-          outputFields,
-          extraOutputFields: Array.from(generatedOutputFields),
-          rows: [
-            ...rowsToPersist.map(({ row, executedIndex }) => ({
-              ...row,
-              ...(executedCellMetaPatches[executedIndex]
-                ? {
-                    __deeplineCellMetaPatch:
-                      executedCellMetaPatches[executedIndex],
-                  }
-                : {}),
-              __deeplineRowKey:
-                uniqueRowsToExecuteEntries[executedIndex]!.rowKey,
-            })),
-            // Failed rows persist as recoverable `_status='failed'` sheet
-            // rows: partial data + per-cell failure meta + the row error.
-            ...failedRowsToPersist.map(({ failure, executedIndex }) => ({
-              ...failure.row,
-              ...(executedCellMetaPatches[executedIndex]
-                ? {
-                    __deeplineCellMetaPatch:
-                      executedCellMetaPatches[executedIndex],
-                  }
-                : {}),
-              __deeplineRowKey:
-                uniqueRowsToExecuteEntries[executedIndex]!.rowKey,
-              __deeplineRowStatus: 'failed',
-              __deeplineRowError: failure.error,
-            })),
-          ],
-        });
-      };
       const workersStartedAt = nowMs();
       // Track completion with a boolean flag rather than narrowing a
       // closure-assigned `| null` variable: TypeScript's control-flow analysis
@@ -4230,7 +4294,9 @@ function createMinimalWorkerCtx(
         },
       });
       try {
-        await persistExecutedRows();
+        await enqueuePersistExecutedRows();
+        await persistFlushChain;
+        if (persistFailure) throw persistFailure;
         recordRunnerPerfTrace({
           req,
           phase: 'runner.map_chunk.persist_rows',

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

@@ -30,19 +30,29 @@ export async function executeChunkedRequests<TRequest, TResult>(input: {
   const results: Array<ChunkExecutionResult<TRequest, TResult>> = [];
   for (let start = 0; start < input.requests.length; start += input.batchSize) {
     const chunk = input.requests.slice(start, start + input.batchSize);
-    const settled = await Promise.allSettled(
-      chunk.map((request) => input.execute(request)),
+    let notifyChain: Promise<void> = Promise.resolve();
+    const notify = async (
+      entry: ChunkExecutionResult<TRequest, TResult>,
+    ): Promise<void> => {
+      results.push(entry);
+      notifyChain = notifyChain.then(
+        async () => await input.onChunkComplete?.([entry]),
+      );
+      await notifyChain;
+    };
+
+    await Promise.all(
+      chunk.map(async (request) => {
+        let entry: ChunkExecutionResult<TRequest, TResult>;
+        try {
+          entry = { request, result: await input.execute(request) };
+        } catch (error) {
+          entry = { request, result: null, error };
+        }
+        await notify(entry);
+      }),
     );
-    for (let index = 0; index < chunk.length; index += 1) {
-      const request = chunk[index]!;
-      const outcome = settled[index]!;
-      if (outcome.status === 'rejected') {
-        results.push({ request, result: null, error: outcome.reason });
-        continue;
-      }
-      results.push({ request, result: outcome.value });
-    }
-    await input.onChunkComplete?.(results.slice(results.length - chunk.length));
+    await notifyChain;
   }
   return results;
 }

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

@@ -101,10 +101,10 @@ export const SDK_RELEASE = {
   // 0.1.108 ships explicit dataset column/tool recompute policy and removes
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
-  version: '0.1.131',
+  version: '0.1.132',
   apiContract: '2026-06-dataset-column-cell-stale-hard-cutover',
   supportPolicy: {
-    latest: '0.1.131',
+    latest: '0.1.132',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

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

@@ -45,30 +45,37 @@ export async function executeChunkedRequests<TRequest, TResult>(input: {
 
   for (let start = 0; start < input.requests.length; start += input.batchSize) {
     const chunk = input.requests.slice(start, start + input.batchSize);
-    const settled = await Promise.allSettled(
-      chunk.map((request) => input.execute(request)),
-    );
-
-    for (let index = 0; index < chunk.length; index += 1) {
-      const request = chunk[index]!;
-      const outcome = settled[index]!;
-      if (outcome.status === 'rejected') {
-        input.onRequestError?.(request, outcome.reason);
-        results.push({
-          request,
-          result: null,
-          error: formatChunkExecutionError(outcome.reason),
-        });
-        continue;
-      }
-      results.push({
-        request,
-        result: outcome.value,
-      });
-    }
+    let notifyChain: Promise<void> = Promise.resolve();
+    const notify = async (
+      entry: ChunkExecutionResult<TRequest, TResult>,
+    ): Promise<void> => {
+      results.push(entry);
+      notifyChain = notifyChain.then(
+        async () => await input.onChunkComplete?.([entry]),
+      );
+      await notifyChain;
+    };
 
-    const completedChunk = results.slice(results.length - chunk.length);
-    await input.onChunkComplete?.(completedChunk);
+    await Promise.all(
+      chunk.map(async (request) => {
+        let entry: ChunkExecutionResult<TRequest, TResult>;
+        try {
+          entry = {
+            request,
+            result: await input.execute(request),
+          };
+        } catch (error) {
+          input.onRequestError?.(request, error);
+          entry = {
+            request,
+            result: null,
+            error: formatChunkExecutionError(error),
+          };
+        }
+        await notify(entry);
+      }),
+    );
+    await notifyChain;
   }
 
   return results;

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

@@ -168,6 +168,9 @@ const MAP_FRAME_FLUSH_ROW_INTERVAL = 100;
 /** Executed-row sheet persistence chunking: rows AND bytes, whichever first. */
 const MAP_PERSIST_CHUNK_ROWS = 2_000;
 const MAP_PERSIST_CHUNK_BYTES = 8 * 1024 * 1024;
+const MAP_INCREMENTAL_PERSIST_CHUNK_ROWS = 100;
+const MAP_INCREMENTAL_PERSIST_CHUNK_BYTES = 1 * 1024 * 1024;
+const MAP_INCREMENTAL_PERSIST_INTERVAL_MS = 100;
 const MAP_FRAME_FLUSH_INTERVAL_MS = 250;
 const TOOL_RETRY_AFTER_FALLBACK_MS = 1_000;
 const TOOL_RETRY_HEARTBEAT_INTERVAL_MS = 30_000;
@@ -219,11 +222,143 @@ function comparePersistableMapRowsByInputIndex(
   return leftIndex - rightIndex;
 }
 
+function persistableMapRowIdentity(row: PersistableMapRow): string | null {
+  if (row.key) return `key:${row.key}`;
+  return typeof row.inputIndex === 'number' && Number.isFinite(row.inputIndex)
+    ? `index:${Math.floor(row.inputIndex)}`
+    : null;
+}
+
+function persistableMapRowBytes(row: PersistableMapRow): number {
+  return JSON.stringify(row).length;
+}
+
 type FieldMapRunResult = {
   completedRows: PersistableMapRow[];
   failedRows: PersistableMapRow[];
 };
 
+type IncrementalMapRowPersistence = {
+  persistRows: (rows: PersistableMapRow[]) => Promise<void>;
+  isPersisted: (row: PersistableMapRow) => boolean;
+  flush: () => Promise<void>;
+};
+
+function createIncrementalMapRowPersistence(
+  persistRows: (rows: PersistableMapRow[]) => Promise<void>,
+): IncrementalMapRowPersistence {
+  const persisted = new Set<string>();
+  const queued = new Set<string>();
+  let pendingRows: PersistableMapRow[] = [];
+  let pendingBytes = 0;
+  let pendingResolvers: Array<{
+    resolve: () => void;
+    reject: (error: unknown) => void;
+  }> = [];
+  let scheduledTimer: ReturnType<typeof setTimeout> | null = null;
+  let flushChain: Promise<void> = Promise.resolve();
+
+  const clearScheduledTimer = (): void => {
+    if (scheduledTimer) {
+      clearTimeout(scheduledTimer);
+      scheduledTimer = null;
+    }
+  };
+
+  const flushPendingRows = (): Promise<void> => {
+    clearScheduledTimer();
+    const rows = pendingRows;
+    const resolvers = pendingResolvers;
+    pendingRows = [];
+    pendingBytes = 0;
+    pendingResolvers = [];
+    if (rows.length === 0) {
+      resolvers.forEach(({ resolve }) => resolve());
+      return flushChain;
+    }
+    flushChain = flushChain
+      .then(async () => {
+        await persistRows(rows);
+        for (const row of rows) {
+          const identity = persistableMapRowIdentity(row);
+          if (identity) {
+            persisted.add(identity);
+            queued.delete(identity);
+          }
+        }
+      })
+      .then(
+        () => {
+          resolvers.forEach(({ resolve }) => resolve());
+        },
+        (error) => {
+          for (const row of rows) {
+            const identity = persistableMapRowIdentity(row);
+            if (identity) queued.delete(identity);
+          }
+          resolvers.forEach(({ reject }) => reject(error));
+          throw error;
+        },
+      );
+    return flushChain;
+  };
+
+  const scheduleFlush = (): void => {
+    if (scheduledTimer) return;
+    scheduledTimer = setTimeout(() => {
+      scheduledTimer = null;
+      void flushPendingRows().catch(() => {
+        // Each queued caller is rejected by flushPendingRows; this scheduled
+        // fire-and-forget path must not create a second unhandled rejection.
+      });
+    }, MAP_INCREMENTAL_PERSIST_INTERVAL_MS);
+  };
+
+  return {
+    persistRows: async (rows) => {
+      const freshRows: PersistableMapRow[] = [];
+      for (const row of rows) {
+        const identity = persistableMapRowIdentity(row);
+        if (identity && (persisted.has(identity) || queued.has(identity))) {
+          continue;
+        }
+        if (identity) queued.add(identity);
+        freshRows.push(row);
+      }
+      if (freshRows.length === 0) return;
+      await new Promise<void>((resolve, reject) => {
+        pendingRows.push(...freshRows);
+        pendingBytes += freshRows.reduce(
+          (total, row) => total + persistableMapRowBytes(row),
+          0,
+        );
+        pendingResolvers.push({ resolve, reject });
+        if (
+          pendingRows.length >= MAP_INCREMENTAL_PERSIST_CHUNK_ROWS ||
+          pendingBytes >= MAP_INCREMENTAL_PERSIST_CHUNK_BYTES
+        ) {
+          void flushPendingRows().catch(() => {
+            // Each queued caller is rejected by flushPendingRows.
+          });
+          return;
+        }
+        scheduleFlush();
+      });
+    },
+    isPersisted: (row) => {
+      const identity = persistableMapRowIdentity(row);
+      return identity ? persisted.has(identity) : false;
+    },
+    flush: async () => {
+      if (pendingRows.length > 0) {
+        clearScheduledTimer();
+        await flushPendingRows();
+      }
+      await flushChain;
+    },
+  };
+}
+
 class FailFastMapRowsError extends Error {
   readonly completedRows: PersistableMapRow[];
   readonly failedRows: PersistableMapRow[];
@@ -1819,6 +1954,7 @@ export class PlayContextImpl {
     let totalInputCount = 0;
     let rawItems: Record<string, unknown>[] = [];
     let itemsToProcess: Array<Record<string, unknown>> = [];
+    let itemOriginalIndexes: number[] = [];
     let completedItemsByKey: Map<string, Record<string, unknown>> | null = null;
     const datasetColumnNames = Object.keys(input);
     const stripFieldOutputs = (row: Record<string, unknown>) => {
@@ -1923,6 +2059,7 @@ export class PlayContextImpl {
     itemsToProcess = materializedItems.map((item) =>
       this.toOutputRow(item as Record<string, unknown>),
     );
+    itemOriginalIndexes = materializedItems.map((_item, index) => index);
     if (this.#options.onMapStart) {
       const shouldPassRowKey = explicitKeyResolver != null;
       // toSerializableCsvAliasedRow (not a plain spread): projected CSV
@@ -1968,7 +2105,7 @@ export class PlayContextImpl {
         const rowKey = persistedRowIdentity(row, index);
         if (rowKey) pendingRowsByKey.set(rowKey, row);
       }
-      itemsToProcess = materializedItems
+      const pendingItems = materializedItems
         .map((item, index) => ({
           row: this.toOutputRow(item as Record<string, unknown>),
           index,
@@ -1981,8 +2118,13 @@ export class PlayContextImpl {
           // the sheet round-trip. Merge the persisted data/meta over the
           // in-memory row so key functions and column resolvers keep seeing
           // projected aliases.
-          return persisted ? cloneCsvAliasedRow(row, persisted) : row;
+          return {
+            row: persisted ? cloneCsvAliasedRow(row, persisted) : row,
+            index,
+          };
         });
+      itemsToProcess = pendingItems.map((item) => item.row);
+      itemOriginalIndexes = pendingItems.map((item) => item.index);
       if (mapStartResult.completedRows.length > 0) {
         completedItemsByKey = new Map();
         for (
@@ -2008,7 +2150,7 @@ export class PlayContextImpl {
     const completedRowKeys =
       completedItemsByKey != null ? [...completedItemsByKey.keys()] : [];
     const pendingRowKeys = itemsToProcess.map((item, index) =>
-      rowIdentity(this.toOutputRow(item), index),
+      rowIdentity(this.toOutputRow(item), itemOriginalIndexes[index] ?? index),
     );
     this.setMapFrame({
       mapInvocationId: mapScope.mapInvocationId,
@@ -2040,9 +2182,10 @@ export class PlayContextImpl {
     >();
     for (let index = 0; index < itemsToProcess.length; index += 1) {
       const row = itemsToProcess[index]!;
-      const rowKey = rowIdentity(row, index);
+      const originalIndex = itemOriginalIndexes[index] ?? index;
+      const rowKey = rowIdentity(row, originalIndex);
       if (!rowsToExecuteByKey.has(rowKey)) {
-        rowsToExecuteByKey.set(rowKey, { row, originalIndex: index });
+        rowsToExecuteByKey.set(rowKey, { row, originalIndex });
       }
     }
     const rowsToExecuteEntries = [...rowsToExecuteByKey.entries()].map(
@@ -2090,6 +2233,9 @@ export class PlayContextImpl {
       }
       await flushChunk();
     };
+    const incrementalPersistence = this.#options.onMapRowsCompleted
+      ? createIncrementalMapRowPersistence(persistMapRows)
+      : null;
 
     let mapResult: FieldMapRunResult;
     try {
@@ -2108,6 +2254,7 @@ export class PlayContextImpl {
           executionRowIndexes: rowsToExecuteEntries.map(
             (entry) => entry.originalIndex,
           ),
+          incrementalPersistence,
         },
       );
     } catch (error) {
@@ -2116,11 +2263,17 @@ export class PlayContextImpl {
           error.completedRows.length > 0
             ? error.completedRows
             : error.failedRows;
+        await incrementalPersistence?.flush();
+        const unpersistedRows = incrementalPersistence
+          ? rowsToPersist.filter(
+              (row) => !incrementalPersistence.isPersisted(row),
+            )
+          : rowsToPersist;
         const persistStartedAt = Date.now();
-        await persistMapRows(rowsToPersist);
-        if (rowsToPersist.length > 0) {
+        await persistMapRows(unpersistedRows);
+        if (unpersistedRows.length > 0) {
           this.log(
-            `Persisted ${rowsToPersist.length} fail-fast rows to sheet ${resolvedTableNamespace} in ${Date.now() - persistStartedAt}ms`,
+            `Persisted ${unpersistedRows.length} fail-fast rows to sheet ${resolvedTableNamespace} in ${Date.now() - persistStartedAt}ms`,
           );
         }
         this.activeMapCellMeta = null;
@@ -2164,9 +2317,11 @@ export class PlayContextImpl {
     // source of truth, not this in-memory results array. Chunked by rows AND
     // bytes so large cells (scraped pages) never produce oversized writes.
     if (resultsByKey.size > 0 || mapResult.failedRows.length > 0) {
+      await incrementalPersistence?.flush();
       const mapCellMeta = this.activeMapCellMeta;
       const persistRows: PersistableMapRow[] = [];
       for (const row of mapResult.completedRows) {
+        if (incrementalPersistence?.isPersisted(row)) continue;
         const rowKey = row.key;
         const meta = mapCellMeta?.get(rowKey);
         persistRows.push({
@@ -2178,12 +2333,18 @@ export class PlayContextImpl {
           },
         });
       }
-      persistRows.push(...mapResult.failedRows);
+      persistRows.push(
+        ...mapResult.failedRows.filter(
+          (row) => !incrementalPersistence?.isPersisted(row),
+        ),
+      );
       const persistStartedAt = Date.now();
       await persistMapRows(persistRows);
-      this.log(
-        `Persisted ${persistRows.length} executed rows to sheet ${resolvedTableNamespace} in ${Date.now() - persistStartedAt}ms`,
-      );
+      if (persistRows.length > 0) {
+        this.log(
+          `Persisted ${persistRows.length} executed rows to sheet ${resolvedTableNamespace} in ${Date.now() - persistStartedAt}ms`,
+        );
+      }
     }
     this.activeMapCellMeta = null;
 
@@ -2255,6 +2416,7 @@ export class PlayContextImpl {
        * want to throttle a wide map.
        */
       concurrency?: number;
+      incrementalPersistence?: IncrementalMapRowPersistence | null;
     },
   ): Promise<FieldMapRunResult> {
     const fieldEntries = Object.entries(definition);
@@ -2299,6 +2461,14 @@ export class PlayContextImpl {
     const failFastOnRowError = runtimeOptions?.onRowError === 'fail';
     const completedRowsToPersist: PersistableMapRow[] = [];
     const failedRowsToPersist: PersistableMapRow[] = [];
+    const incrementalPersistence =
+      runtimeOptions?.incrementalPersistence ?? null;
+    const enqueueIncrementalPersist = (row: PersistableMapRow): void => {
+      void incrementalPersistence?.persistRows([row]).catch(() => {
+        // The final map-level flush awaits the same chain and surfaces the
+        // persistence failure loudly without holding a completed row slot open.
+      });
+    };
 
     if (completedRows > 0 || pendingRows !== totalRows) {
       this.log(
@@ -2605,7 +2775,7 @@ export class PlayContextImpl {
                 : {},
             });
             if (failFastOnRowError) {
-              failedRowsToPersist.push({
+              const failedRow: PersistableMapRow = {
                 key: rowKey,
                 inputIndex: rowIndex,
                 data: this.toPersistedOutputRow(
@@ -2616,21 +2786,23 @@ export class PlayContextImpl {
                   : {}),
                 status: 'failed',
                 error: formattedError,
-              });
+              };
+              failedRowsToPersist.push(failedRow);
               throw error;
             }
             const failedData = this.toPersistedOutputRow(
               cloneCsvAliasedRow(baseRow, computedFields),
             );
             const cellMetaPatch = this.activeMapCellMeta?.get(rowKey);
-            failedRowsToPersist.push({
+            const failedRow: PersistableMapRow = {
               key: rowKey,
               inputIndex: rowIndex,
               data: failedData,
               ...(cellMetaPatch ? { cellMetaPatch } : {}),
               status: 'failed',
               error: formattedError,
-            });
+            };
+            failedRowsToPersist.push(failedRow);
             updateMapFrameProgress({
               failedRowKey: rowKey,
             });
@@ -2642,6 +2814,7 @@ export class PlayContextImpl {
               error: formattedError,
               dataPatch: {},
             });
+            enqueueIncrementalPersist(failedRow);
             return FAILED_ROW;
           }
           const cellValue = this.serializeCellValue(value);
@@ -2682,14 +2855,16 @@ export class PlayContextImpl {
           dataPatch: {},
         });
         const publicRow = this.toPublicOutputRow(merged);
-        completedRowsToPersist.push({
+        const completedRow: PersistableMapRow = {
           key: rowKey,
           inputIndex: rowIndex,
           data: this.toPersistedOutputRow(merged),
           ...(this.activeMapCellMeta?.get(rowKey)
             ? { cellMetaPatch: this.activeMapCellMeta.get(rowKey) }
             : {}),
-        });
+        };
+        completedRowsToPersist.push(completedRow);
+        enqueueIncrementalPersist(completedRow);
         return publicRow;
       } catch (error) {
         if (isPlayRowExecutionSuspendedError(error)) {
@@ -2807,6 +2982,7 @@ export class PlayContextImpl {
         ).values(),
       ];
       this.pendingRowEventBoundaries = [];
+      await incrementalPersistence?.flush();
       this.#options.onBatchComplete?.(this.checkpoint);
       throw new PlayExecutionSuspendedError({
         kind: 'integration_event_batch',
@@ -4960,7 +5136,42 @@ export class PlayContextImpl {
       [...byTool.entries()].map(async ([toolId, requests]) => {
         this.log(`Executing tool batch ${toolId}: ${requests.length} calls`);
 
+        const recordToolStep = (stepRequests: ToolCallRequest[]): void => {
+          if (stepRequests.length === 0) return;
+          const stepResults: PlayStepRowResult[] = stepRequests.map((req) => {
+            const cachedResult = this.getCachedToolResult(
+              toolId,
+              this.buildToolResultCacheKey({
+                rowId: req.rowId,
+                tableNamespace: req.tableNamespace,
+                rowKey: req.rowKey ?? undefined,
+                callId: req.callId,
+              }),
+            );
+            return {
+              rowId: req.rowId,
+              status: cachedResult?.result != null ? 'completed' : 'failed',
+              success: cachedResult?.result != null,
+              value: cachedResult?.result,
+              error: cachedResult?.result != null ? null : 'Tool call failed',
+            };
+          });
+          const toolStep = {
+            type: 'tool' as const,
+            toolId,
+            // Keep the step trace preview-sized for large map pages.
+            results: compactRowResultsPreview(stepResults),
+            description: normalizeStepDescription(stepRequests[0]?.description),
+          };
+          if (this.activeDatasetStep) {
+            this.activeDatasetStep.substeps.push(toolStep);
+          } else {
+            this.steps.push(toolStep);
+          }
+        };
+
         const pendingRequests: ToolCallRequest[] = [];
+        const recoveredRequests: ToolCallRequest[] = [];
         for (const req of requests) {
           const cached = this.getCachedToolResult(
             toolId,
@@ -4978,10 +5189,12 @@ export class PlayContextImpl {
               resolver.resolve(cached.result);
               this.toolCallResolvers.delete(req.callId);
             }
+            recoveredRequests.push(req);
           } else {
             pendingRequests.push(req);
           }
         }
+        recordToolStep(recoveredRequests);
 
         if (pendingRequests.length > 0) {
           const strategy =
@@ -5001,49 +5214,47 @@ export class PlayContextImpl {
                     4,
                   )
                 : 4;
-            for (
-              let start = 0;
-              start < compiledBatches.length;
-              start += batchSize
-            ) {
-              const chunk = compiledBatches.slice(start, start + batchSize);
-              const settled = await Promise.allSettled(
-                chunk.map((batch) =>
-                  this.callToolAPI(batch.batchOperation, batch.batchPayload),
+            await executeChunkedRequests({
+              requests: compiledBatches,
+              batchSize,
+              execute: async (batch) =>
+                await this.callToolAPI(
+                  batch.batchOperation,
+                  batch.batchPayload,
                 ),
-              );
-
-              for (let index = 0; index < chunk.length; index += 1) {
-                const requestBatch = chunk[index]!;
-                const outcome = settled[index]!;
-                if (outcome.status === 'fulfilled') {
+              onChunkComplete: async (chunkResults) => {
+                for (const entry of chunkResults) {
+                  if (entry.error !== undefined) {
+                    for (const request of entry.request.memberRequests) {
+                      this.rejectToolCall(toolId, request, entry.error);
+                    }
+                    continue;
+                  }
                   const splitResults =
-                    outcome.value != null
-                      ? requestBatch.splitResults(outcome.value)
-                      : requestBatch.memberRequests.map(() => null);
+                    entry.result != null
+                      ? entry.request.splitResults(entry.result)
+                      : entry.request.memberRequests.map(() => null);
 
                   for (
                     let index = 0;
-                    index < requestBatch.memberRequests.length;
+                    index < entry.request.memberRequests.length;
                     index += 1
                   ) {
-                    const request = requestBatch.memberRequests[index]!;
+                    const request = entry.request.memberRequests[index]!;
                     await this.resolveToolCall(
                       toolId,
                       request,
                       splitResults[index] ?? null,
                     );
                   }
-                  continue;
                 }
 
-                for (const request of requestBatch.memberRequests) {
-                  this.rejectToolCall(toolId, request, outcome.reason);
-                }
-              }
-
-              this.#options.onBatchComplete?.(this.checkpoint);
-            }
+                recordToolStep(
+                  chunkResults.flatMap((entry) => entry.request.memberRequests),
+                );
+                this.#options.onBatchComplete?.(this.checkpoint);
+              },
+            });
           } else {
             const batchSize = await this.governor.suggestedParallelism(
               toolId,
@@ -5055,66 +5266,32 @@ export class PlayContextImpl {
               start += batchSize
             ) {
               const chunk = pendingRequests.slice(start, start + batchSize);
-              const settled = await Promise.allSettled(
-                chunk.map((request) =>
-                  this.callToolExecutionAPI(toolId, request.input),
-                ),
+              await Promise.allSettled(
+                chunk.map(async (request) => {
+                  try {
+                    const execution = await this.callToolExecutionAPI(
+                      toolId,
+                      request.input,
+                    );
+                    await this.resolveToolCall(
+                      toolId,
+                      request,
+                      execution?.result ?? null,
+                      execution?.metadata ?? null,
+                      execution?.jobId,
+                      execution?.meta,
+                    );
+                  } catch (error) {
+                    this.rejectToolCall(toolId, request, error);
+                  }
+                }),
               );
 
-              for (let index = 0; index < chunk.length; index += 1) {
-                const request = chunk[index]!;
-                const outcome = settled[index]!;
-                if (outcome.status === 'fulfilled') {
-                  await this.resolveToolCall(
-                    toolId,
-                    request,
-                    outcome.value?.result ?? null,
-                    outcome.value?.metadata ?? null,
-                    outcome.value?.jobId,
-                    outcome.value?.meta,
-                  );
-                  continue;
-                }
-
-                this.rejectToolCall(toolId, request, outcome.reason);
-              }
-
+              recordToolStep(chunk);
               this.#options.onBatchComplete?.(this.checkpoint);
             }
           }
         }
-
-        // Record step — nest under map if inside one
-        const stepResults: PlayStepRowResult[] = requests.map((req) => {
-          const cachedResult = this.getCachedToolResult(
-            toolId,
-            this.buildToolResultCacheKey({
-              rowId: req.rowId,
-              tableNamespace: req.tableNamespace,
-              rowKey: req.rowKey ?? undefined,
-              callId: req.callId,
-            }),
-          );
-          return {
-            rowId: req.rowId,
-            status: cachedResult?.result != null ? 'completed' : 'failed',
-            success: cachedResult?.result != null,
-            value: cachedResult?.result,
-            error: cachedResult?.result != null ? null : 'Tool call failed',
-          };
-        });
-        const toolStep = {
-          type: 'tool' as const,
-          toolId,
-          // Keep the step trace preview-sized for large map pages.
-          results: compactRowResultsPreview(stepResults),
-          description: normalizeStepDescription(requests[0]?.description),
-        };
-        if (this.activeDatasetStep) {
-          this.activeDatasetStep.substeps.push(toolStep);
-        } else {
-          this.steps.push(toolStep);
-        }
       }),
     );
   }

package/dist/cli/index.js

@@ -413,10 +413,10 @@ var SDK_RELEASE = {
   // 0.1.108 ships explicit dataset column/tool recompute policy and removes
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
-  version: "0.1.131",
+  version: "0.1.132",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.131",
+    latest: "0.1.132",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -5027,8 +5027,14 @@ function recentUsageLines(entries) {
     const op = `${humanize(entry.provider)} ${humanize(entry.operation)}`.trim();
     const charge = entry.billing_mode === "no_bill" ? "free" : `${entry.credits ?? 0} cr`;
     const state = entry.charge_state === "temporary_hold" ? "temporary hold, awaiting actual usage" : entry.status || "completed";
+    const auditBits = [
+      entry.outcome ? `outcome=${entry.outcome}` : null,
+      entry.pricing_basis ? `priced_by=${entry.pricing_basis}` : null,
+      entry.run_id ? `run=${entry.run_id}` : null,
+      entry.request_id ? `request=${entry.request_id}` : null
+    ].filter(Boolean);
     lines.push(
-      `${op} | ${charge} | ${state} | ${entry.created_at || "unknown"}`
+      `${op} | ${charge} | ${state}${auditBits.length > 0 ? ` | ${auditBits.join(" | ")}` : ""} | ${entry.created_at || "unknown"}`
     );
   }
   return lines;
@@ -5045,14 +5051,24 @@ function summarizeLedgerRows(summary, rows) {
 }
 function ledgerApiEntryToRow(entry) {
   const metadata = typeof entry.metadata === "object" && entry.metadata !== null ? entry.metadata : {};
+  const audit = typeof entry.billing_audit === "object" && entry.billing_audit !== null ? entry.billing_audit : {};
   return {
     created_at: entry.created_at ?? "",
     delta_credits: entry.delta ?? "",
     reason: entry.reason ?? "",
-    provider: metadata.provider ?? "",
-    operation: metadata.operation ?? "",
-    request_id: metadata.requestId ?? metadata.request_id ?? "",
-    run_id: metadata.runId ?? metadata.run_id ?? "",
+    provider: entry.provider ?? audit.provider ?? metadata.provider ?? "",
+    operation: entry.operation ?? audit.operation ?? metadata.operation ?? "",
+    request_id: entry.request_id ?? audit.request_id ?? metadata.requestId ?? metadata.request_id ?? "",
+    run_id: entry.run_id ?? audit.run_id ?? metadata.runId ?? metadata.run_id ?? "",
+    billing_stage: entry.billing_stage ?? audit.billing_stage ?? metadata.billingStage ?? "",
+    charge_state: entry.charge_state ?? audit.charge_state ?? "",
+    billing_mode: entry.billing_mode ?? audit.billing_mode ?? metadata.billingMode ?? metadata.chargeMode ?? "",
+    pricing_model: entry.pricing_model ?? audit.pricing_model ?? metadata.pricingModel ?? "",
+    pricing_basis: entry.pricing_basis ?? audit.pricing_basis ?? "",
+    charge_credits: entry.charge_credits ?? audit.charge_credits ?? "",
+    outcome: entry.outcome ?? audit.outcome ?? "",
+    result_count: entry.result_count ?? audit.result_count ?? "",
+    deepline_rough_usd: entry.deepline_rough_usd ?? "",
     api_key_id: entry.api_key_id ?? "",
     stripe_session_id: entry.stripe_session_id ?? ""
   };
@@ -5068,6 +5084,15 @@ function ledgerRowsToCsv(rows, header) {
       "operation",
       "request_id",
       "run_id",
+      "billing_stage",
+      "charge_state",
+      "billing_mode",
+      "pricing_model",
+      "pricing_basis",
+      "charge_credits",
+      "outcome",
+      "result_count",
+      "deepline_rough_usd",
       "api_key_id",
       "stripe_session_id"
     ]
@@ -5246,6 +5271,7 @@ async function handleLedgerExportAll(options) {
   for (; ; ) {
     const params = new URLSearchParams({ limit: "5000" });
     if (cursor !== null) params.set("cursor", cursor);
+    if (options.runId) params.set("run_id", options.runId);
     const payload = await http.get(
       `/api/v2/billing/ledger?${params.toString()}`
     );
@@ -5273,13 +5299,14 @@ async function handleLedgerExportAll(options) {
       row_count: summary.row_count,
       net_delta_credits: summary.net_delta_credits,
       scope: "current_auth_context",
+      ...options.runId ? { run_id: options.runId } : {},
       render: {
         sections: [
           {
             title: "billing ledger",
             lines: [
               `Billing ledger written to ${outputPath}`,
-              `${summary.row_count} row(s) exported for the current auth context.`,
+              `${summary.row_count} row(s) exported for the current auth context${options.runId ? ` and run ${options.runId}` : ""}.`,
               `Net ledger delta: ${summary.net_delta_credits} Deepline Credits`
             ]
           }
@@ -5703,6 +5730,7 @@ Notes:
 Examples:
   deepline billing ledger export all
   deepline billing ledger export all --output ./ledger.csv
+  deepline billing ledger export all --run-id play/demo/run/abc123
   deepline billing ledger export all --json
 `
   ).addCommand(
@@ -5724,7 +5752,7 @@ Examples:
   deepline billing ledger export all
   deepline billing ledger export all --json
 `
-      ).option("--output <path>", "Write CSV to an explicit path").option(
+      ).option("--output <path>", "Write CSV to an explicit path").option("--run-id <run_id>", "Export ledger rows for one play run.").option(
         "--json",
         "Emit JSON output. Also automatic when stdout is piped"
       ).action(handleLedgerExportAll)

package/dist/cli/index.mjs

@@ -390,10 +390,10 @@ var SDK_RELEASE = {
   // 0.1.108 ships explicit dataset column/tool recompute policy and removes
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
-  version: "0.1.131",
+  version: "0.1.132",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.131",
+    latest: "0.1.132",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -5016,8 +5016,14 @@ function recentUsageLines(entries) {
     const op = `${humanize(entry.provider)} ${humanize(entry.operation)}`.trim();
     const charge = entry.billing_mode === "no_bill" ? "free" : `${entry.credits ?? 0} cr`;
     const state = entry.charge_state === "temporary_hold" ? "temporary hold, awaiting actual usage" : entry.status || "completed";
+    const auditBits = [
+      entry.outcome ? `outcome=${entry.outcome}` : null,
+      entry.pricing_basis ? `priced_by=${entry.pricing_basis}` : null,
+      entry.run_id ? `run=${entry.run_id}` : null,
+      entry.request_id ? `request=${entry.request_id}` : null
+    ].filter(Boolean);
     lines.push(
-      `${op} | ${charge} | ${state} | ${entry.created_at || "unknown"}`
+      `${op} | ${charge} | ${state}${auditBits.length > 0 ? ` | ${auditBits.join(" | ")}` : ""} | ${entry.created_at || "unknown"}`
     );
   }
   return lines;
@@ -5034,14 +5040,24 @@ function summarizeLedgerRows(summary, rows) {
 }
 function ledgerApiEntryToRow(entry) {
   const metadata = typeof entry.metadata === "object" && entry.metadata !== null ? entry.metadata : {};
+  const audit = typeof entry.billing_audit === "object" && entry.billing_audit !== null ? entry.billing_audit : {};
   return {
     created_at: entry.created_at ?? "",
     delta_credits: entry.delta ?? "",
     reason: entry.reason ?? "",
-    provider: metadata.provider ?? "",
-    operation: metadata.operation ?? "",
-    request_id: metadata.requestId ?? metadata.request_id ?? "",
-    run_id: metadata.runId ?? metadata.run_id ?? "",
+    provider: entry.provider ?? audit.provider ?? metadata.provider ?? "",
+    operation: entry.operation ?? audit.operation ?? metadata.operation ?? "",
+    request_id: entry.request_id ?? audit.request_id ?? metadata.requestId ?? metadata.request_id ?? "",
+    run_id: entry.run_id ?? audit.run_id ?? metadata.runId ?? metadata.run_id ?? "",
+    billing_stage: entry.billing_stage ?? audit.billing_stage ?? metadata.billingStage ?? "",
+    charge_state: entry.charge_state ?? audit.charge_state ?? "",
+    billing_mode: entry.billing_mode ?? audit.billing_mode ?? metadata.billingMode ?? metadata.chargeMode ?? "",
+    pricing_model: entry.pricing_model ?? audit.pricing_model ?? metadata.pricingModel ?? "",
+    pricing_basis: entry.pricing_basis ?? audit.pricing_basis ?? "",
+    charge_credits: entry.charge_credits ?? audit.charge_credits ?? "",
+    outcome: entry.outcome ?? audit.outcome ?? "",
+    result_count: entry.result_count ?? audit.result_count ?? "",
+    deepline_rough_usd: entry.deepline_rough_usd ?? "",
     api_key_id: entry.api_key_id ?? "",
     stripe_session_id: entry.stripe_session_id ?? ""
   };
@@ -5057,6 +5073,15 @@ function ledgerRowsToCsv(rows, header) {
       "operation",
       "request_id",
       "run_id",
+      "billing_stage",
+      "charge_state",
+      "billing_mode",
+      "pricing_model",
+      "pricing_basis",
+      "charge_credits",
+      "outcome",
+      "result_count",
+      "deepline_rough_usd",
       "api_key_id",
       "stripe_session_id"
     ]
@@ -5235,6 +5260,7 @@ async function handleLedgerExportAll(options) {
   for (; ; ) {
     const params = new URLSearchParams({ limit: "5000" });
     if (cursor !== null) params.set("cursor", cursor);
+    if (options.runId) params.set("run_id", options.runId);
     const payload = await http.get(
       `/api/v2/billing/ledger?${params.toString()}`
     );
@@ -5262,13 +5288,14 @@ async function handleLedgerExportAll(options) {
       row_count: summary.row_count,
       net_delta_credits: summary.net_delta_credits,
       scope: "current_auth_context",
+      ...options.runId ? { run_id: options.runId } : {},
       render: {
         sections: [
           {
             title: "billing ledger",
             lines: [
               `Billing ledger written to ${outputPath}`,
-              `${summary.row_count} row(s) exported for the current auth context.`,
+              `${summary.row_count} row(s) exported for the current auth context${options.runId ? ` and run ${options.runId}` : ""}.`,
               `Net ledger delta: ${summary.net_delta_credits} Deepline Credits`
             ]
           }
@@ -5692,6 +5719,7 @@ Notes:
 Examples:
   deepline billing ledger export all
   deepline billing ledger export all --output ./ledger.csv
+  deepline billing ledger export all --run-id play/demo/run/abc123
   deepline billing ledger export all --json
 `
   ).addCommand(
@@ -5713,7 +5741,7 @@ Examples:
   deepline billing ledger export all
   deepline billing ledger export all --json
 `
-      ).option("--output <path>", "Write CSV to an explicit path").option(
+      ).option("--output <path>", "Write CSV to an explicit path").option("--run-id <run_id>", "Export ledger rows for one play run.").option(
         "--json",
         "Emit JSON output. Also automatic when stdout is piped"
       ).action(handleLedgerExportAll)

package/dist/index.js

@@ -284,10 +284,10 @@ var SDK_RELEASE = {
   // 0.1.108 ships explicit dataset column/tool recompute policy and removes
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
-  version: "0.1.131",
+  version: "0.1.132",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.131",
+    latest: "0.1.132",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [

package/dist/index.mjs

@@ -206,10 +206,10 @@ var SDK_RELEASE = {
   // 0.1.108 ships explicit dataset column/tool recompute policy and removes
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
-  version: "0.1.131",
+  version: "0.1.132",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.131",
+    latest: "0.1.132",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.131",
+  "version": "0.1.132",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {