deepline 0.1.73 → 0.1.74

package/README.md

@@ -242,12 +242,12 @@ deepline play run --file rate-limit-repro.play.ts --watch
 
 ### 4. Fallback variant (multi-step with rate limits)
 
-Use `steps()` and `runIf()` to express row-level fallback sequences. Skipped
-conditional steps yield `null`.
+Use `steps()` with `{ runIf }` options to express row-level fallback sequences.
+Skipped conditional steps yield `null`.
 
 ```bash
 cat > rate-limit-waterfall.play.ts << 'TS'
-import { definePlay, runIf, steps } from 'deepline';
+import { definePlay, steps } from 'deepline';
 
 export default definePlay('rate-limit-waterfall', async (ctx) => {
   const leads = Array.from({ length: 24 }, (_, i) => ({
@@ -267,8 +267,8 @@ export default definePlay('rate-limit-waterfall', async (ctx) => {
         },
         description: 'Exercise primary rate-limit behavior.',
       }))
-    .step("backup_probe", runIf(
-      (row) => !row.primary_probe,
+    .step(
+      "backup_probe",
       (row, ctx) =>
         ctx.tools.execute({
           id: 'rate_limit_probe_backup',
@@ -280,7 +280,8 @@ export default definePlay('rate-limit-waterfall', async (ctx) => {
           },
           description: 'Exercise fallback rate-limit behavior.',
         }),
-    ))
+      { runIf: (row) => !row.primary_probe },
+    )
     .return((row) => row.primary_probe ?? row.backup_probe ?? null);
 
   // Fan out over leads — each gets a row-level fallback sequence

package/dist/cli/index.js

@@ -229,10 +229,10 @@ var import_node_path2 = require("path");
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.73",
+  version: "0.1.74",
   apiContract: "2026-06-dataset-column-syntax-cutover",
   supportPolicy: {
-    latest: "0.1.73",
+    latest: "0.1.74",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -6885,9 +6885,6 @@ function playInspectionComments(playRef, indent) {
 function accessorExpression(base, field) {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(field) ? `${base}.${field}` : `${base}[${jsString(field)}]`;
 }
-function needsRunIfImport(options) {
-  return stageProviders(options.email).length > 1 || stageProviders(options.phone).length > 1;
-}
 function sourceCollectionTypeName(entity) {
   return entity === "company" ? "CompanySourceRow" : "ContactSourceRow";
 }
@@ -7238,10 +7235,10 @@ function generateFinderProviderStep(input2) {
       const priorCandidates = input2.stepNames.slice(0, input2.index).map((name) => `row.${name}`).join(", ");
       return `.withColumn(
       ${jsString(stepName)},
-      runIf(
-        (row) => ![${priorCandidates}].some((candidate) => ${optionalFinderValueExpression("candidate", input2.outputField)}),
-        ${input2.resolver},
-      ),
+      ${input2.resolver},
+      {
+        runIf: (row) => ![${priorCandidates}].some((candidate) => ${optionalFinderValueExpression("candidate", input2.outputField)}),
+      },
     )`;
     }
   }
@@ -7272,7 +7269,7 @@ function generateFinderProviderWaterfall(input2) {
   );
   const candidateNames = stepNames.map((name) => `row.${name}`).join(", ");
   return `// ${input2.aggregateStepName} provider waterfall. Each provider leg is active once its TODO throw is removed;
