deepline 0.1.69 → 0.1.71

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

@@ -22,7 +22,7 @@
  *     the runtime API endpoint, not direct DB. That keeps the Worker bundle
  *     compatible with the V8 isolate runtime.
  *
- * Status: experimental. First cut targets tool-basic (ctx.csv + ctx.map +
+ * Status: experimental. First cut targets tool-basic (ctx.csv + ctx.dataset +
  * ctx.tools.execute). Plays that depend on the full ctx surface (durable sleep,
  * checkpoints, batched waterfalls, etc.) will fall back to "not implemented"
  * rather than producing wrong results — opt-in via DEEPLINE_PLAY_RUNNER_BACKEND.
@@ -534,7 +534,7 @@ function getStaticSubstepNodeId(
   switch (substep.type) {
     case 'csv':
       return `csv:${substep.field || index}`;
-    case 'map':
+    case 'dataset':
       return `map:${substep.tableNamespace ?? substep.field}`;
     case 'tool':
       return `tool:${substep.field}:${substep.toolId}`;
@@ -2938,7 +2938,7 @@ function requireSheetContract(
   const contract = resolveSheetContractFromReq(req, tableNamespace);
   if (!contract) {
     throw new Error(
-      `ctx.map("${tableNamespace}"): no sheet contract resolvable from contractSnapshot. ` +
+      `ctx.dataset("${tableNamespace}"): no sheet contract resolvable from contractSnapshot. ` +
         'This usually means the dispatcher did not pass a contractSnapshot for this play, ' +
         'which is required for direct-Neon sheet IO from the Workers harness.',
     );
@@ -3000,7 +3000,7 @@ function augmentSheetContractWithDatasetFields(input: {
     columns.push({
       id: `runtime:${input.contract.tableNamespace}:${field}`,
       sqlName,
-      source: outputFields.has(field) ? 'mapField' : 'input',
+      source: outputFields.has(field) ? 'datasetColumn' : 'input',
       field,
     });
   }
@@ -3107,7 +3107,7 @@ async function prepareMapRows(input: {
  * Supported:
  *   - ctx.log(msg)
  *   - ctx.csv(filename | inline rows)  (calls runtime API for file resolve)
- *   - ctx.map(name, rows, fields, opts)
+ *   - ctx.dataset(name, rows).withColumn(name, resolver).run(opts)
  *   - ctx.tools.execute({ id, tool, input, ... })
  *   - ctx.runPlay(key, playRef, input, opts)
  *
@@ -3150,11 +3150,11 @@ function assertNotAborted(signal: AbortSignal | undefined): void {
   }
 }
 
-function childPipelineUsesCtxMap(
+function childPipelineUsesCtxDataset(
   pipeline: PlayStaticPipeline | null | undefined,
 ): boolean {
   return getCompiledPipelineSubsteps(pipeline).some(
-    (substep) => substep.type === 'map',
+    (substep) => substep.type === 'dataset',
   );
 }
 
@@ -3418,7 +3418,7 @@ function createMinimalWorkerCtx(
       const parts = Array.isArray(raw) ? raw : [raw];
       if (parts.some((part) => part === null || part === undefined)) {
         throw new Error(
-          `ctx.map("${name}") key returned null or undefined for row ${index}. ` +
+          `ctx.dataset("${name}") key returned null or undefined for row ${index}. ` +
             'Return a non-empty string or number derived from a stable input column.',
         );
       }
@@ -3430,7 +3430,7 @@ function createMinimalWorkerCtx(
       });
       if (normalizedParts.some((part) => !part)) {
         throw new Error(
-          `ctx.map("${name}") key returned an empty value for row ${index}. ` +
+          `ctx.dataset("${name}") key returned an empty value for row ${index}. ` +
             'Return a non-empty string or finite number derived from a stable input column.',
         );
       }
@@ -3462,7 +3462,7 @@ function createMinimalWorkerCtx(
         const previousIndex = explicitRowKeysSeen?.get(keyValue);
         if (previousIndex !== undefined) {
           throw new Error(
-            `ctx.map("${name}") key function produced duplicate value "${keyValue}" for rows ${previousIndex} and ${index}. ` +
+            `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.',
           );
         }
@@ -4016,7 +4016,7 @@ function createMinimalWorkerCtx(
     return dataset;
   };
 
-  class WorkerMapBuilder<T extends Record<string, unknown>> {
+  class WorkerDatasetBuilder<T extends Record<string, unknown>> {
     private readonly program: WorkerStepProgram = {
       kind: 'steps',
       steps: [],
@@ -4027,14 +4027,22 @@ function createMinimalWorkerCtx(
       private readonly rows: WorkerDatasetInput<T>,
     ) {}
 
-    step(name: string, resolver: WorkerStepProgramStep['resolver']): this {
+    withColumn(name: string, resolver: WorkerStepProgramStep['resolver']): this {
       if (!name.trim()) {
-        throw new Error('ctx.map(...).step(name, ...) requires a name.');
+        throw new Error(
+          'ctx.dataset(...).withColumn(name, ...) requires a name.',
+        );
       }
       this.program.steps = [...this.program.steps, { name, resolver }];
       return this;
     }
 
+    step(): never {
+      throw new Error(
+        'ctx.dataset(...).step(...) has been replaced by ctx.dataset(...).withColumn(...).',
+      );
+    }
+
     run(opts?: WorkerMapOptions): Promise<unknown> {
       const fields = Object.fromEntries(
         this.program.steps.map((step) => [step.name, step.resolver]),
@@ -4201,7 +4209,7 @@ function createMinimalWorkerCtx(
       });
       return dataset;
     },
-    map<T extends Record<string, unknown>>(
+    dataset<T extends Record<string, unknown>>(
       name: string,
       rows: WorkerDatasetInput<T>,
       fieldsDef?:
@@ -4219,7 +4227,7 @@ function createMinimalWorkerCtx(
       opts?: WorkerMapOptions,
     ): unknown {
       if (arguments.length <= 2 || fieldsDef === undefined) {
-        return new WorkerMapBuilder(name, rows);
+        return new WorkerDatasetBuilder(name, rows);
       }
       if (isWorkerStepProgram(fieldsDef)) {
         const fields = Object.fromEntries(
@@ -4228,7 +4236,12 @@ function createMinimalWorkerCtx(
         return runMap(name, rows, fields, opts);
       }
       throw new Error(
-        'ctx.map(key, rows, fields, options) was removed. Use ctx.map(key, rows).step(...).run(options).',
+        'ctx.dataset(key, rows, fields, options) is not supported. Use ctx.dataset(key, rows).withColumn(...).run(options).',
+      );
+    },
+    map(): never {
+      throw new Error(
+        'ctx.map(...) has been replaced by ctx.dataset(...). Use ctx.dataset(key, rows).withColumn(...).run(options).',
       );
     },
 	    tools: {
@@ -4356,7 +4369,7 @@ function createMinimalWorkerCtx(
             `ctx.runPlay(${normalizedKey}) cannot start ${resolvedName}: missing trusted Cloudflare child manifest from top-level submit.`,
           );
         }
-        const childIsMapBacked = childPipelineUsesCtxMap(
+        const childIsDatasetBacked = childPipelineUsesCtxDataset(
           childManifest.staticPipeline,
         );
         const childNeedsWorkflowScheduler = childPipelineNeedsWorkflowScheduler(
@@ -4364,13 +4377,13 @@ function createMinimalWorkerCtx(
         );
         let childConcurrencyAcquired = false;
         let releaseChildPlaySlot: (() => void) | null = null;
-        if (childIsMapBacked) {
+        if (childIsDatasetBacked) {
           const nextInFlight =
             (inFlightChildCallsByPlayName[resolvedName] ?? 0) + 1;
           if (nextInFlight > 1) {
             throw new Error(
-              `Concurrent map-backed play call blocked for ${resolvedName}. ` +
-                'A child play that uses ctx.map() cannot run more than once at the same time because its map tables share durable row identity. ' +
+              `Concurrent dataset-backed play call blocked for ${resolvedName}. ` +
+                'A child play that uses ctx.dataset() cannot run more than once at the same time because its dataset tables share durable row identity. ' +
                 'Run these child play calls sequentially, or give each concurrent branch a different child play/table contract.',
             );
           }
@@ -4980,7 +4993,7 @@ async function executeRunRequest(
     emit(event);
   };
 
-  stepLifecycle?.markPreMapStepsStarted(startedAt);
+  stepLifecycle?.markPreDatasetStepsStarted(startedAt);
   flushLedgerEvents(false);
   const ctx = createMinimalWorkerCtx(
     req,

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

@@ -868,6 +868,9 @@ export class DeeplineClient {
         ? { packagedFiles: request.packagedFiles }
         : {}),
       ...(request.force ? { force: true } : {}),
+      ...(typeof request.waitForCompletionMs === 'number'
+        ? { waitForCompletionMs: request.waitForCompletionMs }
+        : {}),
       ...(request.profile ? { profile: request.profile } : {}),
     };
     for await (const event of this.http.streamSse<PlayLiveEvent>(

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

@@ -95,6 +95,7 @@ export {
   definePlay,
   defineWorkflow,
   getDefinedPlayMetadata,
+  runIf,
   steps,
   when,
 } from './play.js';
@@ -135,14 +136,14 @@ export type {
   DeeplinePlayRuntimeContext,
   DefinedPlay,
   ColumnMap,
+  ColumnResolver,
   CsvInput,
+  DatasetBuilder,
   PlayBindings,
   FileInput,
   PlayInputContract,
   PlayJob,
   ConditionalStepResolver,
-  MapStepBuilder,
-  MapStepResolver,
   PlayDataset,
   PlayDatasetInput,
   PlayStepProgramStep,

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

@@ -254,37 +254,42 @@ export type PlayStepProgramStep = {
     | StepProgramResolver<Record<string, unknown>, unknown>;
 };
 
-export type MapStepResolver<Row, Value> =
+export type ColumnResolver<Row, Value> =
   | StepResolver<Row, Value>
   | ConditionalStepResolver<Row, Value>
   | StepProgramResolver<Row, Value>;
 
-export type MapStepBuilder<
+export type DatasetBuilder<
   InputRow extends object,
   OutputRow extends object,
 > = {
   /**
-   * Define one output column for every row in this map dataset.
+   * Define one output column for every row in this dataset.
    *
    * The `name` becomes a field on each output row. For example,
-   * `.step('contact', ...)` creates `row.contact` in later map stages; it does
+   * `.withColumn('contact', ...)` creates `row.contact` in later column resolvers; it does
    * not spread returned object fields such as `contact.email` into `row.email`.
    * Add a later column resolver when you want a top-level export field:
-   * `.step('email', row => row.contact?.email ?? null)`.
+   * `.withColumn('email', row => row.contact?.email ?? null)`.
    *
    * @param name - Output column name.
    * @param resolver - Computes the value for one row.
-   * @returns The same map builder with the new column type.
+   * @returns The same dataset builder with the new column type.
    */
+  withColumn<Name extends string, Value>(
+    name: Name,
+    resolver: ColumnResolver<OutputRow, Value>,
+  ): DatasetBuilder<InputRow, OutputRow & Record<Name, Value>>;
+  /** @deprecated Dataset `.step(...)` was replaced by `.withColumn(...)`. */
   step<Name extends string, Value>(
     name: Name,
-    resolver: MapStepResolver<OutputRow, Value>,
-  ): MapStepBuilder<InputRow, OutputRow & Record<Name, Value>>;
+    resolver: ColumnResolver<OutputRow, Value>,
+  ): never;
   /**
    * Execute the row-column program and return a durable dataset handle.
    *
    * The returned {@link PlayDataset} preserves one output row per input row,
-   * with original fields merged with the columns produced by `.step(...)`.
+   * with original fields merged with the columns produced by `.withColumn(...)`.
    *
    * @param options - Run options.
    * @returns Output rows as a dataset handle.
@@ -302,6 +307,7 @@ export type MapStepBuilder<
   }): Promise<PlayDataset<OutputRow>>;
 };
 
+
 export type CsvRenameMap = Record<string, string | readonly string[]>;
 
 /**
@@ -358,10 +364,10 @@ export type CsvOptions = {
  *     description: 'Look up company details by domain.',
  *   });
  *
- *   // Fan-out: process items with named steps
+ *   // Fan-out: process items with named columns
  *   const enriched = await ctx
- *     .map('companies', [{ domain: 'a.com' }, { domain: 'b.com' }])
- *     .step('company', (row, rowCtx) =>
+ *     .dataset('companies', [{ domain: 'a.com' }, { domain: 'b.com' }])
+ *     .withColumn('company', (row, rowCtx) =>
  *       rowCtx.tools.execute({
  *         id: 'company_search',
  *         tool: 'test_company_search',
@@ -391,7 +397,7 @@ export interface DeeplinePlayRuntimeContext {
    * Load a staged CSV file as a durable dataset handle.
    *
    * Use this when a play receives a CSV path from the CLI or API and row work
-   * should continue through {@link DeeplinePlayRuntimeContext.map}. The path is
+   * should continue through {@link DeeplinePlayRuntimeContext.dataset}. The path is
    * normally an input field such as `input.csv`, populated by
    * `deepline plays run my.play.ts --csv rows.csv`.
    *
@@ -403,7 +409,7 @@ export interface DeeplinePlayRuntimeContext {
    * @param path - Staged CSV path.
    * @param options - CSV load options.
    *
-   * @returns A {@link PlayDataset} whose rows should usually flow directly into `ctx.map(...)`.
+   * @returns A {@link PlayDataset} whose rows should usually flow directly into `ctx.dataset(...)`.
    */
   csv<T = Record<string, unknown>>(
     path: string,
@@ -413,9 +419,9 @@ export interface DeeplinePlayRuntimeContext {
   /**
    * Create a persisted row dataset/table from input rows.
    *
-   * `ctx.map` is Deepline's row-work primitive. It records row identity,
+   * `ctx.dataset` is Deepline's row-work primitive. It records row identity,
    * progress, retries, table output, and idempotency for a collection of rows.
-   * Use `.step(name, resolver)` on the returned builder to define output
+   * Use `.withColumn(name, resolver)` on the returned builder to define output
    * columns, then `.run(...)` to execute the row program.
    *
    * The `key` identifies the logical dataset/table. Renaming it is a persistence
@@ -423,10 +429,10 @@ export interface DeeplinePlayRuntimeContext {
    * automatically from input row content unless `.run({ key: ... })` overrides
    * it with stable business fields such as `domain`, `email`, or `linkedin_url`.
    *
-   * By default, `ctx.map` is row-preserving: one input row produces one output
+   * By default, `ctx.dataset` is row-preserving: one input row produces one output
    * row, with original fields merged with the columns produced by
-   * `.step(...)`. If one input entity must become many output rows, use the
-   * documented expand/flatten recipe instead of assuming `ctx.map` changes
+   * `.withColumn(...)`. If one input entity must become many output rows, use the
+   * documented expand/flatten recipe instead of assuming `ctx.dataset` changes
    * row cardinality.
    *
    * @typeParam T - Row type
@@ -437,8 +443,8 @@ export interface DeeplinePlayRuntimeContext {
    * @example Single tool per row
    * ```typescript
    * const results = await ctx
-   *   .map('companies', leads)
-   *   .step('company', (row, ctx) =>
+   *   .dataset('companies', leads)
+   *   .withColumn('company', (row, ctx) =>
    *     ctx.tools.execute({
    *       id: 'company_search',
    *       tool: 'test_company_search',
@@ -452,23 +458,30 @@ export interface DeeplinePlayRuntimeContext {
    * @example Multiple columns with pre/post logic
    * ```typescript
    * const results = await ctx
-   *   .map('leads', leads)
-   *   .step('company', (row, ctx) =>
+   *   .dataset('leads', leads)
+   *   .withColumn('company', (row, ctx) =>
    *     ctx.tools.execute({
    *       id: 'company_search',
    *       tool: 'test_company_search',
    *       input: { domain: row.domain },
    *       description: 'Look up company details by domain.',
    *     }))
-   *   .step('score', (row) =>
+   *   .withColumn('score', (row) =>
    *     row.company?.employeeCount > 100 ? 'enterprise' : 'smb')
    *   .run({ description: 'Enrich leads.' });
    * ```
    */
+  dataset<TItem extends object>(
+    key: string,
+    items: PlayDatasetInput<TItem>,
+  ): DatasetBuilder<TItem, TItem>;
+  /**
+   * @deprecated `ctx.map(...)` was replaced by `ctx.dataset(...)`.
+   */
   map<TItem extends object>(
     key: string,
     items: PlayDatasetInput<TItem>,
-  ): MapStepBuilder<TItem, TItem>;
+  ): never;
 
   /** Tool execution namespace. */
   tools: {
@@ -499,8 +512,8 @@ export interface DeeplinePlayRuntimeContext {
    *
    * `steps().step(...)` is a composable mini-pipeline. Use `ctx.runSteps(...)`
    * when that mini-pipeline should execute outside a row dataset. Inside a
-   * `ctx.map` column resolver, pass the step program directly to
-   * `.step(name, program)` instead.
+   * `ctx.dataset` column resolver, pass the step program directly to
+   * `.withColumn(name, program)` instead.
    *
    * @param program - Step program.
    * @param input - Program input.
@@ -521,7 +534,7 @@ export interface DeeplinePlayRuntimeContext {
    * value instead of running `run` again.
    *
    * Plain deterministic assignment does not need `ctx.step`. Use
-   * `ctx.map(...).step(...)`, not `ctx.step`, when the value should become a
+   * `ctx.dataset(...).withColumn(...)`, not `ctx.step`, when the value should become a
    * field on each exported row.
    *
    * @param id - Checkpoint id.
@@ -561,6 +574,22 @@ export interface DeeplinePlayRuntimeContext {
     bodyText: string;
     json: unknown | null;
   }>;
+  /**
+   * Invoke another registered or file-backed play as a child workflow.
+   *
+   * Use this for real composition boundaries, especially when a fitting
+   * scalar prebuilt play already encodes provider order, fallbacks,
+   * normalization, and no-result behavior. Do not invoke plays through
+   * `ctx.tools.execute`; tools and plays are separate namespaces.
+   *
+   * `key` is the stable child-call identity for idempotency and traceability.
+   *
+   * @param key - Stable child-call key.
+   * @param playRef - Registered play name, play handle, or file-backed play reference.
+   * @param input - Input object passed to the child play.
+   * @param options - Child play options.
+   * @returns Child play output.
+   */
   secrets: {
     get(name: string): SecretHandle;
     bearer(secret: SecretHandle): SecretAuth;
@@ -869,6 +898,17 @@ export function steps<TInput>(): StepProgram<TInput, TInput, TInput> {
 export function when<Row, Value>(
   predicate: (row: Row, index: number) => boolean | Promise<boolean>,
   resolver: StepResolver<Row, Value>,
+): never {
+  void predicate;
+  void resolver;
+  throw new Error(
+    'when(...) has been replaced by runIf(...). Use runIf(predicate, resolver).',
+  );
+}
+
+export function runIf<Row, Value>(
+  predicate: (row: Row, index: number) => boolean | Promise<boolean>,
+  resolver: StepResolver<Row, Value>,
 ): ConditionalStepResolver<Row, Value, null> {
   return new DeeplineConditionalStepResolver(predicate, resolver, null);
 }
@@ -1353,8 +1393,8 @@ export function defineInput<TInput>(
  *   const leads = await ctx.csv(input.csv);
  *   ctx.log(`Processing ${await leads.count()} rows`);
  *   const results = await ctx
- *     .map('companies', leads)
- *     .step('company', (row, ctx) =>
+ *     .dataset('companies', leads)
+ *     .withColumn('company', (row, ctx) =>
  *       ctx.tools.execute({
  *         id: 'company_search',
  *         tool: 'test_company_search',

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

@@ -50,10 +50,10 @@ export type SdkRelease = {
 };
 
 export const SDK_RELEASE = {
-  version: '0.1.69',
-  apiContract: '2026-05-play-bootstrap-dataset-summary',
+  version: '0.1.71',
+  apiContract: '2026-06-dataset-column-syntax-cutover',
   supportPolicy: {
-    latest: '0.1.69',
+    latest: '0.1.71',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
   },

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

@@ -718,7 +718,7 @@ export interface PlayDetail {
 }
 
 export interface ClearPlayHistoryRequest {
-  /** Optional explicit ctx.map keys to clear. Omit to clear all discovered sheets for the play. */
+  /** Optional explicit ctx.dataset keys to clear. Omit to clear all discovered sheets for the play. */
   tableNamespaces?: string[];
 }
 

package/dist/repo/sdk/src/worker-play-entry.ts

@@ -31,8 +31,8 @@ export type {
   ColumnMap,
   CsvInput,
   FileInput,
-  MapStepBuilder,
-  MapStepResolver,
+  ColumnResolver,
+  DatasetBuilder,
   PlayBindings,
   PlayDataset,
   PlayDatasetInput,
@@ -128,6 +128,17 @@ export function steps<TInput>(): StepProgram<TInput, TInput, TInput> {
 export function when<Row, Value>(
   predicate: (row: Row, index: number) => boolean | Promise<boolean>,
   resolver: StepResolver<Row, Value>,
+): never {
+  void predicate;
+  void resolver;
+  throw new Error(
+    'when(...) has been replaced by runIf(...). Use runIf(predicate, resolver).',
+  );
+}
+
+export function runIf<Row, Value>(
+  predicate: (row: Row, index: number) => boolean | Promise<boolean>,
+  resolver: StepResolver<Row, Value>,
 ): ConditionalStepResolver<Row, Value, null> {
   return new WorkerConditionalStepResolver(predicate, resolver, null);
 }

package/dist/repo/shared_libs/play-runtime/db-session-plan.ts

@@ -29,7 +29,7 @@ export function planRuntimeSheetDbSessionRequirements(
   }
   const byNamespace = new Map<string, PlaySheetContract>();
   for (const substep of flattenStaticPipeline(pipeline)) {
-    if (substep.type !== 'map') continue;
+    if (substep.type !== 'dataset') continue;
     const tableNamespace = (
       substep.tableNamespace ??
       substep.field ??

package/dist/repo/shared_libs/play-runtime/execution-plan.ts

@@ -200,8 +200,8 @@ function extractPlanMaps(
   );
   return substeps
     .filter(
-      (substep): substep is Extract<PlayStaticSubstep, { type: 'map' }> =>
-        substep.type === 'map',
+      (substep): substep is Extract<PlayStaticSubstep, { type: 'dataset' }> =>
+        substep.type === 'dataset',
     )
     .map((mapSubstep) => {
       const waterfalls = fallbackWaterfalls.filter((waterfall) => {

package/dist/repo/shared_libs/play-runtime/step-lifecycle-tracker.ts

@@ -32,7 +32,7 @@ export class PlayStepLifecycleTracker {
     private readonly now: () => number = Date.now,
   ) {}
 
-  markPreMapStepsStarted(at = this.now()): void {
+  markPreDatasetStepsStarted(at = this.now()): void {
     for (const node of this.nodes) {
       if (!isAutoStartedSetupNode(node.type)) break;
       if (!this.getProgress()[node.nodeId]?.startedAt) {
@@ -106,7 +106,7 @@ export class PlayStepLifecycleTracker {
     for (let index = 0; index < mapIndex; index += 1) {
       const node = this.nodes[index]!;
       if (
-        node.type !== 'map' &&
+        node.type !== 'dataset' &&
         this.getProgress()[node.nodeId]?.startedAt &&
         !this.getProgress()[node.nodeId]?.completedAt &&
         !this.failedNodeIds.has(node.nodeId)
@@ -143,7 +143,7 @@ export class PlayStepLifecycleTracker {
     }
     for (let index = mapIndex + 1; index < this.nodes.length; index += 1) {
       const node = this.nodes[index]!;
-      if (node.type === 'map') break;
+      if (node.type === 'dataset') break;
       if (
         isAutoStartedSetupNode(node.type) &&
         !this.getProgress()[node.nodeId]?.startedAt
@@ -210,7 +210,7 @@ export class PlayStepLifecycleTracker {
 
   private completeStartedNonMapNodes(at: number): void {
     for (const node of this.nodes) {
-      if (node.type === 'map') {
+      if (node.type === 'dataset') {
         continue;
       }
       const existing = this.getProgress()[node.nodeId];

package/dist/repo/shared_libs/plays/dataset.ts

@@ -61,13 +61,13 @@ export type PlayDatasetTransformOptions = {
 };
 
 /**
- * Durable handle for rows produced by `ctx.csv(...)` or `ctx.map(...).run()`.
+ * Durable handle for rows produced by `ctx.csv(...)` or `ctx.dataset(...).run()`.
  *
  * A `PlayDataset` is not a normal in-memory array. It points at runtime-managed
  * rows, usually backed by persisted sheet storage, and carries metadata such as
  * dataset kind, dataset id, table namespace, count, and preview rows.
  *
- * Pass dataset handles directly into later `ctx.map(...)` stages by default so
+ * Pass dataset handles directly into later `ctx.dataset(...)` stages by default so
  * Deepline keeps row progress, retries, memory use, and table output under
  * runtime control. Use `count()` and `peek()` for bounded inspection. Use
  * `materialize(limit)` or async iteration only when the dataset is intentionally

package/dist/repo/shared_libs/plays/row-identity.ts

@@ -187,7 +187,7 @@ export function normalizePlayNameForSheet(value: string): string {
 export function normalizeTableNamespace(value: string): string {
   return validateIdentifierPart(
     value,
-    'ctx.map() key',
+    'ctx.dataset() key',
     MAP_KEY_NAMESPACE_MAX_LENGTH,
   );
 }
@@ -208,7 +208,7 @@ export function resolveStaleMapTableNamespace(
     staleAfterSeconds <= 0
   ) {
     throw new Error(
-      'ctx.map() staleAfterSeconds must be a positive whole number of seconds.',
+      'ctx.dataset() staleAfterSeconds must be a positive whole number of seconds.',
     );
   }
 
@@ -242,7 +242,7 @@ export function validatePlaySheetTableName(
   if (resolved.length > POSTGRES_IDENTIFIER_MAX_LENGTH) {
     throw new Error(
       `Play sheet table name is too long after normalization (${resolved.length}/63). ` +
-        `Shorten the play name or ctx.map() key. ` +
+        `Shorten the play name or ctx.dataset() key. ` +
         `Resolved table name: "${resolved}".`,
     );
   }