deepline 0.1.209 → 0.1.211

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

@@ -281,7 +281,6 @@ export type CustomerDbQueryHandler = (
 
 export interface PlayCallOptions {
   description?: string;
-  staleAfterSeconds?: number;
 }
 
 export interface StepOptions {
@@ -591,7 +590,7 @@ export interface ContextOptions {
   runId?: string;
   /** Physical executor run that owns leases for an inline child context. */
   runtimeReceiptOwnerRunId?: string;
-  /** Logical invocation scope for nested step/fetch/runPlay receipt identity. */
+  /** Logical invocation scope for receipts created inside an inline child. */
   runtimeReceiptScope?: string;
   runAttempt?: number | null;
   /**

package/dist/bundling-sources/shared_libs/play-runtime/durable-call-cache.ts

@@ -9,7 +9,7 @@ import {
 
 export const DURABLE_CALL_CACHE_POLICY_VERSION = 'call-cache-v1';
 
-export type DurableCallKind = 'tool' | 'step' | 'fetch' | 'runPlay';
+export type DurableCallKind = 'tool' | 'step' | 'fetch';
 
 function validateStaleAfterSeconds(staleAfterSeconds?: number | null): void {
   if (staleAfterSeconds === undefined || staleAfterSeconds === null) {
@@ -121,16 +121,14 @@ export function buildDurableCtxCallCacheKey(input: {
   return `ctx:${orgId}:call:${input.kind}:${normalizedId}:${digest}`;
 }
 
-export function buildDurableRunPlaySemanticKey(input: {
+export function buildDurableRunPlayInvocationScope(input: {
   childPlayName: string;
   input: Record<string, unknown>;
-  childRevisionFingerprint?: string | null;
   rowScope?: Record<string, unknown> | null;
 }): string {
   return sha256Hex(
     stableStringify({
       childPlayName: input.childPlayName.trim(),
-      childRevisionFingerprint: input.childRevisionFingerprint ?? null,
       input: input.input,
       rowScope: input.rowScope ?? null,
     }),

package/dist/bundling-sources/shared_libs/play-runtime/durable-receipt-execution.ts

@@ -243,9 +243,11 @@ async function executeWithDurableRuntimeReceiptHeartbeat<T>(input: {
       rejectLeaseLost(error as RuntimeReceiptLeaseLostError),
   });
 
-  if ((await heartbeatOnce()) === 'active') {
-    supervisor.start();
-  }
+  // markRunning is the authoritative pre-dispatch ownership fence. Renewal is
+  // only needed when the lease approaches expiry; an immediate read/renewal
+  // adds a round trip to every short tool call without extending ownership.
+  // Completion remains conditional on this lease, and long work still renews.
+  supervisor.start();
   try {
     return await Promise.race([input.execute(), leaseLost]);
   } finally {
@@ -294,6 +296,7 @@ export async function waitForCompletedRuntimeReceipts(input: {
   maxAttempts?: number;
   delayMs?: number;
   abortSignal?: AbortSignal;
+  log?: (message: string) => void;
 }): Promise<{
   completed: Map<string, RuntimeStepReceipt>;
   failed: Map<string, Error>;
@@ -326,6 +329,20 @@ export async function waitForCompletedRuntimeReceipts(input: {
       }
       throw error;
     }
+    const statuses = [...receipts.values()].reduce<Record<string, number>>(
+      (counts, receipt) => {
+        counts[receipt.status] = (counts[receipt.status] ?? 0) + 1;
+        return counts;
+      },
+      {},
+    );
+    input.log?.(
+      `[perf] runtime-receipt-wait attempt=${attempt} requested=${pending.size} indexed=${receipts.size} statuses=${
+        Object.entries(statuses)
+          .map(([status, count]) => `${status}:${count}`)
+          .join(',') || 'none'
+      }`,
+    );
     for (const key of [...pending]) {
       const receipt = receipts.get(key);
       if (receipt?.status === 'completed' || receipt?.status === 'skipped') {
@@ -343,6 +360,9 @@ export async function waitForCompletedRuntimeReceipts(input: {
         pending.delete(key);
       }
     }
+    input.log?.(
+      `[perf] runtime-receipt-wait attempt=${attempt} remaining=${pending.size}`,
+    );
   }
 
   return { completed, failed, timedOut: pending };
@@ -374,6 +394,16 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
   log: (message: string) => void;
   execute: (context: { leaseId: string | null }) => Promise<T>;
 }): Promise<T> {
+  const lifecycleStartedAt = Date.now();
+  const logPhase = (phase: string, startedAt: number): void => {
+    // Keep this at the semantic receipt layer. Transport timing below this
+    // function explains HTTP cost; these markers expose gaps before/after the
+    // store calls and prove whether user code or receipt orchestration owns the
+    // elapsed time. Do not log receipt keys because they encode tool inputs.
+    input.log(
+      `[perf] durable receipt operation=${input.operation} id=${input.id} phase=${phase} elapsed_ms=${Date.now() - startedAt} lifecycle_ms=${Date.now() - lifecycleStartedAt}`,
+    );
+  };
   if (!input.store.enabled) {
     return await input.execute({ leaseId: null });
   }
@@ -483,12 +513,14 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
     );
   };
 
+  const claimStartedAt = Date.now();
   const claimed = await input.store.claim(
     input.receiptKey,
     input.runId,
     input.reclaimRunning === true || input.force === true,
     input.force === true,
   );
+  logPhase('claim', claimStartedAt);
   if (
     input.force !== true &&
     (claimed?.status === 'completed' || claimed?.status === 'skipped')
@@ -525,11 +557,13 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
   let result: T;
   try {
     if (input.markRunningBeforeExecute !== false && input.store.markRunning) {
+      const markRunningStartedAt = Date.now();
       const running = await input.store.markRunning(
         input.receiptKey,
         input.runId,
         ownedLeaseId,
       );
+      logPhase('mark_running', markRunningStartedAt);
       if (!running || running.status !== 'running') {
         throw new RuntimeReceiptLeaseLostError({
           receiptKey: input.receiptKey,
@@ -540,6 +574,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
       ownedLeaseId = running.leaseId ?? ownedLeaseId;
       ownedLeaseExpiresAt = running.leaseExpiresAt ?? ownedLeaseExpiresAt;
     }
+    const executeStartedAt = Date.now();
     const executed =
       ownedLeaseId && input.store.heartbeat
         ? await executeWithDurableRuntimeReceiptHeartbeat({
@@ -561,6 +596,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
             execute: () => input.execute({ leaseId: ownedLeaseId }),
           })
         : await input.execute({ leaseId: ownedLeaseId });
+    logPhase('execute', executeStartedAt);
     result = input.onClaimedResult
       ? input.onClaimedResult(executed, input.receiptKey)
       : executed;
@@ -603,12 +639,14 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
     throw error;
   }
 
+  const completeStartedAt = Date.now();
   const completed = await input.store.complete(
     input.receiptKey,
     input.runId,
     isToolExecuteResult(result) ? serializeToolExecuteResult(result) : result,
     ownedLeaseId,
   );
+  logPhase('complete', completeStartedAt);
   if (
     !completed ||
     (completed.status !== 'completed' && completed.status !== 'skipped')
@@ -633,6 +671,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
     completed &&
     (completed.status === 'completed' || completed.status === 'skipped')
   ) {
+    logPhase('total', lifecycleStartedAt);
     return await recoverCompletedReceipt(completed, 'owner');
   }
   if (input.store.canPersistCompletion) {

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

@@ -344,13 +344,17 @@ export async function stageDaytonaRunnerPayload(input: {
   const outputPath = `${workDir}/deepline-play-output-${randomUUID()}.log`;
   const exitCodePath = `${workDir}/deepline-play-exit-${randomUUID()}.txt`;
   const progressEventPath = `${workDir}/deepline-play-progress-${randomUUID()}.jsonl`;
+  const runnerTraceEnv =
+    process.env.DEEPLINE_RUNTIME_RECEIPT_TRACE === '1'
+      ? 'DEEPLINE_RUNTIME_RECEIPT_TRACE=1 '
+      : '';
   const runnerCommand = `${nodeMaterializePayloadCommand({
     envelopePath,
     runnerPath,
     configPath,
     artifactCodePath,
     crashPusherPath,
-  })} && DEEPLINE_PLAY_RUNNER_PROGRESS_EVENT_PATH=${shellQuote(progressEventPath)} DEEPLINE_PLAY_RUNNER_STDOUT_EVENT_MODE=compact node ${shellQuote(runnerPath)} ${shellQuote(configPath)}`;
+  })} && 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
   // pushes the parsed (or synthesized) terminal to the gateway so the parked
   // worker wakes within seconds of ANY runner death — process.exit abuse, OOM

package/dist/bundling-sources/shared_libs/play-runtime/single-flight.ts

@@ -0,0 +1,31 @@
+export type SingleFlight<K, V> = {
+  run(key: K, create: () => Promise<V>): Promise<V>;
+  has(key: K): boolean;
+  activeCount(): number;
+};
+
+/** Coalesce concurrent work for one key without caching its settled result. */
+export function createSingleFlight<K, V>(): SingleFlight<K, V> {
+  const active = new Map<K, Promise<V>>();
+
+  return {
+    run(key, create) {
+      const existing = active.get(key);
+      if (existing) return existing;
+
+      const pending = Promise.resolve().then(create);
+      active.set(key, pending);
+      const clear = () => {
+        if (active.get(key) === pending) active.delete(key);
+      };
+      void pending.then(clear, clear);
+      return pending;
+    },
+    has(key) {
+      return active.has(key);
+    },
+    activeCount() {
+      return active.size;
+    },
+  };
+}

package/dist/bundling-sources/shared_libs/play-runtime/test-runtime-seams.ts

@@ -34,6 +34,8 @@ type ValidatedRuntimeTestFaultHeader =
   | { ok: false; status: 400 | 403; error: string };
 
 export type RuntimeTestPolicyOverrides = {
+  /** Opt-in bounded runner map latency profile for local/preview diagnosis. */
+  mapLatencyProfile?: boolean;
   receiptLeaseTtlMs?: number;
   sheetAttemptLeaseMs?: number;
   heartbeatIntervalMs?: number;
@@ -170,7 +172,8 @@ function parseRuntimeTestPolicyOverrides(
   const unknownKeys = Object.keys(record).filter(
     (key) =>
       !RUNTIME_TEST_POLICY_MS_FIELDS.has(key) &&
-      key !== 'workBudgetYieldLimits',
+      key !== 'workBudgetYieldLimits' &&
+      key !== 'mapLatencyProfile',
   );
   if (unknownKeys.length > 0) {
     return {
@@ -179,6 +182,14 @@ function parseRuntimeTestPolicyOverrides(
   }
 
   const overrides: RuntimeTestPolicyOverrides = {};
+  if ('mapLatencyProfile' in record) {
+    if (typeof record.mapLatencyProfile !== 'boolean') {
+      return {
+        error: 'testPolicyOverrides.mapLatencyProfile must be a boolean.',
+      };
+    }
+    overrides.mapLatencyProfile = record.mapLatencyProfile;
+  }
   for (const field of RUNTIME_TEST_POLICY_MS_FIELDS) {
     if (!(field in record)) continue;
     const parsed = readPositiveIntegerField({

package/dist/bundling-sources/shared_libs/plays/dataset.ts

@@ -125,7 +125,7 @@ export interface PlayDataset<T> extends AsyncIterable<T> {
    * Large datasets should flow by handle through Neon-backed storage, not
    * through worker memory as giant arrays.
    */
-  materialize(limit?: number): Promise<T[]>;
+  materialize(options?: number | PlayDatasetMaterializeOptions): Promise<T[]>;
   toJSON(): {
     kind: 'dataset';
     datasetKind: PlayDatasetKind;
@@ -146,9 +146,19 @@ type PlayDatasetResolvers<T> = {
   count: () => Promise<number>;
   peek: (limit: number) => Promise<T[]>;
   materialize: (limit?: number) => Promise<T[]>;
+  materializeFullPersistedDataset?: (limit?: number) => Promise<T[]>;
   iterate: () => AsyncIterable<T>;
 };
 
+export type PlayDatasetMaterializeScope = 'result' | 'full_persisted_dataset';
+
+export type PlayDatasetMaterializeOptions = {
+  /** Rows returned by this operation, or every current row in its persisted dataset. */
+  scope?: PlayDatasetMaterializeScope;
+  /** Maximum number of rows to load into memory. */
+  limit?: number;
+};
+
 type PlayDatasetTransform<T, U = T> =
   | {
       kind: 'map';
@@ -164,7 +174,7 @@ type PlayDatasetTransform<T, U = T> =
       end?: number;
     };
 
-function resolveMaterializeLimitCap(): number {
+export function resolveMaterializeLimitCap(): number {
   const raw = process.env.DEEPLINE_PLAY_DATASET_MATERIALIZE_LIMIT;
   const parsed = raw ? Number(raw) : NaN;
   if (Number.isFinite(parsed) && parsed > 0) {
@@ -301,10 +311,25 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
     return this.slice(0, limit, options);
   }
 
-  async materialize(limit?: number): Promise<T[]> {
+  async materialize(
+    options?: number | PlayDatasetMaterializeOptions,
+  ): Promise<T[]> {
+    const scope =
+      typeof options === 'object' ? (options.scope ?? 'result') : 'result';
+    const limit = typeof options === 'number' ? options : options?.limit;
     const requestedLimit =
       limit !== undefined ? Math.max(0, Math.floor(limit)) : undefined;
     const cap = resolveMaterializeLimitCap();
+    const materialize =
+      scope === 'full_persisted_dataset'
+        ? this.resolvers.materializeFullPersistedDataset
+        : this.resolvers.materialize;
+    if (!materialize) {
+      throw new Error(
+        'PlayDataset.materialize({ scope: "full_persisted_dataset" }) is only available ' +
+          'for a persisted dataset returned by ctx.dataset(...).run().',
+      );
+    }
     if (requestedLimit !== undefined) {
       if (requestedLimit > cap) {
         throw new Error(
@@ -312,7 +337,18 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
             'Return the dataset handle instead, or request a smaller bounded slice.',
         );
       }
-      return await this.resolvers.materialize(requestedLimit);
+      return await materialize(requestedLimit);
+    }
+
+    if (scope === 'full_persisted_dataset') {
+      const rows = await materialize(cap + 1);
+      if (rows.length > cap) {
+        throw new Error(
+          'PlayDataset.materialize({ scope: "full_persisted_dataset" }) refuses to load ' +
+            `more than ${cap} rows into memory. Pass an explicit bounded limit.`,
+        );
+      }
+      return rows;
     }
 
     const count = await this.count();
@@ -322,7 +358,7 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
           `The hard limit is ${cap}. Return the dataset handle instead or call materialize(limit).`,
       );
     }
-    return await this.resolvers.materialize();
+    return await materialize();
   }
 
   async *[Symbol.asyncIterator](): AsyncIterator<T> {

package/dist/cli/index.js

@@ -623,10 +623,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.209",
+  version: "0.1.211",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.209",
+    latest: "0.1.211",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -10826,7 +10826,8 @@ var PLAY_RUN_RESERVED_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "--logs",
   "--full",
   "--force",
-  "--no-open"
+  "--no-open",
+  "--debug-map-latency"
 ]);
 function traceCliSync(phase, fields, run) {
   const startedAt = Date.now();
@@ -14173,6 +14174,7 @@ function parsePlayRunOptions(args) {
   const emitLogs = !jsonOutput || args.includes("--logs");
   const force = args.includes("--force");
   const noOpen = args.includes("--no-open");
+  const debugMapLatency = args.includes("--debug-map-latency");
   let waitTimeoutMs = null;
   let profile = null;
   for (let index = 0; index < args.length; index += 1) {
@@ -14291,7 +14293,8 @@ function parsePlayRunOptions(args) {
     waitTimeoutMs,
     force,
     noOpen,
-    profile
+    profile,
+    debugMapLatency
   };
 }
 function parsePlayCheckOptions(args) {
@@ -14776,6 +14779,7 @@ async function handleFileBackedRun(options) {
     ...stagedFileInputs.packagedFiles.length ? { packagedFiles: stagedFileInputs.packagedFiles } : {},
     ...options.force ? { force: true } : {},
     ...options.profile ? { profile: options.profile } : {},
+    ...options.debugMapLatency ? { testPolicyOverrides: { mapLatencyProfile: true } } : {},
     ...integrationMode ? { integrationMode } : {}
   };
   if (options.watch) {
@@ -14937,6 +14941,7 @@ async function handleNamedRun(options) {
     ...stagedFileInputs.packagedFiles.length ? { packagedFiles: stagedFileInputs.packagedFiles } : {},
     ...options.force ? { force: true } : {},
     ...options.profile ? { profile: options.profile } : {},
+    ...options.debugMapLatency ? { testPolicyOverrides: { mapLatencyProfile: true } } : {},
     ...integrationMode ? { integrationMode } : {}
   };
   if (options.watch) {
@@ -16185,7 +16190,10 @@ Examples:
   ).option("--watch", "Compatibility alias; run waits by default").option("--wait", "Compatibility alias; run waits by default").option("--no-wait", "Start the run and return immediately").option(
     "--logs",
     "When output is non-interactive, stream play logs to stderr while waiting"
-  ).option("--tail-timeout-ms <ms>", "Timeout while watching the run stream").option("--force", "Start a fresh run graph").option("--no-open", "Print the play page URL without opening a browser").option("--json", "Emit JSON output").option("--full", "Debug only: with --json, emit the raw status payload").addHelpText(
+  ).option("--tail-timeout-ms <ms>", "Timeout while watching the run stream").option("--force", "Start a fresh run graph").option(
+    "--debug-map-latency",
+    "Internal diagnostics: emit one aggregate latency profile per dataset map"
+  ).option("--no-open", "Print the play page URL without opening a browser").option("--json", "Emit JSON output").option("--full", "Debug only: with --json, emit the raw status payload").addHelpText(
     "afterAll",
     `
 Pass-through input flags:
@@ -16221,6 +16229,7 @@ Pass-through input flags:
       ...options.logs ? ["--logs"] : [],
       ...options.tailTimeoutMs ? ["--tail-timeout-ms", options.tailTimeoutMs] : [],
       ...options.force ? ["--force"] : [],
+      ...options.debugMapLatency ? ["--debug-map-latency"] : [],
       ...options.noOpen || options.open === false ? ["--no-open"] : [],
       ...options.json ? ["--json"] : [],
       ...options.full ? ["--full"] : [],
@@ -17215,12 +17224,9 @@ function renderColumnRunIfFunction(command) {
   if (!command.run_if_js) {
     return null;
   }
-  if (command.play) {
-    return `(__dlRawRow) => { const row = __dlPrepareEnrichRow(__dlRawRow, [${stringLiteral(command.alias)}]); const input = row; const context = row;
+  return `(__dlRawRow) => { const row = __dlPrepareEnrichRow(__dlRawRow, [${stringLiteral(command.alias)}]); const input = row; const context = row;
 ${indent(renderJavascriptBody(command.run_if_js), 6)}
     }`;
-  }
-  return renderRunIfFunction(command);
 }
 function renderCombinedRunIfFunction(precheck, runIfSource) {
   if (!runIfSource) {
@@ -17273,6 +17279,8 @@ function renderPlayStep(command, options) {
     `  const __dlRunIf = ${runIfJs};`,
     `  if (!__dlRunIf(templateRow)) return null;`
   ] : [];
+  const inline = command.play?.inline;
+  const inlineHandler = inline ? `__dlInlinePlay_${inline.sourceHash.slice(0, 16)}` : null;
   return [
     `async (row, stepCtx) => {`,
     ...options.precheck ? [`  if (${options.precheck}) return null;`] : [],
@@ -17282,9 +17290,16 @@ function renderPlayStep(command, options) {
     `  if (__dlShouldSkipBlankPlayPayload(payload)) return null;`,
     `  let result: unknown;`,
     `  try {`,
-    `    result = await stepCtx.runPlay(${callId}, ${playRef}, payload, {`,
-    `        description: ${stringLiteral(command.description ?? command.alias)}`,
-    `    });`,
+    ...inlineHandler ? [
+      // Enrich validates and normalizes this payload against the certified
+      // prebuilt contract before code generation. The attachment retains
+      // its concrete input type, while generated payloads are records.
+      `    result = await __dlRunInlinePlay(${inlineHandler}, stepCtx, payload as never, ${options.force});`
+    ] : [
+      `    result = await stepCtx.runPlay(${callId}, ${playRef}, payload, {`,
+      `        description: ${stringLiteral(command.description ?? command.alias)}`,
+      `    });`
+    ],
     `  } catch (error) {`,
     ...options.waterfallSoftFail ? [`    return __dlWaterfallToolFailure(error);`] : [`    throw error;`],
     `  }`,
@@ -17292,6 +17307,19 @@ function renderPlayStep(command, options) {
     `}`
   ].join("\n");
 }
+function collectInlinePlayHandlers(commands) {
+  const handlers = /* @__PURE__ */ new Map();
+  const visit = (command) => {
+    if (isWaterfall(command)) {
+      command.commands.forEach(visit);
+      return;
+    }
+    const inline = command.play?.inline;
+    if (inline) handlers.set(inline.sourceHash, inline);
+  };
+  commands.forEach(visit);
+  return [...handlers.values()];
+}
 function renderInlineJavascriptStep(command, options) {
   const alias = stringLiteral(command.alias);
   const extractJs = renderExtractFunction(command, 4);
@@ -17492,6 +17520,10 @@ function compileEnrichConfigToPlaySource(config, options = {}) {
     [...options.forceAliases ?? []].map((alias) => normalizeAlias(alias))
   );
   const columnSteps = [];
+  const inlineHandlers = collectInlinePlayHandlers(config.commands);
+  const inlineTypeImports = [
+    ...new Set(inlineHandlers.flatMap((inline) => inline.typeImports ?? []))
+  ].sort();
   config.commands.forEach((command) => {
     if (isWaterfall(command)) {
       columnSteps.push(
@@ -17529,6 +17561,19 @@ function compileEnrichConfigToPlaySource(config, options = {}) {
   const generatedAliases = collectGeneratedAliases(config.commands);
   const runOptionsSource = options.failFast ? `{ key: (row, index) => __dlEnrichRowKey(row, index + rowStart), onRowError: 'fail' as const }` : `{ key: (row, index) => __dlEnrichRowKey(row, index + rowStart) }`;
   const body = [
+    `function __dlRunInlinePlay<TContext, TInput, TOutput>(handler: (ctx: TContext, input: TInput) => Promise<TOutput>, scope: TContext, payload: TInput, force: boolean): Promise<TOutput> {`,
+    `  if (!force) return handler(scope, payload);`,
+    `  const runtimeScope = scope as TContext & { __deeplineRunWithForcedTools?: <T>(run: () => Promise<T>) => Promise<T> };`,
+    `  if (typeof runtimeScope.__deeplineRunWithForcedTools !== 'function') {`,
+    `    throw new Error('This runtime does not support forced certified inline play execution.');`,
+    `  }`,
+    `  return runtimeScope.__deeplineRunWithForcedTools(() => handler(scope, payload));`,
+    `}`,
+    ``,
+    ...inlineHandlers.flatMap((inline) => [
+      `const __dlInlinePlay_${inline.sourceHash.slice(0, 16)} = ${inline.functionExpressionSource};`,
+      ``
+    ]),
     `export default definePlay(${stringLiteral(playName)}, async (ctx, input: EnrichInput) => {`,
     `  const sourceRows = await ctx.csv<Record<string, unknown>>(input.file);`,
     `  const rowStart = __dlNonNegativeInteger(input.rowStart, 0);`,
@@ -17553,7 +17598,8 @@ function compileEnrichConfigToPlaySource(config, options = {}) {
   const helpers = idiomaticGetters ? selectUsedHelpers(helperSource(), body.join("\n")) : helperSource();
   return [
     ...inlineRunJavascript && configHasRunJavascript(config) ? ["// @ts-nocheck", "/* eslint-disable */", ""] : [],
-    `import { definePlay } from 'deepline';`,
+    `import { definePlay, steps } from 'deepline';`,
+    ...inlineTypeImports.length > 0 ? [`import type { ${inlineTypeImports.join(", ")} } from 'deepline';`] : [],
     ``,
     `type EnrichInput = { file: string; rowStart?: number | null; rowEnd?: number | null };`,
     ``,
@@ -18768,7 +18814,8 @@ async function buildPlanArgs(args) {
     "--fail-fast",
     "--all",
     "--in-place",
-    "--no-open"
+    "--no-open",
+    "--debug-map-latency"
   ]);
   const planArgs = [];
   for (let index = 0; index < args.length; index += 1) {
@@ -21321,11 +21368,15 @@ async function fetchBackingRowsForCsvExport(input2) {
 }
 function mergeRowsForCsvExport(enrichedRows, options) {
   const compactAliases = options?.config ? enrichAiRuntimeCompactAliases(options.config) : /* @__PURE__ */ new Set();
+  const preservedAliases = /* @__PURE__ */ new Set([
+    ...compactAliases,
+    ...options?.config ? collectConfigPlayAliases(options.config) : []
+  ]);
   const rows = dataExportRows(
     normalizeEnrichRowsForCsvExport(enrichedRows, options?.config, {
       statusFailureMessages: options?.statusFailureMessages
     }),
-    { preserveJsonStringColumns: compactAliases }
+    { preserveJsonStringColumns: preservedAliases }
   );
   const range = options?.rows;
   if (!options?.sourceCsvPath) {
@@ -21402,6 +21453,22 @@ function mergeRowsForCsvExport(enrichedRows, options) {
   }
   return { rows: merged, preferredColumns };
 }
+function collectConfigPlayAliases(config) {
+  const aliases = /* @__PURE__ */ new Set();
+  const visit = (commands) => {
+    for (const command of commands) {
+      if ("with_waterfall" in command) {
+        visit(command.commands);
+        continue;
+      }
+      if (!command.disabled && command.play) {
+        aliases.add(normalizeAlias2(command.alias));
+      }
+    }
+  };
+  visit(config.commands);
+  return aliases;
+}
 function collectConfigScalarAliasOrder(config) {
   const aliases = [];
   const seen = /* @__PURE__ */ new Set();
@@ -21557,6 +21624,9 @@ function materializeEnrichAliasCellForCsv(row, alias, options) {
     if (Object.prototype.hasOwnProperty.call(direct, "matched_result") || Object.prototype.hasOwnProperty.call(direct, "matchedResult") || Object.prototype.hasOwnProperty.call(direct, "result")) {
       return materializeCsvCellValue(direct);
     }
+    if (options?.preservePlainObject && !Object.prototype.hasOwnProperty.call(direct, "_metadata")) {
+      return materializeCsvCellValue(direct);
+    }
     const directCells = [];
     for (const [field, value] of Object.entries(direct)) {
       if (!isEnrichAliasPayloadField(field)) {
@@ -21613,6 +21683,7 @@ function materializeEnrichAliasCellForCsv(row, alias, options) {
 function normalizeEnrichRowsForCsvExport(rows, config, options) {
   const aliases = config ? collectConfigScalarAliasOrder(config) : [];
   const aiCompactAliases = config ? enrichAiRuntimeCompactAliases(config) : null;
+  const playAliases = config ? collectConfigPlayAliases(config) : /* @__PURE__ */ new Set();
   const failureOperationByAlias = hardFailureOperationByAlias(config);
   return rows.map((row) => {
     const metadata = legacyMetadataFromRow(row);
@@ -21656,7 +21727,8 @@ function normalizeEnrichRowsForCsvExport(rows, config, options) {
     }
     for (const alias of aliases) {
       const value = materializeEnrichAliasCellForCsv(normalized, alias, {
-        compactAiCell: aiCompactAliases?.has(normalizeAlias2(alias)) ?? false
+        compactAiCell: aiCompactAliases?.has(normalizeAlias2(alias)) ?? false,
+        preservePlainObject: playAliases.has(normalizeAlias2(alias))
       });
       if (value !== void 0) {
         normalized[alias] = value;
@@ -21844,6 +21916,9 @@ function registerEnrichCommand(program) {
   ).option(
     "--profile <id>",
     "Internal/testing: override the execution profile for the generated play run."
+  ).option(
+    "--debug-map-latency",
+    "Internal diagnostics: emit one aggregate latency profile per dataset map."
   ).option(
     "--fail-fast",
     "Fail the generated play when any selected row errors, while preserving recovered runtime-sheet rows for export."
@@ -21989,6 +22064,9 @@ function registerEnrichCommand(program) {
         if (options.profile) {
           runArgs.push("--profile", options.profile);
         }
+        if (options.debugMapLatency) {
+          runArgs.push("--debug-map-latency");
+        }
         if (options.noOpen || input2.suppressOpen) {
           runArgs.push("--no-open");
         }