deepline 0.1.225 → 0.1.227

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

@@ -2539,6 +2539,7 @@ type WorkerStepProgram = {
 
 type WorkerMapOptions = {
   description?: string;
+  mode?: 'upsert' | 'net_new';
   concurrency?: number;
   key?:
     | string
@@ -4870,9 +4871,18 @@ function createMinimalWorkerCtx(
             runId: req.runId,
             inputOffset: 0,
             attemptLeaseTtlMs: runtimeSheetAttemptLeaseTtlMs(req),
+            ...(opts?.mode ? { mode: opts.mode } : {}),
             ...mapWriteAttempt,
           });
     const mapWriteVersion = mapReservation?.writeVersion ?? null;
+    const netNewRowKeys =
+      opts?.mode === 'net_new'
+        ? new Set(
+            (mapReservation?.pendingRows ?? [])
+              .map((row) => resolveMapRowOutcomeKey(row))
+              .filter((key): key is string => Boolean(key)),
+          )
+        : null;
 
     let totalRowsWritten = 0;
     let datasetLifecycleRegistered = false;
@@ -4896,7 +4906,7 @@ function createMinimalWorkerCtx(
         chunkIndex,
       });
       const keyStartedAt = nowMs();
-      const chunkEntries = chunkRows.map((row, localIndex) => {
+      let chunkEntries = chunkRows.map((row, localIndex) => {
         const absoluteIndex = baseOffset + chunkStart + localIndex;
         const rowKey = resolveRowKey(
           row,
@@ -4906,6 +4916,11 @@ function createMinimalWorkerCtx(
         );
         return { row, absoluteIndex, rowKey };
       });
+      if (netNewRowKeys) {
+        chunkEntries = chunkEntries.filter(({ rowKey }) =>
+          netNewRowKeys.has(rowKey),
+        );
+      }
       recordRunnerPerfTrace({
         req,
         phase: 'runner.map_chunk.keys',
@@ -4968,7 +4983,10 @@ function createMinimalWorkerCtx(
         },
       });
       mapLatencyProfile.recordPhase('prepare_rows', nowMs() - prepareStartedAt);
-      const progressTotalRows = rowCountHint ?? chunkRows.length;
+      // net_new reserves the entire source before chunk execution, so its
+      // progress describes the admitted subset rather than the source CSV.
+      const progressTotalRows =
+        netNewRowKeys?.size ?? rowCountHint ?? chunkRows.length;
       const preparedCompletedRows = Math.min(
         progressTotalRows,
         totalRowsWritten,
@@ -5023,15 +5041,8 @@ function createMinimalWorkerCtx(
         ({ rowKey }) => !preparedKeys.has(rowKey),
       );
       if (missingPreparedRows.length > 0) {
-        const rowKeySamples = missingPreparedRows
-          .map(({ rowKey }) => rowKey)
-          .slice(0, MAP_ROW_FAILURE_SAMPLE_LIMIT);
         throw new Error(
-          `ctx.dataset("${name}") runtime preparation omitted ${missingPreparedRows.length} row disposition(s). ` +
-            `Every input row must be claimed, completed, or blocked before execution starts.` +
-            (rowKeySamples.length > 0
-              ? ` Missing row keys: ${rowKeySamples.join(', ')}`
-              : ''),
+          `ctx.dataset("${name}") preparation omitted ${missingPreparedRows.length} row disposition(s).`,
         );
       }
       const rowsToExecuteEntries = chunkEntries.filter(({ rowKey }) =>
@@ -5986,9 +5997,8 @@ function createMinimalWorkerCtx(
         // dataset (their recoverable state lives in the runtime sheet).
         if (key && executedRow) resultByKey.set(key, executedRow);
       }
-      const outEntries = chunkRows
-        .map((_row, index) => {
-          const entry = chunkEntries[index]!;
+      const outEntries = chunkEntries
+        .map((entry) => {
           const row = resultByKey.get(entry.rowKey);
           return row
             ? {
@@ -6531,11 +6541,11 @@ function createMinimalWorkerCtx(
           }
           enqueueMapProgressUpdate({
             completed: totalRowsWritten,
-            total: rowCountHint ?? undefined,
+            total: netNewRowKeys?.size ?? rowCountHint ?? undefined,
             ...(totalRowsFailed > 0 ? { failed: totalRowsFailed } : {}),
             message: formatMapProgressMessage(
               totalRowsWritten,
-              rowCountHint ?? undefined,
+              netNewRowKeys?.size ?? rowCountHint ?? undefined,
             ),
           });
           if (previewRows.length < WORKER_DATASET_PREVIEW_ROWS) {
@@ -7836,6 +7846,9 @@ async function executeRunRequest(
         occurredAt: event.at,
         stepId: event.nodeId,
         kind: event.type,
+        ...(event.transition === 'failed' && event.error
+          ? { error: event.error }
+          : {}),
       },
     ];
     flushLedgerEvents(false);
@@ -8317,7 +8330,8 @@ async function executeRunRequest(
       durationMs: nowMs() - startedAt,
     };
   } catch (error) {
-    stepLifecycle?.markStartedFailed(nowMs());
+    const failure = normalizePlayRunFailure(error);
+    stepLifecycle?.markStartedFailed(nowMs(), failure.message);
     // A runtime-limit abort is a timeout failure, not a user cancellation, so
     // it should be reported as run.failed with the limit message rather than
     // run.cancelled.
@@ -8329,7 +8343,6 @@ async function executeRunRequest(
         error instanceof Error ? error.message : 'Play run cancelled.',
       );
     }
-    const failure = normalizePlayRunFailure(error);
     const message = failure.message;
     // Controlled run-fatal teardown: release the runtime-sheet row leases and
     // work-receipt leases this attempt still holds so an immediate rerun is not
@@ -8369,6 +8382,9 @@ async function executeRunRequest(
             retryable: failure.retryable,
             ...(errorBilling ? { billing: errorBilling } : {}),
             ...(failure.cause ? { cause: failure.cause } : {}),
+            ...(failure.name ? { name: failure.name } : {}),
+            ...(failure.stack ? { stack: failure.stack } : {}),
+            ...(failure.causes ? { causes: failure.causes } : {}),
           },
         ],
       });

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

@@ -560,6 +560,11 @@ export type DatasetBuilder<
    */
   run(options?: {
     description?: string;
+    /**
+     * `upsert` (default) returns every input row, reusing persisted work for
+     * existing keys. `net_new` atomically inserts and returns only unseen keys.
+     */
+    mode?: 'upsert' | 'net_new';
     key?:
       | (keyof InputRow & string)
       | readonly (keyof InputRow & string)[]

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

@@ -108,10 +108,10 @@ export const SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: '0.1.225',
+  version: '0.1.227',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.225',
+    latest: '0.1.227',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.219',
     commandMinimumSupported: [

package/dist/bundling-sources/shared_libs/observability/tracing.ts

@@ -1,4 +1,5 @@
 import {
+  INVALID_SPAN_CONTEXT,
   SpanKind,
   SpanStatusCode,
   trace,
@@ -10,6 +11,97 @@ type PrimitiveAttribute = string | number | boolean | null | undefined;
 
 type TraceAttributes = Record<string, PrimitiveAttribute>;
 
+const NOOP_SPAN: Span = {
+  spanContext: () => INVALID_SPAN_CONTEXT,
+  setAttribute: () => NOOP_SPAN,
+  setAttributes: () => NOOP_SPAN,
+  addEvent: () => NOOP_SPAN,
+  addLink: () => NOOP_SPAN,
+  addLinks: () => NOOP_SPAN,
+  setStatus: () => NOOP_SPAN,
+  updateName: () => NOOP_SPAN,
+  end: () => undefined,
+  isRecording: () => false,
+  recordException: () => undefined,
+};
+
+function discardTelemetryResult(invoke: () => unknown): void {
+  try {
+    const result = invoke();
+    if (
+      result === null ||
+      (typeof result !== 'object' && typeof result !== 'function')
+    ) {
+      return;
+    }
+    let then: unknown;
+    try {
+      then = Reflect.get(result, 'then');
+    } catch {
+      return;
+    }
+    if (typeof then === 'function') {
+      void Promise.resolve(result).catch(() => undefined);
+    }
+  } catch {}
+}
+
+function nonBlockingSpan(span: Span): Span {
+  const safeSpan: Span = {
+    spanContext() {
+      try {
+        return span.spanContext();
+      } catch {
+        return INVALID_SPAN_CONTEXT;
+      }
+    },
+    setAttribute(key, value) {
+      discardTelemetryResult(() => span.setAttribute(key, value));
+      return safeSpan;
+    },
+    setAttributes(attributes) {
+      discardTelemetryResult(() => span.setAttributes(attributes));
+      return safeSpan;
+    },
+    addEvent(name, attributesOrStartTime, startTime) {
+      discardTelemetryResult(() =>
+        span.addEvent(name, attributesOrStartTime, startTime),
+      );
+      return safeSpan;
+    },
+    addLink(link) {
+      discardTelemetryResult(() => span.addLink(link));
+      return safeSpan;
+    },
+    addLinks(links) {
+      discardTelemetryResult(() => span.addLinks(links));
+      return safeSpan;
+    },
+    setStatus(status) {
+      discardTelemetryResult(() => span.setStatus(status));
+      return safeSpan;
+    },
+    updateName(name) {
+      discardTelemetryResult(() => span.updateName(name));
+      return safeSpan;
+    },
+    end(endTime) {
+      discardTelemetryResult(() => span.end(endTime));
+    },
+    isRecording() {
+      try {
+        return span.isRecording();
+      } catch {
+        return false;
+      }
+    },
+    recordException(exception, time) {
+      discardTelemetryResult(() => span.recordException(exception, time));
+    },
+  };
+  return safeSpan;
+}
+
 function normalizeAttributes(
   attributes: TraceAttributes | undefined,
 ): Attributes | undefined {
@@ -60,34 +152,67 @@ export async function withActiveSpan<T>(
   },
   fn: (span: Span) => Promise<T> | T,
 ): Promise<T> {
-  const tracer = trace.getTracer(options.tracer ?? 'deepline');
-  return await tracer.startActiveSpan(
-    name,
-    {
-      kind: options.kind,
-      attributes: normalizeAttributes(options.attributes),
-    },
-    async (span) => {
+  let operationPromise: Promise<T> | null = null;
+  const runOperation = async (span: Span): Promise<T> => {
+    const safeSpan = nonBlockingSpan(span);
+    try {
+      const result = await fn(safeSpan);
+      safeSpan.setStatus({ code: SpanStatusCode.OK });
+      return result;
+    } catch (error) {
       try {
-        const result = await fn(span);
-        span.setStatus({ code: SpanStatusCode.OK });
-        return result;
-      } catch (error) {
-        recordError(span, error);
-        throw error;
-      } finally {
-        span.end();
+        recordError(safeSpan, error);
+      } catch {
+        // Error telemetry must not replace the operation's real error.
       }
-    },
-  );
+      throw error;
+    } finally {
+      safeSpan.end();
+    }
+  };
+  const startOperation = (span: Span): Promise<T> => {
+    if (operationPromise) return operationPromise;
+    let resolveOperation!: (value: T | PromiseLike<T>) => void;
+    let rejectOperation!: (reason?: unknown) => void;
+    operationPromise = new Promise<T>((resolve, reject) => {
+      resolveOperation = resolve;
+      rejectOperation = reject;
+    });
+    void runOperation(span).then(resolveOperation, rejectOperation);
+    return operationPromise;
+  };
+
+  let tracerResult: unknown;
+  try {
+    const tracer = trace.getTracer(options.tracer ?? 'deepline');
+    tracerResult = tracer.startActiveSpan(
+      name,
+      {
+        kind: options.kind,
+        attributes: normalizeAttributes(options.attributes),
+      },
+      (span) => startOperation(span),
+    );
+  } catch {}
+
+  // A non-conforming exporter may return work unrelated to the callback.
+  // Drain its rejection without awaiting it; only execution owns latency and
+  // the returned success/failure contract.
+  discardTelemetryResult(() => tracerResult);
+
+  // A broken tracer may return without invoking the callback. Execution is
+  // authoritative, so run it once without telemetry in that case.
+  return await startOperation(NOOP_SPAN);
 }
 
 export function setSpanAttributes(
   span: Span,
   attributes: TraceAttributes,
 ): void {
-  const normalized = normalizeAttributes(attributes);
-  if (normalized) {
-    span.setAttributes(normalized);
-  }
+  try {
+    const normalized = normalizeAttributes(attributes);
+    if (normalized) {
+      discardTelemetryResult(() => span.setAttributes(normalized));
+    }
+  } catch {}
 }

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

@@ -33,6 +33,8 @@ import { createRuntimeReceiptHeartbeatSupervisor } from './receipt-heartbeat-sup
 import { dispatchBoundedSettled } from './bounded-dispatch';
 import type { PlayQueueHint } from './governor/rate-state-backend';
 import type { MapRowOutcome } from './durability-store';
+import { stringifyPostgresJson } from './postgres-json';
+import { RUNTIME_ROW_OUTPUT_NOT_JSON_SERIALIZABLE } from './runtime-sheet-row-transition';
 import type { WorkReceiptFailureKind } from './work-receipts';
 import {
   completedMapRowOutcome,
@@ -3090,9 +3092,19 @@ export class PlayContextImpl {
   // are no-ops for any value that is not a tool result.
 
   private serializeCellValue(value: unknown): unknown {
-    return isToolExecuteResult(value)
+    const serialized = isToolExecuteResult(value)
       ? serializeToolExecuteResult(value)
       : value;
+    try {
+      stringifyPostgresJson(serialized);
+    } catch (error) {
+      throw new Error(
+        `${RUNTIME_ROW_OUTPUT_NOT_JSON_SERIALIZABLE}: Dataset cell output is not JSON-serializable: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+    return serialized;
   }
 
   private rehydrateCellValue(value: unknown): unknown {
@@ -3931,7 +3943,10 @@ export class PlayContextImpl {
         this.#options.runId,
       );
     if (shouldStreamRuntimeBackedDataset) {
-      totalInputCount = await items.count();
+      // Net-new admission happens one source page at a time. Its progress and
+      // returned dataset describe admitted rows, not every provider/CSV row
+      // supplied to this run, so accumulate the admitted count below.
+      totalInputCount = options?.mode === 'net_new' ? 0 : await items.count();
       const mapScope = this.createMapExecutionScope({
         logicalNamespace: normalizedMapNamespace,
         artifactTableNamespace: resolvedTableNamespace,
@@ -4085,6 +4100,7 @@ export class PlayContextImpl {
             staticPipeline: this.currentStaticPipeline,
             forceRefresh: this.#options.cachePolicy?.forceToolRefresh === true,
             inputOffset: page.offset,
+            mode: options?.mode,
           },
         );
         resolvedTableNamespace = normalizeTableNamespace(
@@ -4128,12 +4144,21 @@ export class PlayContextImpl {
             index: originalIndex,
           };
         });
+        const admittedSeededItems =
+          options?.mode === 'net_new'
+            ? seededItems.filter(({ row, index }) =>
+                pendingRowsByKey.has(seedRowIdentity(row, index)),
+              )
+            : seededItems;
+        if (options?.mode === 'net_new') {
+          totalInputCount += admittedSeededItems.length;
+        }
 
         const rowsToExecuteByKey = new Map<
           string,
           { row: Record<string, unknown>; originalIndex: number }
         >();
-        for (const { row, index } of seededItems) {
+        for (const { row, index } of admittedSeededItems) {
           if (explicitKeyResolver) {
             const explicitKey = explicitKeyResolver(row, index);
             if (seenExplicitKeys.has(explicitKey)) {
@@ -4268,6 +4293,45 @@ export class PlayContextImpl {
         page.rows.length = 0;
       }
 
+      // Isolated failures are a partial result only when at least one admitted
+      // row completed. A fully failed admission run is systemic: preserve the
+      // failed sheet rows for recovery, but fail the enclosing play loudly.
+      if (totalInputCount > 0 && failedCount === totalInputCount) {
+        const completedRows = 0;
+        this.setMapFrame({
+          mapInvocationId: mapScope.mapInvocationId,
+          mapNodeId: mapScope.mapNodeId ?? null,
+          logicalNamespace: mapScope.logicalNamespace,
+          artifactTableNamespace: resolvedTableNamespace,
+          status: 'failed',
+          totalRows: totalInputCount,
+          completedRowKeys: [],
+          pendingRowKeys: [],
+          completedRowsCount: completedRows,
+          pendingRowsCount: 0,
+          failedRowsCount: failedCount,
+          startedAt:
+            this.checkpoint.mapFrames?.[mapScope.mapInvocationId]?.startedAt ??
+            Date.now(),
+          updatedAt: Date.now(),
+        });
+        this.emitExecutionEvent({
+          type: 'map.failed',
+          mapInvocationId: mapScope.mapInvocationId,
+          mapNodeId: mapScope.mapNodeId ?? null,
+          logicalNamespace: mapScope.logicalNamespace,
+          artifactTableNamespace: resolvedTableNamespace,
+          completedRows,
+          failedRows: failedCount,
+          totalRows: totalInputCount,
+          at: Date.now(),
+        });
+        throw new Error(
+          `ctx.dataset("${normalizedMapNamespace}") failed for every admitted row (${failedCount}/${totalInputCount}). ` +
+            'Failed rows were persisted and will be retried on the next run.',
+        );
+      }
+
       this.setMapFrame({
         mapInvocationId: mapScope.mapInvocationId,
         mapNodeId: mapScope.mapNodeId ?? null,
@@ -4519,6 +4583,7 @@ export class PlayContextImpl {
           executorToken: this.#options.executorToken,
           staticPipeline: this.currentStaticPipeline,
           forceRefresh: this.#options.cachePolicy?.forceToolRefresh === true,
+          mode: options?.mode,
         },
       );
       resolvedTableNamespace = normalizeTableNamespace(
@@ -4575,8 +4640,16 @@ export class PlayContextImpl {
             index,
           };
         });
-      itemsToProcess = seededItems.map((item) => item.row);
-      itemOriginalIndexes = seededItems.map((item) => item.index);
+      const admittedItems =
+        options?.mode === 'net_new'
+          ? seededItems.filter(({ row, index }) =>
+              pendingRowsByKey.has(seedRowIdentity(row, index)),
+            )
+          : seededItems;
+      rawItems = admittedItems.map((item) => item.row);
+      itemsToProcess = admittedItems.map((item) => item.row);
+      itemOriginalIndexes = admittedItems.map((item) => item.index);
+      totalInputCount = admittedItems.length;
     }
 
     const mapScope = this.createMapExecutionScope({
@@ -5391,6 +5464,7 @@ export class PlayContextImpl {
           });
 
           let value: unknown;
+          let cellValue: unknown;
           try {
             value = await rowContext.run(
               {
@@ -5411,6 +5485,7 @@ export class PlayContextImpl {
                   this.previousCellForField(baseRow, fieldName),
                 ),
             );
+            cellValue = this.serializeCellValue(value);
           } catch (error) {
             if (
               isPlayRowExecutionSuspendedError(error) ||
@@ -5482,7 +5557,6 @@ export class PlayContextImpl {
             });
             return FAILED_ROW;
           }
-          const cellValue = this.serializeCellValue(value);
           computedFields[fieldName] = cellValue;
           this.rowStates.get(idx)?.results.set(fieldName, cellValue);
           const currentCellMeta =

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -248,6 +248,16 @@ export interface DatasetOptions<TItem = Record<string, unknown>> {
    * and are reused on re-run.
    */
   onRowError?: 'isolate' | 'fail';
+  /**
+   * Controls how a persisted dataset admits rows whose key already exists.
+   *
+   * `upsert` (the default) preserves the row-preserving enrichment contract:
+   * existing rows are reused and returned with the current input. `net_new`
+   * atomically inserts only previously unseen keys and returns/processes only
+   * those inserted rows. Use `net_new` for a durable sourcing table, not for
+   * ordinary CSV enrichment reruns.
+   */
+  mode?: 'upsert' | 'net_new';
 }
 
 export type DatasetDefinitionOptions<TItem = Record<string, unknown>> = Omit<
@@ -257,7 +267,7 @@ export type DatasetDefinitionOptions<TItem = Record<string, unknown>> = Omit<
 
 export type DatasetRunOptions<TItem = Record<string, unknown>> = Pick<
   DatasetOptions<TItem>,
-  'description' | 'key' | 'onRowError'
+  'description' | 'key' | 'onRowError' | 'mode'
 >;
 
 export interface ToolCallOptions {
@@ -597,6 +607,7 @@ export interface ContextOptions {
       staticPipeline?: PlayStaticPipeline | null;
       forceRefresh?: boolean;
       inputOffset?: number;
+      mode?: DatasetRunOptions['mode'];
     },
   ) => Promise<MapStartResult>;
   /**

package/dist/bundling-sources/shared_libs/play-runtime/live-state-contract.ts

@@ -35,6 +35,7 @@ export type PlayVisualNodeProgressSnapshot = {
 export type PlayVisualNodeStateSnapshot = {
   nodeId: string;
   status: PlayVisualNodeStatus;
+  error?: string | null;
   artifactTableNamespace?: string | null;
   progress?: PlayVisualNodeProgressSnapshot | null;
   startedAt?: number | null;

package/dist/bundling-sources/shared_libs/play-runtime/postgres-json.ts

@@ -1,9 +1,71 @@
-const POSTGRES_UNSUPPORTED_NUL_RE = /\u0000/g;
+const POSTGRES_JSON_REPLACEMENT_CHARACTER = '\uFFFD';
+const POSTGRES_JSON_SUSPECT_CODE_UNIT_RE = /[\u0000\uD800-\uDFFF]/;
+
+function sanitizePostgresJsonString(value: string): string {
+  if (!POSTGRES_JSON_SUSPECT_CODE_UNIT_RE.test(value)) return value;
+
+  let sanitized = '';
+  let changed = false;
+
+  for (let index = 0; index < value.length; index += 1) {
+    const codeUnit = value.charCodeAt(index);
+    if (codeUnit === 0) {
+      changed = true;
+      continue;
+    }
+
+    if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+      const nextCodeUnit = value.charCodeAt(index + 1);
+      if (nextCodeUnit >= 0xdc00 && nextCodeUnit <= 0xdfff) {
+        sanitized += value[index] + value[index + 1];
+        index += 1;
+        continue;
+      }
+      sanitized += POSTGRES_JSON_REPLACEMENT_CHARACTER;
+      changed = true;
+      continue;
+    }
+
+    if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+      sanitized += POSTGRES_JSON_REPLACEMENT_CHARACTER;
+      changed = true;
+      continue;
+    }
+
+    sanitized += value[index];
+  }
+
+  return changed ? sanitized : value;
+}
 
 function postgresJsonReplacer(_key: string, value: unknown): unknown {
-  return typeof value === 'string'
-    ? value.replace(POSTGRES_UNSUPPORTED_NUL_RE, '')
-    : value;
+  if (typeof value === 'string') {
+    return sanitizePostgresJsonString(value);
+  }
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    return value;
+  }
+
+  const keys = Object.keys(value);
+  if (!keys.some((key) => sanitizePostgresJsonString(key) !== key)) {
+    return value;
+  }
+  const sanitizedEntries: Array<[string, unknown]> = [];
+  const sanitizedKeys = new Set<string>();
+  for (const key of keys) {
+    const sanitizedKey = sanitizePostgresJsonString(key);
+    if (sanitizedKeys.has(sanitizedKey)) {
+      throw new TypeError(
+        'Postgres JSON key normalization produced a duplicate object key.',
+      );
+    }
+    sanitizedKeys.add(sanitizedKey);
+    sanitizedEntries.push([
+      sanitizedKey,
+      (value as Record<string, unknown>)[key],
+    ]);
+  }
+  return Object.fromEntries(sanitizedEntries);
 }
 
 export function sanitizePostgresJsonValue<T>(value: T): T {

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

@@ -12,6 +12,7 @@ import type { PreloadedRuntimeDbSession } from './db-session';
 import type { PacingRule } from './governor/rate-state-backend';
 import type { GovernanceSnapshot } from './governor/governor';
 import type { PlayRunInputPayload } from './play-input';
+import type { PlayRunFailureDetails } from './run-failure';
 
 export type PlayRunnerRateStateBackendConfig =
   | {
@@ -165,6 +166,7 @@ export interface PlayRunnerExecutionConfig {
   artifactTransport?: {
     bundledCodePath?: string | null;
     bundledCodeEncoding?: 'utf8' | 'gzip';
+    sourceMapPath?: string | null;
   } | null;
   input: PlayRunInputPayload;
   checkpoint?: PlayCheckpoint | null;
@@ -241,6 +243,7 @@ export type PlayRunnerResult =
   | {
       status: 'failed';
       error: string;
+      errors?: PlayRunFailureDetails[];
       logs: string[];
       stats: Record<string, unknown>;
       steps: PlayStep[];