deepline 0.1.100 → 0.1.102

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

@@ -78,6 +78,7 @@ import {
   derivePlayRowIdentityFromKey,
   deriveToolRequestIdentity,
 } from '../../../shared_libs/plays/row-identity';
+import { DEDUPE_DUPLICATE_KEY_SAMPLE_CAP } from '../../../shared_libs/play-runtime/map-row-identity';
 import {
   getTopLevelPipelineSubsteps,
   getCompiledPipelineSubsteps,
@@ -3667,24 +3668,52 @@ function createMinimalWorkerCtx(
         ? derivePlayRowIdentity(inputRow, name)
         : derivePlayRowIdentityFromKey(explicitKeyValue, name);
     };
-    const assertUniqueExplicitRowKeys = (
-      chunkRows: readonly Record<string, unknown>[],
+    // Cross-chunk dedupe accumulators for the single end-of-map log line.
+    // `dedupeExplicitMapKeyRows` (shared_libs/play-runtime/map-row-identity.ts)
+    // can't be reused directly here because that helper is a single pass over a
+    // fully materialized array, whereas the workers path streams rows in chunks
+    // and must keep a persistent seen-set (`explicitRowKeysSeen`) across chunks.
+    // We mirror its exact semantics (keep-first, order preserved, capped sample)
+    // and share its sample cap constant so the two stay in lockstep.
+    let totalDuplicateKeysDropped = 0;
+    const droppedDuplicateKeySamples: string[] = [];
+    const seenDroppedDuplicateKeys = new Set<string>();
+    // Silent dedupe of duplicate explicit map keys: keep the first row per
+    // canonical key and drop subsequent duplicates, preserving input order.
+    // Deduping here — before rows reach `processChunk` — keeps every downstream
+    // derivation (chunk counts, sheet writes, resumable keys, result mapping)
+    // consistent: dropped rows never enter the chunk, so there is no index
+    // mismatch. Replaces the prior throw-on-duplicate behavior per product
+    // decision: duplicate keys must never fail the run.
+    const dedupeExplicitRowKeys = (
+      chunkRows: readonly T[],
       chunkStart: number,
-    ) => {
-      if (!explicitRowKeysSeen) return;
+    ): T[] => {
+      if (!explicitRowKeysSeen) return [...chunkRows];
+      const kept: T[] = [];
       for (let localIndex = 0; localIndex < chunkRows.length; localIndex += 1) {
         const index = chunkStart + localIndex;
-        const keyValue = resolveExplicitKeyValue(chunkRows[localIndex]!, index);
-        if (keyValue == null) continue;
-        const previousIndex = explicitRowKeysSeen?.get(keyValue);
-        if (previousIndex !== undefined) {
-          throw new Error(
-            `ctx.dataset("${name}") key function produced duplicate value "${keyValue}" for rows ${previousIndex} and ${index}. ` +
-              'Each row must produce a unique key. Combine columns (e.g. `${row.email}|${row.company}`) or pick a column that is unique per row.',
-          );
+        const row = chunkRows[localIndex]!;
+        const keyValue = resolveExplicitKeyValue(row, index);
+        if (keyValue == null) {
+          kept.push(row);
+          continue;
+        }
+        if (explicitRowKeysSeen.has(keyValue)) {
+          totalDuplicateKeysDropped += 1;
+          if (
+            !seenDroppedDuplicateKeys.has(keyValue) &&
+            droppedDuplicateKeySamples.length < DEDUPE_DUPLICATE_KEY_SAMPLE_CAP
+          ) {
+            droppedDuplicateKeySamples.push(keyValue);
+          }
+          seenDroppedDuplicateKeys.add(keyValue);
+          continue;
         }
-        explicitRowKeysSeen?.set(keyValue, index);
+        explicitRowKeysSeen.set(keyValue, index);
+        kept.push(row);
       }
+      return kept;
     };
 
     let totalRowsWritten = 0;
@@ -4085,14 +4114,9 @@ function createMinimalWorkerCtx(
                   completedExecutedRows += 1;
                   reportChunkProgress(false);
                 } catch (rowError) {
-                  // Row failure isolation (the default): one row's
-                  // tool/provider error is recorded on that row and its
-                  // siblings continue. Abort/budget errors stay run-fatal,
-                  // and `onRowError: 'fail'` opts the map into fail-fast.
-                  if (
-                    failFastRowErrors ||
-                    isRowIsolationExemptError(rowError)
-                  ) {
+                  // Abort/budget errors stay run-fatal and leave no partial
+                  // state: rethrow immediately without recording the row.
+                  if (isRowIsolationExemptError(rowError)) {
                     throw rowError;
                   }
                   const message = formatWorkerRowFailureMessage(rowError);
@@ -4108,8 +4132,14 @@ function createMinimalWorkerCtx(
                     Object.keys(cellMetaPatch).length > 0
                       ? cellMetaPatch
                       : undefined;
-                  // Keep the partially-enriched row so completed sibling
-                  // cells persist and replay free when the row re-executes.
+                  // 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).
                   failedRowEntries[myIndex] = {
                     row: enriched as T & Record<string, unknown>,
                     error: message,
@@ -4125,11 +4155,24 @@ function createMinimalWorkerCtx(
                       message:
                         `Row ${absoluteIndex} of ctx.dataset("${name}") failed` +
                         `${activeField ? ` at column "${activeField}"` : ''}: ${message} ` +
-                        '(row recorded as failed; sibling rows continue and the row re-executes on the next run)',
+                        (failFastRowErrors
+                          ? '(row persisted as failed; onRowError:"fail" fails the run after committing it)'
+                          : '(row recorded as failed; sibling rows continue and the row re-executes on the next run)'),
                       ts: nowMs(),
                     });
                   }
                   reportChunkProgress(false);
+                  // onRowError:'fail' fails the run — but NOT by throwing from
+                  // inside this per-row worker. A throw here would propagate out
+                  // of `processChunk`, which runs inside the durable chunk step's
+                  // retry wrapper, so CF would re-run (and re-fail) the whole
+                  // chunk up to its retry limit before the run finally fails.
+                  // Instead the row is recorded above (so its already-succeeded
+                  // sibling cells persist as recoverable), the chunk completes
+                  // normally (persisting all rows), and `runMap` fails the run
+                  // once after the chunk step returns — outside the retry
+                  // wrapper. This keeps both the recoverable export AND the
+                  // single clean run failure.
                 }
               } finally {
                 if (rowMarkedActive) {
@@ -4160,7 +4203,7 @@ function createMinimalWorkerCtx(
               executedIndex: number;
             } => entry !== null,
           );
-        const failedRowsToPersist = failedRowEntries
+        const allFailedRowsToPersist = failedRowEntries
           .map((failure, executedIndex) =>
             failure
               ? {
@@ -4177,6 +4220,20 @@ function createMinimalWorkerCtx(
               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;
         }
@@ -4492,12 +4549,21 @@ function createMinimalWorkerCtx(
       });
     };
 
+    const failFastRowErrors = opts?.onRowError === 'fail';
     let chunkIndex = 0;
     let chunkStart = 0;
-    for await (const chunkRows of iterDatasetChunks(inputRows, rowsPerChunk)) {
+    for await (const rawChunkRows of iterDatasetChunks(inputRows, rowsPerChunk)) {
       assertNotAborted(abortSignal);
-      if (chunkRows.length === 0) continue;
-      assertUniqueExplicitRowKeys(chunkRows, chunkStart);
+      if (rawChunkRows.length === 0) continue;
+      // Drop duplicate explicit-key rows before anything downstream observes
+      // them. `chunkStart` keeps advancing by the original (pre-dedupe) chunk
+      // length so cross-chunk key indices and persisted input offsets stay
+      // aligned to the original input stream.
+      const chunkRows = dedupeExplicitRowKeys(rawChunkRows, chunkStart);
+      if (chunkRows.length === 0) {
+        chunkStart += rawChunkRows.length;
+        continue;
+      }
       const chunkResult = await runChunkStep(chunkRows, chunkStart, chunkIndex);
       totalRowsWritten += chunkResult.rowsWritten;
       totalRowsExecuted += chunkResult.rowsExecuted;
@@ -4541,14 +4607,56 @@ function createMinimalWorkerCtx(
           canCacheRows = false;
         }
       }
-      chunkStart += chunkRows.length;
+      chunkStart += rawChunkRows.length;
       chunkIndex += 1;
+      // onRowError:'fail' short-circuit: once a chunk reports a row failure,
+      // skip the remaining chunks entirely. The failing chunk itself completed
+      // normally (no chunk-step retry storm) and persisted its rows, but
+      // executing later chunks would keep spending provider credits on a run
+      // the caller asked to fail fast. The post-loop fail-fast throw below
+      // reports what committed before the stop.
+      if (failFastRowErrors && totalRowsFailed > 0) {
+        break;
+      }
+    }
+    if (totalDuplicateKeysDropped > 0) {
+      const keySample = droppedDuplicateKeySamples.join(', ');
+      emitEvent({
+        type: 'log',
+        level: 'info',
+        message:
+          `deduped ${totalDuplicateKeysDropped} duplicate dataset key(s) for ctx.dataset("${name}"); keeping first occurrence` +
+          (keySample ? ` (e.g. ${keySample})` : ''),
+        ts: nowMs(),
+      });
+    }
+    if (failFastRowErrors && totalRowsFailed > 0 && totalRowsWritten > 0) {
+      // onRowError:'fail', PARTIAL failure (some rows committed): fail the run
+      // without finalizing the dataset. The committed rows already persisted
+      // per chunk and are surfaced as a recovered dataset (the failed rows'
+      // partial data was intentionally NOT persisted here — only the rows that
+      // fully committed before the failure are recoverable). We reach this
+      // AFTER the failing chunk completed normally (no per-row throw inside
+      // the durable chunk step, so no chunk-step retry storm); later chunks
+      // were skipped by the fail-fast short-circuit in the chunk loop.
+      const firstError = totalRowFailureSamples[0]?.error ?? 'unknown error';
+      throw new Error(
+        `ctx.dataset("${name}") failed for ${totalRowsFailed} executed row(s) under onRowError:'fail'. ` +
+          `First error: ${firstError} ` +
+          `(${totalRowsWritten} row(s) committed before the failure are recoverable — ` +
+          `export them, fix the cause, and re-run to resume)`,
+      );
     }
     if (totalRowsFailed > 0 && totalRowsWritten === 0) {
-      // Every row failed: this is a systemic failure (provider outage, broken
-      // resolver, exhausted credits), not a partial one. Isolating it would
-      // silently complete the run with an empty dataset. Fail loudly — the
-      // failed rows are persisted with their errors and re-execute on re-run.
+      // Every executed row failed — under onRowError:'fail' (the run dies) OR
+      // the default isolation (a systemic failure, not a partial one; isolating
+      // it would silently complete the run with an empty dataset). Fail loudly,
+      // but finalize first so the failed rows' persisted partial cells (the
+      // always-succeeding sibling columns committed by each chunk's persist
+      // step when no row otherwise succeeded) are summarized and registered as
+      // a recovered dataset — the failed run then advertises a WORKING export
+      // instead of a dead end (#15/#27). The run still fails (the throw below).
+      finalize(totalRowsWritten);
       const firstError = totalRowFailureSamples[0]?.error ?? 'unknown error';
       throw new Error(
         `ctx.dataset("${name}") failed for all ${totalRowsFailed} executed rows. ` +

package/dist/repo/sdk/src/http.ts

@@ -250,6 +250,29 @@ export class HttpClient {
           }
 
           if (!response.ok) {
+            // A 5xx that escaped a Worker can return Cloudflare's default HTML
+            // error page. Never surface raw HTML to CLI users: replace the
+            // message with a structured summary and store a short flag in
+            // details instead of the full HTML body. JSON-envelope handling
+            // below is unchanged.
+            const htmlError = detectHtmlErrorBody(
+              body,
+              response.headers.get('content-type'),
+            );
+            if (htmlError) {
+              throw new DeeplineError(
+                htmlError.message(response.status),
+                response.status,
+                'API_ERROR',
+                {
+                  htmlErrorPage: true,
+                  ...(htmlError.title ? { title: htmlError.title } : {}),
+                  ...(htmlError.workerThrewException
+                    ? { workerThrewException: true }
+                    : {}),
+                },
+              );
+            }
             const errorValue =
               typeof parsed === 'object' && parsed && 'error' in parsed
                 ? (parsed as Record<string, unknown>).error
@@ -343,6 +366,24 @@ export class HttpClient {
         }
         if (!response.ok) {
           const body = await response.text();
+          const htmlError = detectHtmlErrorBody(
+            body,
+            response.headers.get('content-type'),
+          );
+          if (htmlError) {
+            throw new DeeplineError(
+              htmlError.message(response.status),
+              response.status,
+              'API_ERROR',
+              {
+                htmlErrorPage: true,
+                ...(htmlError.title ? { title: htmlError.title } : {}),
+                ...(htmlError.workerThrewException
+                  ? { workerThrewException: true }
+                  : {}),
+              },
+            );
+          }
           const parsed = parseResponseBody(body);
           throw new DeeplineError(
             apiErrorMessage(parsed, response.status),
@@ -430,6 +471,54 @@ function parseResponseBody(body: string): unknown {
   }
 }
 
+/**
+ * Detect a raw Cloudflare HTML error page in an error response body.
+ *
+ * A 5xx that escaped a Worker can return Cloudflare's default HTML error page
+ * ("Worker threw exception" / error code 1042). We must never surface raw HTML
+ * to CLI users — it lands verbatim in `DeeplineError.message`/`details`. When
+ * detected, we synthesize a structured message (status + extracted <title>) and
+ * preserve the literal token `Worker threw exception` when present, since SDK
+ * retry classifiers (`isTransientPlayStreamError`) regex-match on it.
+ */
+function detectHtmlErrorBody(
+  body: string,
+  contentType?: string | null,
+): {
+  title?: string;
+  workerThrewException: boolean;
+  message: (status: number) => string;
+} | null {
+  const trimmed = body.trim();
+  const lower = trimmed.toLowerCase();
+  const isHtml =
+    (contentType ?? '').toLowerCase().includes('text/html') ||
+    lower.startsWith('<!doctype') ||
+    lower.startsWith('<html');
+  if (!isHtml) {
+    return null;
+  }
+  const titleMatch = trimmed.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  const title = titleMatch?.[1]?.replace(/\s+/g, ' ').trim() || undefined;
+  const workerThrewException = /worker threw exception/i.test(trimmed);
+  return {
+    title,
+    workerThrewException,
+    message: (status: number): string => {
+      // Detail segments joined with ': ', then the suppression note appended
+      // in parens so it never reads as another colon-delimited segment.
+      const segments = [`HTTP ${status}`];
+      if (workerThrewException) {
+        segments.push('Worker threw exception');
+      }
+      if (title) {
+        segments.push(title);
+      }
+      return `${segments.join(': ')} (Cloudflare HTML error page suppressed)`;
+    },
+  };
+}
+
 function apiErrorMessage(parsed: unknown, status: number): string {
   const errorValue =
     typeof parsed === 'object' && parsed && 'error' in parsed

package/dist/repo/sdk/src/release.ts

@@ -53,10 +53,15 @@ export const SDK_RELEASE = {
   // 0.1.94 is claimed by PR #1527 — this watch-render fix ships as 0.1.95.
   // 0.1.98 ships the duplicate-browser-tab fix (default-browser detection).
   // 0.1.99 ships prebuilt job-change source-column preservation and validation fixes.
-  version: '0.1.100',
+  // 0.1.101 ships retryable play artifact publish failures and CI retry hardening.
+  // 0.1.102 ships the job-change ledger fixes: recovered-dataset export on
+  // failed runs, persisted/succeeded/failed row counts, strict local CSV
+  // preflight (existence, data rows, quotes, duplicate headers), HTML error
+  // scrubbing, and word-boundary watch truncation.
+  version: '0.1.102',
   apiContract: '2026-06-dataset-column-cell-stale-hard-cutover',
   supportPolicy: {
-    latest: '0.1.100',
+    latest: '0.1.102',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
   },

package/dist/repo/sdk/src/stream-reconnect.ts

@@ -38,7 +38,7 @@ export function isTransientPlayStreamError(error: unknown): boolean {
     return error.statusCode >= 500 && error.statusCode < 600;
   }
   const text = error instanceof Error ? error.message : String(error);
-  return /auth validation backend timed out|fetch failed|eaddrnotavail|econnreset|etimedout|eai_again|socket hang up/i.test(
+  return /auth validation backend timed out|coordinator \/submit(?:\?[^ ]*)? 5\d\d|Worker threw exception|Internal Server Error|Service Unavailable|fetch failed|eaddrnotavail|econnreset|etimedout|eai_again|socket hang up/i.test(
     text,
   );
 }

package/dist/repo/shared_libs/play-runtime/map-row-identity.ts

@@ -0,0 +1,204 @@
+import {
+  derivePlayRowIdentity,
+  derivePlayRowIdentityFromKey,
+  // Relative (not '@shared_libs/...') because this file ships inside the
+  // packed SDK's dist/repo source graph (reachable from the
+  // apps/play-runner-workers entry), where only relative imports resolve.
+} from '../plays/row-identity';
+import type { MapExecutionScope } from './ctx-types';
+
+export type ExplicitMapKeyResolver = (
+  row: Record<string, unknown>,
+  index: number,
+) => string;
+
+export type ExplicitMapKeyInput =
+  | string
+  | readonly string[]
+  | ((row: Record<string, unknown>, index: number) => unknown);
+
+export function stripMapFieldOutputs(
+  row: Record<string, unknown>,
+  fieldNames: readonly string[],
+): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(row).filter(
+      ([fieldName]) => !fieldNames.includes(fieldName),
+    ),
+  );
+}
+
+export function createExplicitMapKeyResolver(input: {
+  mapNamespace: string;
+  fieldNames: readonly string[];
+  key: ExplicitMapKeyInput | null | undefined;
+}): ExplicitMapKeyResolver | null {
+  if (!input.key) {
+    return null;
+  }
+  const key = input.key;
+  return (row, index) => {
+    const stableRow = stripMapFieldOutputs(row, input.fieldNames);
+    let raw: unknown;
+    if (typeof key === 'function') {
+      raw = key(stableRow, index);
+    } else if (typeof key === 'string') {
+      raw = stableRow[key];
+    } else {
+      raw = key.map((fieldName) => stableRow[fieldName]);
+    }
+    if (raw === null || raw === undefined) {
+      throw new Error(
+        `ctx.dataset("${input.mapNamespace}") key function returned ${raw === null ? 'null' : 'undefined'} for row ${index}. ` +
+          'Use a non-empty stable input column (e.g. { key: "email" }) or return a non-empty string, number, or tuple.',
+      );
+    }
+    const asString = normalizeExplicitMapKey(raw);
+    if (!asString) {
+      throw new Error(
+        `ctx.dataset("${input.mapNamespace}") key function returned an empty value for row ${index}. ` +
+          'Use non-empty stable input columns or return a non-empty string, number, or tuple.',
+      );
+    }
+    return asString;
+  };
+}
+
+function normalizeExplicitMapKey(value: unknown): string {
+  if (Array.isArray(value)) {
+    const parts = value.map((entry) => normalizeExplicitMapKeyPart(entry));
+    return parts.every(Boolean) ? JSON.stringify(parts) : '';
+  }
+  return normalizeExplicitMapKeyPart(value);
+}
+
+function normalizeExplicitMapKeyPart(value: unknown): string {
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? String(value) : '';
+  }
+  return String(value ?? '').trim();
+}
+
+/**
+ * Maximum number of distinct duplicate keys retained in dedupe metadata for
+ * observability. Keeps log lines bounded when many keys collide.
+ */
+export const DEDUPE_DUPLICATE_KEY_SAMPLE_CAP = 5;
+
+export interface DedupeExplicitMapKeyResult<TRow> {
+  /** Rows with duplicates removed; first occurrence per key kept, order preserved. */
+  rows: TRow[];
+  /** Count of rows dropped because an earlier row produced the same key. */
+  droppedCount: number;
+  /** Capped sample of the duplicate key values that were deduped. */
+  duplicateKeys: string[];
+}
+
+/**
+ * Resolver shape used by {@link dedupeExplicitMapKeyRows}. Receives each row in
+ * its original (pre-dedupe) position. Callers that hold output rows in a
+ * different form than `Record<string, unknown>` adapt to this signature with a
+ * thin wrapper.
+ */
+export type DedupeKeyResolver<TRow> = (row: TRow, index: number) => string;
+
+/**
+ * Silent dedupe for explicit `ctx.dataset(...)` map keys. Keeps the first row
+ * for each canonical key and drops subsequent duplicates, preserving original
+ * order. With no resolver this is a pure passthrough (a fresh array copy with
+ * empty metadata). Replaces the prior throw-on-duplicate behavior per product
+ * decision: duplicate keys should never fail the run.
+ */
+export function dedupeExplicitMapKeyRows<TRow>(input: {
+  rows: readonly TRow[];
+  resolver: DedupeKeyResolver<TRow> | null;
+}): DedupeExplicitMapKeyResult<TRow> {
+  if (!input.resolver) {
+    return { rows: [...input.rows], droppedCount: 0, duplicateKeys: [] };
+  }
+  const resolver = input.resolver;
+  const seenKeys = new Set<string>();
+  const duplicateKeys: string[] = [];
+  const seenDuplicateKeys = new Set<string>();
+  const rows: TRow[] = [];
+  for (let index = 0; index < input.rows.length; index += 1) {
+    const row = input.rows[index]!;
+    const keyValue = resolver(row, index);
+    if (seenKeys.has(keyValue)) {
+      if (
+        !seenDuplicateKeys.has(keyValue) &&
+        duplicateKeys.length < DEDUPE_DUPLICATE_KEY_SAMPLE_CAP
+      ) {
+        duplicateKeys.push(keyValue);
+      }
+      seenDuplicateKeys.add(keyValue);
+      continue;
+    }
+    seenKeys.add(keyValue);
+    rows.push(row);
+  }
+  return {
+    rows,
+    droppedCount: input.rows.length - rows.length,
+    duplicateKeys,
+  };
+}
+
+export function deriveMapRowIdentity(input: {
+  row: Record<string, unknown>;
+  index?: number;
+  artifactTableNamespace: string;
+  fieldNames?: readonly string[];
+  explicitKey?: ExplicitMapKeyResolver | null;
+}): string {
+  const stableRow = stripMapFieldOutputs(input.row, input.fieldNames ?? []);
+  return input.explicitKey
+    ? derivePlayRowIdentityFromKey(
+        input.explicitKey(stableRow, input.index ?? 0),
+        input.artifactTableNamespace,
+      )
+    : derivePlayRowIdentity(stableRow, input.artifactTableNamespace);
+}
+
+export class MapRowIdentity {
+  private nextInvocationIndex: number;
+
+  constructor(startInvocationIndex = 0) {
+    this.nextInvocationIndex = startInvocationIndex;
+  }
+
+  get invocationIndex(): number {
+    return this.nextInvocationIndex;
+  }
+
+  set invocationIndex(value: number) {
+    this.nextInvocationIndex = value;
+  }
+
+  createScope(input: {
+    logicalNamespace: string;
+    artifactTableNamespace: string;
+    mapNodeId?: string | null;
+    fieldNames?: readonly string[];
+    explicitKey?: ExplicitMapKeyResolver | null;
+  }): MapExecutionScope {
+    const mapInvocationId = `${input.logicalNamespace}:${this.nextInvocationIndex}`;
+    this.nextInvocationIndex += 1;
+    const explicitKey = input.explicitKey ?? null;
+    const fieldNames = input.fieldNames ?? [];
+    return {
+      mapInvocationId,
+      mapNodeId: input.mapNodeId ?? null,
+      logicalNamespace: input.logicalNamespace,
+      artifactTableNamespace: input.artifactTableNamespace,
+      rowIdentity: (row, index) =>
+        deriveMapRowIdentity({
+          row,
+          index,
+          artifactTableNamespace: input.artifactTableNamespace,
+          fieldNames,
+          explicitKey,
+        }),
+    };
+  }
+}

package/dist/repo/shared_libs/play-runtime/run-ledger.ts

@@ -592,13 +592,18 @@ export function reducePlayRunLedgerEvent(
   };
 
   switch (event.type) {
-    case 'run.created':
+    case 'run.created': {
+      const createdStatus = event.status ?? base.status;
       return withTiming({
         ...base,
         playName: event.playName ?? base.playName ?? null,
-        status: event.status ?? base.status,
+        status: createdStatus,
         createdAt: base.createdAt ?? occurredAt,
+        startedAt:
+          base.startedAt ??
+          (createdStatus === 'running' ? occurredAt : base.startedAt),
       });
+    }
     case 'run.started':
       return withTiming({
         ...base,

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

@@ -50,6 +50,10 @@ export type PlayRunStreamNodeState = {
 export type PlayRunLiveSnapshot = {
   runId: string;
   status: PlayRunLiveStatus;
+  createdAt?: number | null;
+  startedAt?: number | null;
+  finishedAt?: number | null;
+  durationMs?: number | null;
   updatedAt: number | null;
   /**
    * Rotating log tail (the ledger snapshot's bounded `logTail`; the wire name
@@ -167,6 +171,10 @@ function buildSnapshotFromLedger(
   return {
     runId: snapshot.runId,
     status: normalizePlayRunLiveStatus(snapshot.status),
+    createdAt: snapshot.createdAt ?? null,
+    startedAt: snapshot.startedAt ?? null,
+    finishedAt: snapshot.finishedAt ?? null,
+    durationMs: snapshot.durationMs ?? null,
     updatedAt:
       snapshot.updatedAt ?? snapshot.finishedAt ?? snapshot.startedAt ?? null,
     logs: snapshot.logTail,

package/package.json

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