deepline 0.1.225 → 0.1.227

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

@@ -6,6 +6,7 @@ const CLOUDFLARE_WORKFLOW_ENDPOINT_UNAVAILABLE_RE =
   /The requested endpoint could not be found, or you don't have access to it\. Please check the provided ID and try again\./i;
 const VERCEL_RUNTIME_API_DEPLOYMENT_MISSING_RE =
   /runtime API 404:[\s\S]*(?:DeploymentNotFound|DEPLOYMENT_NOT_FOUND|requested deployment .*exist|deployment could not be found on Vercel)/i;
+const RUNTIME_SANDBOX_LOST_RE = /\bRUNTIME_SANDBOX_LOST\b/i;
 
 export const PLATFORM_DEPLOY_INTERRUPTED_MESSAGE =
   'Run interrupted by a platform deploy. Deepline retries this automatically when possible; if this error is still visible, re-run the same command.';
@@ -16,6 +17,8 @@ export const PLATFORM_WORKFLOW_ENDPOINT_INTERRUPTED_MESSAGE =
 
 export const INTERNAL_RUNTIME_STORAGE_ERROR_MESSAGE =
   'Internal play runtime storage failed. Please retry the run; if this keeps happening, contact Deepline support with the run ID.';
+export const RUNTIME_SANDBOX_LOST_MESSAGE =
+  'The execution sandbox became unreachable before returning a terminal result. Re-run the same command; if this keeps happening, contact Deepline support with the run ID.';
 
 export const WORKSPACE_STORAGE_NOT_READY_CODE = 'WORKSPACE_STORAGE_NOT_READY';
 
