deepline 0.1.130 → 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.130',
+  version: '0.1.132',
   apiContract: '2026-06-dataset-column-cell-stale-hard-cutover',
   supportPolicy: {
-    latest: '0.1.130',
+    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;