-    // delete or comment out legs you do not want before running. Later legs are gated with runIf(...).
+    // delete or comment out legs you do not want before running. Later legs are gated with { runIf }.
     ${providerSteps.join("\n    ")}
     .withColumn(${jsString(input2.aggregateStepName)}, (row) => {
       const candidates = [${candidateNames}];
@@ -7329,8 +7326,7 @@ function generateBootstrapPlaySource(input2) {
     rowTypeDefinitions,
     finderPlayResultTypes
   ].filter((definition) => definition.trim().length > 0).join("\n\n");
-  const importNames = needsRunIfImport(input2.options) ? "definePlay, runIf" : "definePlay";
-  return `import { ${importNames} } from 'deepline';
+  return `import { definePlay } from 'deepline';
 
 ${typeDefinitions}
 

package/dist/cli/index.mjs

@@ -206,10 +206,10 @@ import { join as join2 } from "path";
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.73",
+  version: "0.1.74",
   apiContract: "2026-06-dataset-column-syntax-cutover",
   supportPolicy: {
-    latest: "0.1.73",
+    latest: "0.1.74",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -6888,9 +6888,6 @@ function playInspectionComments(playRef, indent) {
 function accessorExpression(base, field) {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(field) ? `${base}.${field}` : `${base}[${jsString(field)}]`;
 }
-function needsRunIfImport(options) {
-  return stageProviders(options.email).length > 1 || stageProviders(options.phone).length > 1;
-}
 function sourceCollectionTypeName(entity) {
   return entity === "company" ? "CompanySourceRow" : "ContactSourceRow";
 }
@@ -7241,10 +7238,10 @@ function generateFinderProviderStep(input2) {
       const priorCandidates = input2.stepNames.slice(0, input2.index).map((name) => `row.${name}`).join(", ");
       return `.withColumn(
       ${jsString(stepName)},
-      runIf(
-        (row) => ![${priorCandidates}].some((candidate) => ${optionalFinderValueExpression("candidate", input2.outputField)}),
-        ${input2.resolver},
-      ),
+      ${input2.resolver},
+      {
+        runIf: (row) => ![${priorCandidates}].some((candidate) => ${optionalFinderValueExpression("candidate", input2.outputField)}),
+      },
     )`;
     }
   }
@@ -7275,7 +7272,7 @@ function generateFinderProviderWaterfall(input2) {
   );
   const candidateNames = stepNames.map((name) => `row.${name}`).join(", ");
   return `// ${input2.aggregateStepName} provider waterfall. Each provider leg is active once its TODO throw is removed;
-    // delete or comment out legs you do not want before running. Later legs are gated with runIf(...).
+    // delete or comment out legs you do not want before running. Later legs are gated with { runIf }.
     ${providerSteps.join("\n    ")}
     .withColumn(${jsString(input2.aggregateStepName)}, (row) => {
       const candidates = [${candidateNames}];
@@ -7332,8 +7329,7 @@ function generateBootstrapPlaySource(input2) {
     rowTypeDefinitions,
     finderPlayResultTypes
   ].filter((definition) => definition.trim().length > 0).join("\n\n");
-  const importNames = needsRunIfImport(input2.options) ? "definePlay, runIf" : "definePlay";
-  return `import { ${importNames} } from 'deepline';
+  return `import { definePlay } from 'deepline';
 
 ${typeDefinitions}
 

package/dist/index.d.mts

@@ -2143,12 +2143,16 @@ type ConditionalStepResolver<Row, Value, Else = null> = {
     readonly elseValue: Else;
     else<ValueElse>(value: ValueElse): ConditionalStepResolver<Row, Value, ValueElse>;
 };
+type StepOptions<Row> = {
+    readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>;
+};
 type StepProgram<Input, Output, Return = Output> = {
     readonly kind: 'steps';
     readonly steps: readonly PlayStepProgramStep[];
     readonly returnResolver?: StepResolver<Output, Return>;
     readonly __inputType?: (input: Input) => void;
     step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | ConditionalStepResolver<Output, Value> | StepProgramResolver<Output, Value>): StepProgram<Input, Output & Record<Name, Value>, Return>;
+    step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>, options: StepOptions<Output>): StepProgram<Input, Output & Record<Name, Value | null>, Return>;
     return<Value>(resolver: StepResolver<Output, Value>): StepProgram<Input, Output, Value>;
 };
 type StepProgramResolver<Input, Return> = {
@@ -2162,6 +2166,7 @@ type PlayStepProgramStep = {
     readonly resolver: StepResolver<Record<string, unknown>, unknown> | ConditionalStepResolver<Record<string, unknown>, unknown> | StepProgramResolver<Record<string, unknown>, unknown>;
 };
 type ColumnResolver<Row, Value> = StepResolver<Row, Value> | ConditionalStepResolver<Row, Value> | StepProgramResolver<Row, Value>;
+type StepProgramOutput<TProgram> = TProgram extends StepProgram<any, infer Output, any> ? Output : never;
 type DatasetBuilder<InputRow extends object, OutputRow extends object> = {
     /**
      * Define one output column for every row in this dataset.
@@ -2177,6 +2182,8 @@ type DatasetBuilder<InputRow extends object, OutputRow extends object> = {
      * @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>>;
+    withColumn<Name extends string, Value>(name: Name, resolver: StepResolver<OutputRow, Value> | StepProgramResolver<OutputRow, Value>, options: StepOptions<OutputRow>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;
+    withColumns<Program extends StepProgram<OutputRow, object, unknown>>(program: Program): DatasetBuilder<InputRow, StepProgramOutput<Program>>;
     /** @deprecated Dataset `.step(...)` was replaced by `.withColumn(...)`. */
     step<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): never;
     /**

package/dist/index.d.ts

@@ -2143,12 +2143,16 @@ type ConditionalStepResolver<Row, Value, Else = null> = {
     readonly elseValue: Else;
     else<ValueElse>(value: ValueElse): ConditionalStepResolver<Row, Value, ValueElse>;
 };
+type StepOptions<Row> = {
+    readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>;
+};
 type StepProgram<Input, Output, Return = Output> = {
     readonly kind: 'steps';
     readonly steps: readonly PlayStepProgramStep[];
     readonly returnResolver?: StepResolver<Output, Return>;
     readonly __inputType?: (input: Input) => void;
     step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | ConditionalStepResolver<Output, Value> | StepProgramResolver<Output, Value>): StepProgram<Input, Output & Record<Name, Value>, Return>;
+    step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>, options: StepOptions<Output>): StepProgram<Input, Output & Record<Name, Value | null>, Return>;
     return<Value>(resolver: StepResolver<Output, Value>): StepProgram<Input, Output, Value>;
 };
 type StepProgramResolver<Input, Return> = {
@@ -2162,6 +2166,7 @@ type PlayStepProgramStep = {
     readonly resolver: StepResolver<Record<string, unknown>, unknown> | ConditionalStepResolver<Record<string, unknown>, unknown> | StepProgramResolver<Record<string, unknown>, unknown>;
 };
 type ColumnResolver<Row, Value> = StepResolver<Row, Value> | ConditionalStepResolver<Row, Value> | StepProgramResolver<Row, Value>;
+type StepProgramOutput<TProgram> = TProgram extends StepProgram<any, infer Output, any> ? Output : never;
 type DatasetBuilder<InputRow extends object, OutputRow extends object> = {
     /**
      * Define one output column for every row in this dataset.
@@ -2177,6 +2182,8 @@ type DatasetBuilder<InputRow extends object, OutputRow extends object> = {
      * @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>>;
+    withColumn<Name extends string, Value>(name: Name, resolver: StepResolver<OutputRow, Value> | StepProgramResolver<OutputRow, Value>, options: StepOptions<OutputRow>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;
+    withColumns<Program extends StepProgram<OutputRow, object, unknown>>(program: Program): DatasetBuilder<InputRow, StepProgramOutput<Program>>;
     /** @deprecated Dataset `.step(...)` was replaced by `.withColumn(...)`. */
     step<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): never;
     /**

package/dist/index.js

@@ -241,10 +241,10 @@ var import_node_path2 = require("path");
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.73",
+  version: "0.1.74",
   apiContract: "2026-06-dataset-column-syntax-cutover",
   supportPolicy: {
-    latest: "0.1.73",
+    latest: "0.1.74",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -2410,18 +2410,23 @@ var DeeplineStepProgram = class _DeeplineStepProgram {
   steps;
   returnResolver;
   kind = "steps";
-  step(name, resolver) {
+  step(name, resolver, options) {
     if (!name.trim()) {
       throw new Error(
         "steps().step(name, ...) requires a non-empty step name."
       );
     }
+    const stepResolver = options?.runIf && !isConditionalStepResolver(resolver) ? new DeeplineConditionalStepResolver(
+      options.runIf,
+      resolver,
+      null
+    ) : resolver;
     return new _DeeplineStepProgram(
       [
         ...this.steps,
         {
           name,
-          resolver
+          resolver: stepResolver
         }
       ],
       this.returnResolver
@@ -2431,6 +2436,9 @@ var DeeplineStepProgram = class _DeeplineStepProgram {
     return new _DeeplineStepProgram(this.steps, resolver);
   }
 };
+function isConditionalStepResolver(value) {
+  return value !== null && typeof value === "object" && value.kind === "conditional";
+}
 function steps() {
   return new DeeplineStepProgram([]);
 }

package/dist/index.mjs

@@ -179,10 +179,10 @@ import { join as join2 } from "path";
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.73",
+  version: "0.1.74",
   apiContract: "2026-06-dataset-column-syntax-cutover",
   supportPolicy: {
-    latest: "0.1.73",
+    latest: "0.1.74",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -2348,18 +2348,23 @@ var DeeplineStepProgram = class _DeeplineStepProgram {
   steps;
   returnResolver;
   kind = "steps";
-  step(name, resolver) {
+  step(name, resolver, options) {
     if (!name.trim()) {
       throw new Error(
         "steps().step(name, ...) requires a non-empty step name."
       );
     }
+    const stepResolver = options?.runIf && !isConditionalStepResolver(resolver) ? new DeeplineConditionalStepResolver(
+      options.runIf,
+      resolver,
+      null
+    ) : resolver;
     return new _DeeplineStepProgram(
       [
         ...this.steps,
         {
           name,
-          resolver
+          resolver: stepResolver
         }
       ],
       this.returnResolver
@@ -2369,6 +2374,9 @@ var DeeplineStepProgram = class _DeeplineStepProgram {
     return new _DeeplineStepProgram(this.steps, resolver);
   }
 };
+function isConditionalStepResolver(value) {
+  return value !== null && typeof value === "object" && value.kind === "conditional";
+}
 function steps() {
   return new DeeplineStepProgram([]);
 }

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

@@ -151,6 +151,10 @@ import {
   isHardBillingToolHttpError,
   normalizeToolHttpErrorMessage,
 } from './runtime/tool-http-errors';
+import {
+  StepProgramDatasetBuilder,
+  type StepProgramDatasetOptions,
+} from '../../../shared_libs/play-runtime/step-program-dataset-builder';
 
 // The play's default export. The bundler injects this — see bundle-play-file.ts.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -4017,37 +4021,55 @@ function createMinimalWorkerCtx(
   };
 
   class WorkerDatasetBuilder<T extends Record<string, unknown>> {
-    private readonly program: WorkerStepProgram = {
-      kind: 'steps',
-      steps: [],
-    };
+    private readonly builder: StepProgramDatasetBuilder<
+      WorkerStepProgramStep,
+      WorkerStepProgramStep['resolver'],
+      WorkerMapOptions,
+      Promise<unknown>
+    >;
 
     constructor(
       private readonly name: string,
       private readonly rows: WorkerDatasetInput<T>,
-    ) {}
+    ) {
+      this.builder = new StepProgramDatasetBuilder(
+        (program, opts) => {
+          const fields = Object.fromEntries(
+            program.steps.map((step) => [step.name, step.resolver]),
+          );
+          return runMap(this.name, this.rows, fields, opts);
+        },
+        {
+          emptyColumnName:
+            'ctx.dataset(...).withColumn(name, ...) requires a name.',
+          invalidColumnsProgram:
+            'ctx.dataset(...).withColumns(...) requires a steps() program.',
+          legacyStep:
+            'ctx.dataset(...).step(...) has been replaced by ctx.dataset(...).withColumn(...).',
+        },
+      );
+    }
 
-    withColumn(name: string, resolver: WorkerStepProgramStep['resolver']): this {
-      if (!name.trim()) {
-        throw new Error(
-          'ctx.dataset(...).withColumn(name, ...) requires a name.',
-        );
-      }
-      this.program.steps = [...this.program.steps, { name, resolver }];
+    withColumn(
+      name: string,
+      resolver: WorkerStepProgramStep['resolver'],
+      options?: StepProgramDatasetOptions,
+    ): this {
+      this.builder.withColumn(name, resolver, options);
+      return this;
+    }
+
+    withColumns(program: WorkerStepProgram): this {
+      this.builder.withColumns(program);
       return this;
     }
 
     step(): never {
-      throw new Error(
-        'ctx.dataset(...).step(...) has been replaced by ctx.dataset(...).withColumn(...).',
-      );
+      return this.builder.step();
     }
 
     run(opts?: WorkerMapOptions): Promise<unknown> {
-      const fields = Object.fromEntries(
-        this.program.steps.map((step) => [step.name, step.resolver]),
-      );
-      return runMap(this.name, this.rows, fields, opts);
+      return this.builder.run(opts);
     }
   }
 

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

@@ -222,6 +222,10 @@ export type ConditionalStepResolver<Row, Value, Else = null> = {
   ): ConditionalStepResolver<Row, Value, ValueElse>;
 };
 
+export type StepOptions<Row> = {
+  readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>;
+};
+
 export type StepProgram<Input, Output, Return = Output> = {
   readonly kind: 'steps';
   readonly steps: readonly PlayStepProgramStep[];
@@ -234,6 +238,11 @@ export type StepProgram<Input, Output, Return = Output> = {
       | ConditionalStepResolver<Output, Value>
       | StepProgramResolver<Output, Value>,
   ): StepProgram<Input, Output & Record<Name, Value>, Return>;
+  step<Name extends string, Value>(
+    name: Name,
+    resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>,
+    options: StepOptions<Output>,
+  ): StepProgram<Input, Output & Record<Name, Value | null>, Return>;
   return<Value>(
     resolver: StepResolver<Output, Value>,
   ): StepProgram<Input, Output, Value>;
@@ -259,6 +268,9 @@ export type ColumnResolver<Row, Value> =
   | ConditionalStepResolver<Row, Value>
   | StepProgramResolver<Row, Value>;
 
+export type StepProgramOutput<TProgram> =
+  TProgram extends StepProgram<any, infer Output, any> ? Output : never;
+
 export type DatasetBuilder<
   InputRow extends object,
   OutputRow extends object,
@@ -280,6 +292,16 @@ export type DatasetBuilder<
     name: Name,
     resolver: ColumnResolver<OutputRow, Value>,
   ): DatasetBuilder<InputRow, OutputRow & Record<Name, Value>>;
+  withColumn<Name extends string, Value>(
+    name: Name,
+    resolver:
+      | StepResolver<OutputRow, Value>
+      | StepProgramResolver<OutputRow, Value>,
+    options: StepOptions<OutputRow>,
+  ): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;
+  withColumns<Program extends StepProgram<OutputRow, object, unknown>>(
+    program: Program,
+  ): DatasetBuilder<InputRow, StepProgramOutput<Program>>;
   /** @deprecated Dataset `.step(...)` was replaced by `.withColumn(...)`. */
   step<Name extends string, Value>(
     name: Name,
@@ -307,7 +329,6 @@ export type DatasetBuilder<
   }): Promise<PlayDataset<OutputRow>>;
 };
 
-
 export type CsvRenameMap = Record<string, string | readonly string[]>;
 
 /**
@@ -478,10 +499,7 @@ export interface DeeplinePlayRuntimeContext {
   /**
    * @deprecated `ctx.map(...)` was replaced by `ctx.dataset(...)`.
    */
-  map<TItem extends object>(
-    key: string,
-    items: PlayDatasetInput<TItem>,
-  ): never;
+  map<TItem extends object>(key: string, items: PlayDatasetInput<TItem>): never;
 
   /** Tool execution namespace. */
   tools: {
@@ -863,22 +881,43 @@ class DeeplineStepProgram<Input, Output, ReturnValue> implements StepProgram<
       | StepResolver<Output, Value>
       | ConditionalStepResolver<Output, Value>
       | StepProgramResolver<Output, Value>,
-  ): StepProgram<Input, Output & Record<Name, Value>, ReturnValue> {
+  ): StepProgram<Input, Output & Record<Name, Value>, ReturnValue>;
+  step<Name extends string, Value>(
+    name: Name,
+    resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>,
+    options: StepOptions<Output>,
+  ): StepProgram<Input, Output & Record<Name, Value | null>, ReturnValue>;
+  step<Name extends string, Value>(
+    name: Name,
+    resolver:
+      | StepResolver<Output, Value>
+      | ConditionalStepResolver<Output, Value>
+      | StepProgramResolver<Output, Value>,
+    options?: StepOptions<Output>,
+  ): StepProgram<Input, Output & Record<Name, Value | null>, ReturnValue> {
     if (!name.trim()) {
       throw new Error(
         'steps().step(name, ...) requires a non-empty step name.',
       );
     }
+    const stepResolver =
+      options?.runIf && !isConditionalStepResolver(resolver)
+        ? new DeeplineConditionalStepResolver(
+            options.runIf,
+            resolver as StepResolver<Output, Value>,
+            null,
+          )
+        : resolver;
     return new DeeplineStepProgram(
       [
         ...this.steps,
         {
           name,
-          resolver: resolver as PlayStepProgramStep['resolver'],
+          resolver: stepResolver as PlayStepProgramStep['resolver'],
         },
       ],
       this.returnResolver as StepResolver<
-        Output & Record<Name, Value>,
+        Output & Record<Name, Value | null>,
         ReturnValue
       >,
     );
@@ -891,6 +930,16 @@ class DeeplineStepProgram<Input, Output, ReturnValue> implements StepProgram<
   }
 }
 
+function isConditionalStepResolver(
+  value: unknown,
+): value is ConditionalStepResolver<unknown, unknown> {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    (value as { kind?: unknown }).kind === 'conditional'
+  );
+}
+
 export function steps<TInput>(): StepProgram<TInput, TInput, TInput> {
   return new DeeplineStepProgram<TInput, TInput, TInput>([]);
 }

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

@@ -50,10 +50,10 @@ export type SdkRelease = {
 };
 
 export const SDK_RELEASE = {
-  version: '0.1.73',
+  version: '0.1.74',
   apiContract: '2026-06-dataset-column-syntax-cutover',
   supportPolicy: {
-    latest: '0.1.73',
+    latest: '0.1.74',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
   },

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

@@ -19,6 +19,7 @@ import type {
   PlayStepProgramStep,
   StepProgram,
   StepProgramResolver,
+  StepOptions,
   StepResolver,
 } from './play.js';
 
@@ -43,6 +44,7 @@ export type {
   PrebuiltPlayRef,
   StepProgram,
   StepProgramResolver,
+  StepOptions,
   StepResolver,
   ToolExecuteResult,
 } from './play.js';
@@ -95,20 +97,41 @@ class WorkerStepProgram<Input, Output, ReturnValue> implements StepProgram<
       | StepResolver<Output, Value>
       | ConditionalStepResolver<Output, Value>
       | StepProgramResolver<Output, Value>,
-  ): StepProgram<Input, Output & Record<Name, Value>, ReturnValue> {
+  ): StepProgram<Input, Output & Record<Name, Value>, ReturnValue>;
+  step<Name extends string, Value>(
+    name: Name,
+    resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>,
+    options: StepOptions<Output>,
+  ): StepProgram<Input, Output & Record<Name, Value | null>, ReturnValue>;
+  step<Name extends string, Value>(
+    name: Name,
+    resolver:
+      | StepResolver<Output, Value>
+      | ConditionalStepResolver<Output, Value>
+      | StepProgramResolver<Output, Value>,
+    options?: StepOptions<Output>,
+  ): StepProgram<Input, Output & Record<Name, Value | null>, ReturnValue> {
     if (!name.trim()) {
       throw new Error('Step name required.');
     }
+    const stepResolver =
+      options?.runIf && !isConditionalStepResolver(resolver)
+        ? new WorkerConditionalStepResolver(
+            options.runIf,
+            resolver as StepResolver<Output, Value>,
+            null,
+          )
+        : resolver;
     return new WorkerStepProgram(
       [
         ...this.steps,
         {
           name,
-          resolver: resolver as PlayStepProgramStep['resolver'],
+          resolver: stepResolver as PlayStepProgramStep['resolver'],
         },
       ],
       this.returnResolver as StepResolver<
-        Output & Record<Name, Value>,
+        Output & Record<Name, Value | null>,
         ReturnValue
       >,
     );
@@ -121,6 +144,16 @@ class WorkerStepProgram<Input, Output, ReturnValue> implements StepProgram<
   }
 }
 
+function isConditionalStepResolver(
+  value: unknown,
+): value is ConditionalStepResolver<unknown, unknown> {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    (value as { kind?: unknown }).kind === 'conditional'
+  );
+}
+
 export function steps<TInput>(): StepProgram<TInput, TInput, TInput> {
   return new WorkerStepProgram<TInput, TInput, TInput>([]);
 }

package/dist/repo/shared_libs/play-runtime/step-program-dataset-builder.ts

@@ -0,0 +1,125 @@
+export type StepProgramDatasetOptions = {
+  runIf?: (
+    row: Record<string, unknown>,
+    index: number,
+  ) => boolean | Promise<boolean>;
+};
+
+export type StepProgramDatasetStep<TResolver> = {
+  name: string;
+  resolver: TResolver;
+};
+
+export type StepProgramDatasetProgram<TStep> = {
+  kind: 'steps';
+  steps: readonly TStep[];
+};
+
+export type StepProgramDatasetConditionalResolver<TResolver> = {
+  kind: 'conditional';
+  when: (
+    row: Record<string, unknown>,
+    index: number,
+  ) => boolean | Promise<boolean>;
+  run: TResolver;
+  elseValue?: unknown;
+};
+
+export function isStepProgramDatasetProgram<TStep>(
+  value: unknown,
+): value is StepProgramDatasetProgram<TStep> {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    (value as { kind?: unknown }).kind === 'steps' &&
+    Array.isArray((value as { steps?: unknown }).steps)
+  );
+}
+
+export function isStepProgramDatasetConditionalResolver<TResolver>(
+  value: unknown,
+): value is StepProgramDatasetConditionalResolver<TResolver> {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    (value as { kind?: unknown }).kind === 'conditional' &&
+    typeof (value as { when?: unknown }).when === 'function' &&
+    typeof (value as { run?: unknown }).run === 'function'
+  );
+}
+
+export class StepProgramDatasetBuilder<
+  TStep extends StepProgramDatasetStep<TResolver>,
+  TResolver,
+  TRunOptions,
+  TResult,
+> {
+  private readonly program: StepProgramDatasetProgram<TStep> = {
+    kind: 'steps',
+    steps: [],
+  };
+
+  constructor(
+    private readonly runProgram: (
+      program: StepProgramDatasetProgram<TStep>,
+      options?: TRunOptions,
+    ) => TResult,
+    private readonly messages: {
+      emptyColumnName: string;
+      invalidColumnsProgram: string;
+      legacyStep: string;
+    },
+  ) {}
+
+  withColumn(
+    name: string,
+    resolver: TResolver,
+    options?: StepProgramDatasetOptions,
+  ): this {
+    if (!name.trim()) {
+      throw new Error(this.messages.emptyColumnName);
+    }
+    this.program.steps = [
+      ...this.program.steps,
+      {
+        name,
+        resolver: this.applyDerivationOptions(resolver, options),
+      } as TStep,
+    ];
+    return this;
+  }
+
+  withColumns(program: StepProgramDatasetProgram<TStep>): this {
+    if (!isStepProgramDatasetProgram<TStep>(program)) {
+      throw new Error(this.messages.invalidColumnsProgram);
+    }
+    this.program.steps = [...this.program.steps, ...program.steps];
+    return this;
+  }
+
+  step(): never {
+    throw new Error(this.messages.legacyStep);
+  }
+
+  run(options?: TRunOptions): TResult {
+    return this.runProgram(this.program, options);
+  }
+
+  private applyDerivationOptions(
+    resolver: TResolver,
+    options?: StepProgramDatasetOptions,
+  ): TResolver {
+    if (
+      !options?.runIf ||
+      isStepProgramDatasetConditionalResolver<TResolver>(resolver)
+    ) {
+      return resolver;
+    }
+    return {
+      kind: 'conditional',
+      when: options.runIf,
+      run: resolver,
+      elseValue: null,
+    } as TResolver;
+  }
+}

package/package.json

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