@@ -90,11 +93,7 @@ export class ProviderExhaustedError extends Error {
   readonly provider: string;
   /** ISO 8601 retry deadline (from the server Retry-After / cooldown). */
   readonly retryAt: string;
-  constructor(input: {
-    provider: string;
-    retryAtMs: number;
-    cause?: unknown;
-  }) {
+  constructor(input: { provider: string; retryAtMs: number; cause?: unknown }) {
     // Prefix the code token so `String(error)` and any persisted error string
     // carry it across the serialization boundary back to the CLI, exactly like
     // WorkspaceStorageNotReadyError.
@@ -124,8 +123,7 @@ export class ProviderExhaustedError extends Error {
  */
 export function providerNameFromBucketId(bucketId: string): string {
   const separator = bucketId.indexOf(':');
-  const provider =
-    separator >= 0 ? bucketId.slice(separator + 1) : bucketId;
+  const provider = separator >= 0 ? bucketId.slice(separator + 1) : bucketId;
   return provider.startsWith('tool:')
     ? provider.slice('tool:'.length)
     : provider;
@@ -137,8 +135,66 @@ export type PlayRunFailureDetails = {
   message: string;
   retryable: boolean | null;
   cause?: string;
+  name?: string;
+  stack?: string;
+  causes?: string[];
 };
 
+const PUBLIC_FAILURE_STACK_LINE_LIMIT = 12;
+const PUBLIC_FAILURE_TEXT_BYTE_LIMIT = 64 * 1024;
+const PUBLIC_FAILURE_CAUSE_LIMIT = 8;
+const PUBLIC_FAILURE_CAUSE_LENGTH_LIMIT = 1_000;
+
+function boundedFailureText(value: string): string {
+  const encoder = new TextEncoder();
+  if (encoder.encode(value).byteLength <= PUBLIC_FAILURE_TEXT_BYTE_LIMIT) {
+    return value;
+  }
+  let bytes = 0;
+  let output = '';
+  for (const character of value) {
+    const characterBytes = encoder.encode(character).byteLength;
+    if (bytes + characterBytes > PUBLIC_FAILURE_TEXT_BYTE_LIMIT) break;
+    output += character;
+    bytes += characterBytes;
+  }
+  return `${output}\n[truncated]`;
+}
+
+function boundedFailureStack(error: Error): string | undefined {
+  if (typeof error.stack !== 'string' || !error.stack.trim()) return undefined;
+  return boundedFailureText(
+    error.stack.split('\n').slice(0, PUBLIC_FAILURE_STACK_LINE_LIMIT).join('\n'),
+  );
+}
+
+function failureCauseTexts(error: Error): string[] {
+  const queue: unknown[] = [];
+  const seen = new Set<unknown>([error]);
+  const causes: string[] = [];
+  const withCause = error as Error & { cause?: unknown };
+  if (withCause.cause !== undefined) queue.push(withCause.cause);
+  if (error instanceof AggregateError) queue.push(...error.errors);
+
+  while (queue.length > 0 && causes.length < PUBLIC_FAILURE_CAUSE_LIMIT) {
+    const current = queue.shift();
+    if (current === undefined || current === null || seen.has(current)) {
+      continue;
+    }
+    seen.add(current);
+    const text = toErrorText(current).trim();
+    if (text && text !== error.message && !causes.includes(text)) {
+      causes.push(text.slice(0, PUBLIC_FAILURE_CAUSE_LENGTH_LIMIT));
+    }
+    if (current instanceof Error) {
+      const nested = current as Error & { cause?: unknown };
+      if (nested.cause !== undefined) queue.push(nested.cause);
+      if (current instanceof AggregateError) queue.push(...current.errors);
+    }
+  }
+  return causes;
+}
+
 function toErrorText(error: unknown): string {
   if (error instanceof Error) {
     return error.message;
@@ -147,8 +203,23 @@ function toErrorText(error: unknown): string {
 }
 
 export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
-  const cause = toErrorText(error);
-  if (CLOUDFLARE_DURABLE_OBJECT_RESET_RE.test(cause)) {
+  const rawCause = toErrorText(error);
+  const cause = boundedFailureText(rawCause);
+  if (RUNTIME_SANDBOX_LOST_RE.test(rawCause)) {
+    const stack = error instanceof Error ? boundedFailureStack(error) : null;
+    const causes = error instanceof Error ? failureCauseTexts(error) : [];
+    return {
+      code: 'RUNTIME_SANDBOX_LOST',
+      phase: 'infrastructure',
+      message: RUNTIME_SANDBOX_LOST_MESSAGE,
+      retryable: true,
+      cause,
+      ...(error instanceof Error ? { name: error.name || 'Error' } : {}),
+      ...(stack ? { stack } : {}),
+      ...(causes.length > 0 ? { causes } : {}),
+    };
+  }
+  if (CLOUDFLARE_DURABLE_OBJECT_RESET_RE.test(rawCause)) {
     return {
       code: 'PLATFORM_DEPLOY_INTERRUPTED',
       phase: 'runtime',
@@ -157,7 +228,7 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
       cause,
     };
   }
-  if (VERCEL_RUNTIME_API_DEPLOYMENT_MISSING_RE.test(cause)) {
+  if (VERCEL_RUNTIME_API_DEPLOYMENT_MISSING_RE.test(rawCause)) {
     return {
       code: 'PLATFORM_DEPLOY_INTERRUPTED',
       phase: 'runtime',
@@ -166,7 +237,7 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
       cause,
     };
   }
-  if (CLOUDFLARE_WORKER_SUBREQUEST_LIMIT_RE.test(cause)) {
+  if (CLOUDFLARE_WORKER_SUBREQUEST_LIMIT_RE.test(rawCause)) {
     return {
       code: 'PLATFORM_WORKER_SUBREQUEST_INTERRUPTED',
       phase: 'runtime',
@@ -175,7 +246,7 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
       cause,
     };
   }
-  if (CLOUDFLARE_WORKFLOW_ENDPOINT_UNAVAILABLE_RE.test(cause)) {
+  if (CLOUDFLARE_WORKFLOW_ENDPOINT_UNAVAILABLE_RE.test(rawCause)) {
     return {
       code: 'PLATFORM_WORKFLOW_ENDPOINT_INTERRUPTED',
       phase: 'runtime',
@@ -184,7 +255,7 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
       cause,
     };
   }
-  const playDepthBudgetMatch = cause.match(
+  const playDepthBudgetMatch = rawCause.match(
     /Play execution playDepth budget exceeded \((\d+)\/(\d+)\)\./,
   );
   if (playDepthBudgetMatch) {
@@ -198,7 +269,7 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
   }
   if (
     error instanceof ProviderExhaustedError ||
-    /\bPROVIDER_EXHAUSTED\b/.test(cause)
+    /\bPROVIDER_EXHAUSTED\b/.test(rawCause)
   ) {
     // The human message (provider + retry time) already lives in `cause` after
     // the code token prefix; surface it verbatim minus the token so the run
@@ -218,7 +289,7 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
   }
   if (
     error instanceof WorkspaceStorageNotReadyError ||
-    /\bWORKSPACE_STORAGE_NOT_READY\b/.test(cause)
+    /\bWORKSPACE_STORAGE_NOT_READY\b/.test(rawCause)
   ) {
     return {
       code: WORKSPACE_STORAGE_NOT_READY_CODE,
@@ -242,10 +313,27 @@ export function normalizePlayRunFailure(error: unknown): PlayRunFailureDetails {
       retryable: true,
     };
   }
+  const diagnostics =
+    error instanceof Error
+      ? {
+          name: error.name || 'Error',
+          stack: boundedFailureStack(error),
+          causes: failureCauseTexts(error),
+        }
+      : null;
   return {
     code: 'RUN_FAILED',
     phase: 'runtime',
     message: cause,
     retryable: null,
+    ...(diagnostics
+      ? {
+          name: diagnostics.name,
+          ...(diagnostics.stack ? { stack: diagnostics.stack } : {}),
+          ...(diagnostics.causes.length > 0
+            ? { causes: diagnostics.causes }
+            : {}),
+        }
+      : {}),
   };
 }

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

@@ -78,6 +78,7 @@ export type PlayRunLedgerStepSnapshot = {
   label?: string;
   kind?: string;
   status: PlayRunLedgerStepStatus;
+  error?: string | null;
   artifactTableNamespace?: string | null;
   startedAt?: number | null;
   completedAt?: number | null;
@@ -480,6 +481,7 @@ export function normalizePlayRunLedgerSnapshot(
       label: optionalString(rawStep.label),
       kind: optionalString(rawStep.kind),
       status,
+      error: optionalNullableString(rawStep.error),
       artifactTableNamespace: optionalNullableString(
         rawStep.artifactTableNamespace,
       ),
@@ -1255,6 +1257,7 @@ export function reducePlayRunLedgerEvent(
         label: event.label ?? current?.label,
         kind: event.kind ?? current?.kind,
         status,
+        error: current?.error ?? null,
         artifactTableNamespace:
           progress?.artifactTableNamespace ??
           current?.artifactTableNamespace ??
@@ -1308,6 +1311,12 @@ export function reducePlayRunLedgerEvent(
         label: event.label ?? current?.label,
         kind: event.kind ?? current?.kind,
         status,
+        error:
+          event.type === 'step.failed'
+            ? (event.error ?? current?.error ?? null)
+            : preserveFailedStatus
+              ? (current?.error ?? null)
+              : null,
         artifactTableNamespace:
           event.artifactTableNamespace ??
           current?.artifactTableNamespace ??

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

@@ -46,6 +46,7 @@ export type PlayRunStreamNodeProgress = {
 export type PlayRunStreamNodeState = {
   nodeId: string;
   status: 'idle' | 'running' | 'completed' | 'failed' | 'skipped';
+  error?: string | null;
   artifactTableNamespace?: string | null;
   progress?: PlayRunStreamNodeProgress | null;
   startedAt?: number | null;
@@ -167,6 +168,7 @@ function buildSnapshotFromLedger(
     .map((step) => ({
       nodeId: step.stepId,
       status: step.status,
+      error: step.error ?? null,
       artifactTableNamespace: step.artifactTableNamespace ?? null,
       progress: step.progress
         ? {

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-payload-transport.ts

@@ -19,6 +19,7 @@ type DaytonaPayloadEnvelope = {
   schemaVersion: 1;
   runnerCode: string;
   artifactBundledCode: string;
+  artifactSourceMap: string;
   config: PlayRunnerExecutionConfig;
   /** Crash-containment epilogue script (see buildDaytonaCrashTerminalPusherSource). */
   crashPusherCode: string;
@@ -50,10 +51,11 @@ function nodeMaterializePayloadCommand(input: {
   runnerPath: string;
   configPath: string;
   artifactCodePath: string;
+  artifactSourceMapPath: string;
   crashPusherPath: string;
 }): string {
   const script =
-    "const fs=require('node:fs');const zlib=require('node:zlib');const p=JSON.parse(zlib.gunzipSync(fs.readFileSync(process.argv[1])));if(p.schemaVersion!==1)throw new Error('Unsupported Daytona payload envelope');fs.writeFileSync(process.argv[2],p.runnerCode);fs.writeFileSync(process.argv[3],JSON.stringify(p.config));fs.writeFileSync(process.argv[4],p.artifactBundledCode);fs.writeFileSync(process.argv[5],p.crashPusherCode);";
+    "const fs=require('node:fs');const zlib=require('node:zlib');const p=JSON.parse(zlib.gunzipSync(fs.readFileSync(process.argv[1])));if(p.schemaVersion!==1)throw new Error('Unsupported Daytona payload envelope');fs.writeFileSync(process.argv[2],p.runnerCode);fs.writeFileSync(process.argv[3],JSON.stringify(p.config));fs.writeFileSync(process.argv[4],p.artifactBundledCode);fs.writeFileSync(process.argv[5],p.artifactSourceMap);fs.writeFileSync(process.argv[6],p.crashPusherCode);";
   return [
     'node',
     '-e',
@@ -62,6 +64,7 @@ function nodeMaterializePayloadCommand(input: {
     shellQuote(input.runnerPath),
     shellQuote(input.configPath),
     shellQuote(input.artifactCodePath),
+    shellQuote(input.artifactSourceMapPath),
     shellQuote(input.crashPusherPath),
   ].join(' ');
 }
@@ -236,6 +239,7 @@ export async function stageDaytonaRunnerPayload(input: {
   const envelopePath = `${workDir}/deepline-play-payload-${randomUUID()}.json.gz`;
   const configPath = `${workDir}/deepline-play-config-${randomUUID()}.json`;
   const artifactCodePath = `${workDir}/deepline-play-artifact-${randomUUID()}.cjs`;
+  const artifactSourceMapPath = `${artifactCodePath}.map`;
   const crashPusherPath = `${workDir}/deepline-play-crash-terminal-${randomUUID()}.cjs`;
 
   const remoteMaterializedFiles: Record<string, string> = {};
@@ -306,6 +310,7 @@ export async function stageDaytonaRunnerPayload(input: {
     artifactTransport: {
       bundledCodePath: artifactCodePath,
       bundledCodeEncoding: 'utf8',
+      sourceMapPath: artifactSourceMapPath,
     },
     workspaceRoot: input.workDir,
     csvSourcePath: hasInlineCsv
@@ -330,6 +335,7 @@ export async function stageDaytonaRunnerPayload(input: {
         schemaVersion: 1,
         runnerCode: bundle,
         artifactBundledCode: compactedArtifact.bundledCode,
+        artifactSourceMap: input.config.artifact.sourceMap,
         config: remoteConfig,
         crashPusherCode: buildDaytonaCrashTerminalPusherSource(),
       }),
@@ -355,6 +361,7 @@ export async function stageDaytonaRunnerPayload(input: {
     runnerPath,
     configPath,
     artifactCodePath,
+    artifactSourceMapPath,
     crashPusherPath,
   })} && DEEPLINE_PLAY_RUNNER_READY_PATH=${shellQuote(readyPath)} DEEPLINE_PLAY_RUNNER_PROGRESS_EVENT_PATH=${shellQuote(progressEventPath)} DEEPLINE_PLAY_RUNNER_STDOUT_EVENT_MODE=compact ${runnerTraceEnv}node ${shellQuote(runnerPath)} ${shellQuote(configPath)}`;
   // Crash-containment epilogue: runs UNCONDITIONALLY after the runner exits and

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

@@ -80,6 +80,7 @@ import {
 import type { MapRowOutcome } from './durability-store';
 import {
   normalizeRuntimeMapInputIndex,
+  prepareRuntimeSheetRowsForJsonTransport,
   prepareRuntimeSheetRowTransitions,
   type RuntimePreparedCompletedRow,
   type RuntimePreparedFailedRow,
@@ -272,6 +273,8 @@ type RuntimeSheetPreparedRowDisposition = {
   key: string;
   disposition: RuntimeSheetPrepareDisposition;
 };
+
+type RuntimeSheetDatasetMode = 'upsert' | 'net_new';
 const dbSessionCache = new Map<string, DbSessionCacheEntry>();
 const dbSessionInFlight = new Map<string, Promise<CreateDbSessionResponse>>();
 const postgresPools = new Map<string, RuntimePool>();
@@ -614,10 +617,22 @@ async function postRuntimeApi<TResponse>(
       typeof parsed?.error === 'string'
         ? parsed.error
         : `Runtime API request failed with status ${response.status}.`;
+    const errorCode = typeof parsed?.code === 'string' ? parsed.code : null;
+    const errorAction =
+      typeof parsed?.action === 'string' ? parsed.action : body.action;
+    const requestId = response.headers.get('x-deepline-request-id');
+    const diagnosticContext = [
+      `status ${response.status}`,
+      errorCode ? `code=${errorCode}` : null,
+      errorAction ? `action=${errorAction}` : null,
+      requestId ? `request_id=${requestId}` : null,
+    ]
+      .filter((value): value is string => Boolean(value))
+      .join(', ');
     throw new Error(
       details
-        ? `${errorMessage} (status ${response.status}): ${details}`
-        : `${errorMessage} (status ${response.status}).`,
+        ? `${errorMessage} (${diagnosticContext}): ${details}`
+        : `${errorMessage} (${diagnosticContext}).`,
     );
   }
 
@@ -2963,6 +2978,7 @@ async function prepareRuntimeSheetDatasetRows(
     physicalUpsertSetSql: string;
     outputPhysicalColumns: PhysicalSheetColumnProjection[];
     force?: boolean;
+    mode?: RuntimeSheetDatasetMode;
   },
 ): Promise<{
   inserted: number;
@@ -3365,6 +3381,121 @@ async function prepareRuntimeSheetDatasetRows(
   return { inserted, rowDispositions };
 }
 
+/**
+ * Atomically admit source-table keys that have not completed. A completed row
+ * is consumed forever; failed rows and rows owned by this logical run remain
+ * recoverable. This is deliberately a separate insert-only path: deriving
+ * "new" from a read before the normal insert would race a concurrent sourcing
+ * run.
+ */
+async function prepareNetNewRuntimeSheetDatasetRows(
+  client: RuntimeQueryClient,
+  session: RuntimePostgresSession,
+  input: {
+    chunks: RuntimeDatasetRowEntry[][];
+    runId: string;
+    attemptId: string;
+    attemptOwnerRunId: string;
+    attemptExpiresAt: string;
+    attemptSeq: number;
+    writeVersion: number;
+    physicalInsertColumnsSql: string;
+    physicalInsertValuesSql: string;
+  },
+): Promise<{
+  inserted: number;
+  rowDispositions: RuntimeSheetPreparedRowDisposition[];
+}> {
+  let inserted = 0;
+  const rowDispositions: RuntimeSheetPreparedRowDisposition[] = [];
+  for (const chunk of input.chunks) {
+    const { rows } = await client.query<{
+      inserted_count: number;
+      row_dispositions: RuntimeSheetPreparedRowDisposition[];
+    }>(
+      `WITH input_rows AS (
+         SELECT DISTINCT ON (key_values._key)
+                key_values._key, payload_values.payload, index_values._input_index
+         FROM unnest($1::text[]) WITH ORDINALITY AS key_values(_key, ord)
+         JOIN unnest($2::jsonb[]) WITH ORDINALITY AS payload_values(payload, ord)
+           ON payload_values.ord = key_values.ord
+         JOIN unnest($3::bigint[]) WITH ORDINALITY AS index_values(_input_index, ord)
+           ON index_values.ord = key_values.ord
+         ORDER BY key_values._key, key_values.ord
+       ),
+       reclaimed_rows AS (
+         UPDATE ${sheetTable(session)} AS target
+            SET _status = 'pending',
+                _run_id = $4::text,
+                _input_index = input_rows._input_index,
+                _attempt_id = $5::text,
+                _attempt_owner_run_id = $6::text,
+                _attempt_expires_at = $7::timestamptz,
+                _attempt_seq = $8::integer,
+                _write_version = $9::bigint,
+                _writer_run_id = $4::text,
+                _error = NULL,
+                _updated_at = now(),
+                _version = ${nextRuntimeSheetVersionExpression(session)}
+           FROM input_rows
+          WHERE target._key = input_rows._key
+            AND (
+              target._status = 'failed'
+              OR (
+                target._status IN ('pending', 'running')
+                AND coalesce(target._attempt_owner_run_id, target._run_id) = $6::text
+              )
+            )
+         RETURNING target._key
+       ),
+       inserted_rows AS (
+         INSERT INTO ${sheetTable(session)}
+         (_key, _status, _run_id, _input_index, _attempt_id, _attempt_owner_run_id,
+          _attempt_expires_at, _attempt_seq, _write_version, _writer_run_id${input.physicalInsertColumnsSql})
+       SELECT _key, 'pending', $4::text, _input_index, $5::text, $6::text,
+              $7::timestamptz, $8::integer, $9::bigint, $4::text${input.physicalInsertValuesSql}
+       FROM input_rows
+       ON CONFLICT (_key) DO NOTHING
+       RETURNING _key
+       ),
+       pending_rows AS (
+         SELECT _key FROM inserted_rows
+         UNION
+         SELECT _key FROM reclaimed_rows
+       )
+       SELECT
+         (SELECT count(*)::int FROM inserted_rows) AS inserted_count,
+         coalesce(
+           (SELECT jsonb_agg(jsonb_build_object('key', _key, 'disposition', 'pending')) FROM pending_rows),
+           '[]'::jsonb
+         ) AS row_dispositions`,
+      [
+        chunk.map((entry) => entry.key),
+        chunk.map((entry) => stringifyPostgresJson(entry.row)),
+        chunk.map((entry) => entry.inputIndex),
+        input.runId,
+        input.attemptId,
+        input.attemptOwnerRunId,
+        input.attemptExpiresAt,
+        input.attemptSeq,
+        input.writeVersion,
+      ],
+    );
+    inserted += Number(rows[0]?.inserted_count ?? 0);
+    if (Array.isArray(rows[0]?.row_dispositions)) {
+      rowDispositions.push(
+        ...rows[0].row_dispositions.filter(
+          (row): row is RuntimeSheetPreparedRowDisposition =>
+            row != null &&
+            typeof row.key === 'string' &&
+            row.disposition === 'pending',
+        ),
+      );
+    }
+  }
+  return { inserted, rowDispositions };
+}
+
 async function buildRuntimeSheetDatasetStartResult(
   client: RuntimeQueryClient,
   session: RuntimePostgresSession,
@@ -5548,6 +5679,7 @@ export async function startRuntimeSheetDataset(
     writeVersion?: number | null;
     inputOffset?: number;
     force?: boolean;
+    mode?: RuntimeSheetDatasetMode;
   },
 ): Promise<PrepareRuntimeSheetResult> {
   if (context.dbSessionStrategy === 'gateway_only') {
@@ -5724,24 +5856,37 @@ export async function startRuntimeSheetDataset(
         rows: rowEntries.length,
       });
       const prepareStartedAt = Date.now();
-      const prepared = await prepareRuntimeSheetDatasetRows(client, session, {
-        chunks,
-        runId: input.runId,
-        normalizedPlayName,
-        normalizedTableNamespace,
-        attemptId,
-        attemptOwnerRunId,
-        attemptExpiresAt,
-        attemptSeq,
-        writeVersion,
-        physicalInsertColumnsSql,
-        physicalInsertValuesSql,
-        physicalRefreshSetSql:
-          input.force === true ? physicalRefreshSetSql : '',
-        physicalUpsertSetSql,
-        outputPhysicalColumns,
-        force: input.force === true,
-      });
+      const prepared =
+        input.mode === 'net_new'
+          ? await prepareNetNewRuntimeSheetDatasetRows(client, session, {
+              chunks,
+              runId: input.runId,
+              attemptId,
+              attemptOwnerRunId,
+              attemptExpiresAt,
+              attemptSeq,
+              writeVersion,
+              physicalInsertColumnsSql,
+              physicalInsertValuesSql,
+            })
+          : await prepareRuntimeSheetDatasetRows(client, session, {
+              chunks,
+              runId: input.runId,
+              normalizedPlayName,
+              normalizedTableNamespace,
+              attemptId,
+              attemptOwnerRunId,
+              attemptExpiresAt,
+              attemptSeq,
+              writeVersion,
+              physicalInsertColumnsSql,
+              physicalInsertValuesSql,
+              physicalRefreshSetSql:
+                input.force === true ? physicalRefreshSetSql : '',
+              physicalUpsertSetSql,
+              outputPhysicalColumns,
+              force: input.force === true,
+            });
       timings.push({
         phase: 'prepare_rows_sql',
         ms: Date.now() - prepareStartedAt,
@@ -6151,12 +6296,8 @@ async function completeRuntimeMapRowChunks(
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
-    const chunkDataPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.data_patch),
-    );
-    const chunkCellMetaPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.cell_meta_patch),
-    );
+    const chunkDataPatches = chunk.map((row) => row.data_patch_json);
+    const chunkCellMetaPatches = chunk.map((row) => row.cell_meta_patch_json);
     const targetChangedPatchedCellSql = changedPatchedCellSql(
       'target',
       'updates.data_patch',
@@ -6418,12 +6559,8 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
-    const chunkDataPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.data_patch),
-    );
-    const chunkCellMetaPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.cell_meta_patch),
-    );
+    const chunkDataPatches = chunk.map((row) => row.data_patch_json);
+    const chunkCellMetaPatches = chunk.map((row) => row.cell_meta_patch_json);
     const targetChangedPatchedCellSql = changedPatchedCellSql(
       'target',
       'updates.data_patch',
@@ -6661,12 +6798,8 @@ async function insertMissingCompletedMapRowChunks(
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
-    const chunkDataPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.data_patch),
-    );
-    const chunkCellMetaPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.cell_meta_patch),
-    );
+    const chunkDataPatches = chunk.map((row) => row.data_patch_json);
+    const chunkCellMetaPatches = chunk.map((row) => row.cell_meta_patch_json);
     const { rows } = await client.query<{ inserted: number }>(
       `WITH input_rows AS (
          SELECT key_values._key,
@@ -6833,12 +6966,8 @@ async function failRuntimeMapRowChunks(
   for (const chunk of input.chunks) {
     const chunkKeys = chunk.map((row) => row.key);
     const chunkInputIndexes = chunk.map((row) => row.input_index);
-    const chunkDataPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.data_patch),
-    );
-    const chunkCellMetaPatches = chunk.map((row) =>
-      stringifyPostgresJson(row.cell_meta_patch),
-    );
+    const chunkDataPatches = chunk.map((row) => row.data_patch_json);
+    const chunkCellMetaPatches = chunk.map((row) => row.cell_meta_patch_json);
     const chunkErrors = chunk.map((row) => row.error);
     // Per-field failed-cell counts for the column summary, computed from the
     // cell meta patches (a failed row records exactly which cell failed).
@@ -7064,9 +7193,21 @@ export async function completeRuntimeMapRows(
   },
 ): Promise<RuntimeMapRowsWriteResult> {
   if (context.dbSessionStrategy === 'gateway_only') {
+    const keyedRows = input.rows.map((row) => {
+      if (row.key) return row;
+      const key = resolveMapRowOutcomeKey(
+        row as unknown as Record<string, unknown>,
+      );
+      return key ? { ...row, key } : row;
+    });
+    const rows = prepareRuntimeSheetRowsForJsonTransport({
+      rows: keyedRows,
+      runId: input.runId,
+      outputFields: input.outputFields ?? [],
+    });
     return await postRuntimeApi<RuntimeMapRowsWriteResult>(context, {
       action: 'runtime_sheet_complete_map_rows',
-      input,
+      input: { ...input, rows },
     });
   }
   if (input.rows.length === 0) {