runsheet 0.5.0 → 0.7.0

package/dist/index.js

@@ -1,6 +1,3 @@
-// src/define-step.ts
-import { composable } from "composable-functions";
-
 // src/errors.ts
 var RunsheetError = class extends Error {
   /** Discriminant code identifying the type of library error. */
@@ -69,12 +66,6 @@ var StrictOverlapError = class extends RunsheetError {
     this.steps = steps;
   }
 };
-var ChoiceNoMatchError = class extends RunsheetError {
-  constructor(message) {
-    super("CHOICE_NO_MATCH", message);
-    this.name = "ChoiceNoMatchError";
-  }
-};
 var UnknownError = class extends RunsheetError {
   /** The original thrown value before stringification. */
   originalValue;
@@ -85,24 +76,73 @@ var UnknownError = class extends RunsheetError {
   }
 };
 var RollbackError = class extends RunsheetError {
-  constructor(message) {
+  /** The individual errors from each failed rollback handler. */
+  causes;
+  constructor(message, causes = []) {
     super("ROLLBACK", message);
     this.name = "RollbackError";
+    this.causes = causes;
+    if (causes.length === 1) this.cause = causes[0];
+    else if (causes.length > 1) this.cause = new AggregateError(causes, message);
   }
 };
 
-// src/define-step.ts
-function withTimeout(run, stepName, ms) {
-  return async (ctx) => {
+// src/internal.ts
+function toError(err) {
+  if (err instanceof Error) return err;
+  return new UnknownError(String(err), err);
+}
+var EMPTY_ROLLBACK = Object.freeze({
+  completed: Object.freeze([]),
+  failed: Object.freeze([])
+});
+function formatIssues(issues) {
+  return issues.map((i) => i.path.length > 0 ? `${i.path.join(".")}: ${i.message}` : i.message).join(", ");
+}
+function collapseErrors(errors, message) {
+  return errors.length === 1 ? errors[0] : new AggregateError(errors, message);
+}
+function createStepObject(fields) {
+  return Object.freeze({
+    name: fields.name,
+    requires: fields.requires ?? void 0,
+    provides: fields.provides ?? void 0,
+    run: fields.run,
+    rollback: fields.rollback ?? void 0,
+    retry: fields.retry ?? void 0,
+    timeout: fields.timeout ?? void 0
+  });
+}
+function baseMeta(name, args) {
+  return Object.freeze({ name, args });
+}
+function aggregateMeta(name, args, stepsExecuted) {
+  return Object.freeze({ name, args, stepsExecuted });
+}
+function stepSuccess(data, meta) {
+  return Object.freeze({ success: true, data, meta });
+}
+function stepFailure(error, meta, failedStep, rollback = EMPTY_ROLLBACK) {
+  return Object.freeze({ success: false, error, meta, failedStep, rollback });
+}
+function aggregateSuccess(data, meta) {
+  return Object.freeze({ success: true, data, meta });
+}
+function aggregateFailure(error, meta, failedStep, rollback = EMPTY_ROLLBACK) {
+  return Object.freeze({ success: false, error, meta, failedStep, rollback });
+}
+
+// src/step.ts
+function withTimeout(fn, stepName, ms) {
+  return async () => {
     let timer;
-    const timeout = new Promise((resolve) => {
+    const timeout = new Promise((_, reject) => {
       timer = setTimeout(() => {
-        const error = new TimeoutError(`${stepName} timed out after ${ms}ms`, ms);
-        resolve({ success: false, errors: [error] });
+        reject(new TimeoutError(`${stepName} timed out after ${ms}ms`, ms));
       }, ms);
     });
     try {
-      return await Promise.race([run(ctx), timeout]);
+      return await Promise.race([Promise.resolve(fn()), timeout]);
     } finally {
       clearTimeout(timer);
     }
@@ -114,303 +154,306 @@ function computeDelay(policy, attempt) {
   const strategy = policy.backoff ?? "linear";
   return strategy === "exponential" ? base * 2 ** (attempt - 1) : base * attempt;
 }
-function withRetry(run, stepName, policy) {
-  return async (ctx) => {
-    let lastResult = await run(ctx);
-    if (lastResult.success) return lastResult;
+function withRetry(fn, stepName, policy) {
+  return async () => {
+    let lastError;
+    const errors = [];
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = toError(err);
+      errors.push(lastError);
+    }
     for (let attempt = 1; attempt <= policy.count; attempt++) {
-      if (policy.retryIf && !policy.retryIf(lastResult.errors)) return lastResult;
+      if (policy.retryIf && !policy.retryIf(errors)) throw lastError;
       const delay = computeDelay(policy, attempt);
-      if (delay > 0) await new Promise((r) => setTimeout(r, delay));
-      lastResult = await run(ctx);
-      if (lastResult.success) return lastResult;
+      if (delay > 0) await new Promise((r) => setTimeout(() => r(void 0), delay));
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = toError(err);
+        errors.push(lastError);
+      }
     }
     const error = new RetryExhaustedError(
       `${stepName} failed after ${policy.count} retries`,
       policy.count + 1
     );
-    return { success: false, errors: [...lastResult.errors, error] };
+    error.cause = errors.length === 1 ? errors[0] : new AggregateError(errors, error.message);
+    throw error;
   };
 }
-function wrapWithTimeoutAndRetry(run, stepName, timeout, retry) {
-  let wrapped = run;
-  if (timeout !== void 0) wrapped = withTimeout(wrapped, stepName, timeout);
-  if (retry !== void 0) wrapped = withRetry(wrapped, stepName, retry);
-  return wrapped;
+function buildExecutor(config) {
+  let fn = (ctx) => Promise.resolve(config.run(ctx));
+  if (config.timeout !== void 0) {
+    const baseFn = fn;
+    const ms = config.timeout;
+    fn = (ctx) => withTimeout(() => baseFn(ctx), config.name, ms)();
+  }
+  if (config.retry !== void 0) {
+    const baseFn = fn;
+    const policy = config.retry;
+    fn = (ctx) => withRetry(() => baseFn(ctx), config.name, policy)();
+  }
+  return fn;
 }
-function defineStep(config) {
-  const baseRun = composable(config.run);
-  const wrappedRun = wrapWithTimeoutAndRetry(baseRun, config.name, config.timeout, config.retry);
-  return Object.freeze({
+function step(config) {
+  const execute = buildExecutor(config);
+  const run = async (ctx) => {
+    const frozenCtx = Object.freeze({ ...ctx });
+    const meta = baseMeta(config.name, frozenCtx);
+    if (config.requires) {
+      const parsed = config.requires.safeParse(frozenCtx);
+      if (!parsed.success) {
+        const error = new RequiresValidationError(
+          `${config.name} requires: ${formatIssues(parsed.error.issues)}`
+        );
+        return stepFailure(error, meta, config.name);
+      }
+    }
+    let data;
+    try {
+      data = await execute(frozenCtx);
+    } catch (err) {
+      return stepFailure(toError(err), meta, config.name);
+    }
+    if (config.provides) {
+      const parsed = config.provides.safeParse(data);
+      if (!parsed.success) {
+        const error = new ProvidesValidationError(
+          `${config.name} provides: ${formatIssues(parsed.error.issues)}`
+        );
+        return stepFailure(error, meta, config.name);
+      }
+    }
+    return stepSuccess(data, meta);
+  };
+  return createStepObject({
     name: config.name,
-    requires: config.requires ?? void 0,
-    provides: config.provides ?? void 0,
-    run: wrappedRun,
+    requires: config.requires,
+    provides: config.provides,
+    run,
     rollback: config.rollback ? async (ctx, output) => {
       await config.rollback(ctx, output);
     } : void 0,
-    retry: config.retry ?? void 0,
-    timeout: config.timeout ?? void 0
+    retry: config.retry,
+    timeout: config.timeout
   });
 }
 
-// src/middleware.ts
-function applyMiddleware(middlewares, step, executor) {
-  return middlewares.reduceRight((next, mw) => mw(step, next), executor);
-}
-
-// src/when.ts
-function when(predicate, step) {
+// src/builder.ts
+function makeBuilder(state) {
   return Object.freeze({
-    ...step,
-    predicate
+    step: (step2) => makeBuilder({
+      ...state,
+      steps: [...state.steps, step2]
+    }),
+    use: (...middleware) => makeBuilder({
+      ...state,
+      middleware: [...state.middleware, ...middleware]
+    }),
+    build: () => buildPipelineStep({
+      name: state.name,
+      steps: state.steps,
+      middleware: state.middleware.length > 0 ? state.middleware : void 0,
+      argsSchema: state.argsSchema,
+      strict: state.strict ? true : void 0
+    })
   });
 }
-function isConditionalStep(step) {
-  return "predicate" in step && typeof step.predicate === "function";
-}
 
-// src/internal.ts
-function toError(err) {
-  if (err instanceof Error) return err;
-  return new UnknownError(String(err), err);
+// src/middleware.ts
+function applyMiddleware(middlewares, step2, executor) {
+  return middlewares.reduceRight((next, mw) => mw(step2, next), executor);
 }
-function validateInnerSchema(schema, data, label, ErrorClass) {
-  if (!schema) return null;
-  const parsed = schema.safeParse(data);
-  if (parsed.success) return null;
-  return parsed.error.issues.map(
-    (issue) => new ErrorClass(`${label}: ${issue.path.join(".")}: ${issue.message}`)
-  );
+
+// src/when.ts
+function when(predicate, step2) {
+  const name = step2.name;
+  const innerStep = step2;
+  const run = async (ctx) => {
+    const frozenCtx = Object.freeze({ ...ctx });
+    let shouldRun;
+    try {
+      shouldRun = predicate(frozenCtx);
+    } catch (err) {
+      const cause = toError(err);
+      const error = new PredicateError(`${name} predicate: ${cause.message}`);
+      error.cause = cause;
+      return aggregateFailure(error, aggregateMeta(name, frozenCtx, []), name);
+    }
+    if (!shouldRun) {
+      return aggregateSuccess({}, aggregateMeta(name, frozenCtx, []));
+    }
+    const result = await innerStep.run(frozenCtx);
+    if (!result.success) {
+      return aggregateFailure(result.error, aggregateMeta(name, frozenCtx, [name]), name);
+    }
+    return aggregateSuccess(result.data, aggregateMeta(name, frozenCtx, [name]));
+  };
+  return createStepObject({
+    name,
+    run,
+    rollback: innerStep.rollback,
+    requires: innerStep.requires,
+    provides: innerStep.provides
+  });
 }
-async function runInnerStep(step, ctx) {
-  const requiresErrors = validateInnerSchema(
-    step.requires,
-    ctx,
-    `${step.name} requires`,
-    RequiresValidationError
-  );
-  if (requiresErrors) return { success: false, errors: requiresErrors };
-  const result = await step.run(ctx);
-  if (!result.success) return result;
-  const providesErrors = validateInnerSchema(
-    step.provides,
-    result.data,
-    `${step.name} provides`,
-    ProvidesValidationError
-  );
-  if (providesErrors) return { success: false, errors: providesErrors };
-  return result;
+function wasSkipped(meta) {
+  return "stepsExecuted" in meta && meta.stepsExecuted.length === 0;
 }
 
 // src/pipeline.ts
 function checkStrictOverlap(steps) {
   const seen = /* @__PURE__ */ new Map();
-  for (const step of steps) {
-    if (!step.provides) continue;
-    const shape = step.provides.shape;
+  for (const step2 of steps) {
+    if (!step2.provides) continue;
+    const shape = step2.provides.shape;
     if (!shape || typeof shape !== "object") continue;
     for (const key of Object.keys(shape)) {
       const existing = seen.get(key);
       if (existing) {
         throw new StrictOverlapError(
-          `strict mode: key "${key}" is provided by both "${existing}" and "${step.name}"`,
+          `strict mode: key "${key}" is provided by both "${existing}" and "${step2.name}"`,
           key,
-          [existing, step.name]
+          [existing, step2.name]
         );
       }
-      seen.set(key, step.name);
+      seen.set(key, step2.name);
     }
   }
 }
-function validateSchema(schema, data, label, ErrorClass) {
-  if (!schema) return { success: true, data };
-  const parsed = schema.safeParse(data);
-  if (parsed.success) return { success: true, data: parsed.data };
-  const errors = parsed.error.issues.map(
-    (issue) => new ErrorClass(`${label}: ${issue.path.join(".")}: ${issue.message}`)
-  );
-  return { success: false, errors };
+function createExecutionState(args) {
+  return {
+    context: Object.freeze({ ...args }),
+    executed: [],
+    stepsExecuted: []
+  };
 }
-async function executeRollback(executedSteps, snapshots, outputs) {
+async function executeRollback(executed) {
   const completed = [];
   const failed = [];
-  for (let i = executedSteps.length - 1; i >= 0; i--) {
-    const step = executedSteps[i];
-    if (!step.rollback) continue;
+  for (let i = executed.length - 1; i >= 0; i--) {
+    const entry = executed[i];
+    if (!entry.step.rollback) continue;
     try {
-      await step.rollback(snapshots[i], outputs[i]);
-      completed.push(step.name);
+      await entry.step.rollback(entry.snapshot, entry.output);
+      completed.push(entry.step.name);
     } catch (err) {
-      failed.push({
-        step: step.name,
-        error: toError(err)
-      });
+      failed.push({ step: entry.step.name, error: toError(err) });
     }
   }
   return Object.freeze({ completed, failed });
 }
-function createExecutionState(args) {
-  return {
-    context: Object.freeze({ ...args }),
-    snapshots: [],
-    outputs: [],
-    executedSteps: [],
-    stepsExecuted: [],
-    stepsSkipped: []
-  };
-}
-function pipelineFailure(pipelineName, args, state, failedStep, errors, rollback) {
-  return Object.freeze({
-    success: false,
-    errors,
-    meta: Object.freeze({
-      pipeline: pipelineName,
-      args,
-      stepsExecuted: state.stepsExecuted,
-      stepsSkipped: state.stepsSkipped
-    }),
-    failedStep,
-    rollback
-  });
-}
-function pipelineSuccess(pipelineName, args, state) {
-  return Object.freeze({
-    success: true,
-    data: state.context,
-    errors: [],
-    meta: Object.freeze({
-      pipeline: pipelineName,
-      args,
-      stepsExecuted: state.stepsExecuted,
-      stepsSkipped: state.stepsSkipped
-    })
-  });
-}
-function createStepExecutor(step) {
-  return async (ctx) => {
-    const requiresCheck = validateSchema(
-      step.requires,
-      ctx,
-      `${step.name} requires`,
-      RequiresValidationError
-    );
-    if (!requiresCheck.success) {
-      return { success: false, errors: requiresCheck.errors };
-    }
-    const result = await step.run(ctx);
-    if (!result.success) return result;
-    const providesCheck = validateSchema(
-      step.provides,
-      result.data,
-      `${step.name} provides`,
-      ProvidesValidationError
-    );
-    if (!providesCheck.success) {
-      return { success: false, errors: providesCheck.errors };
-    }
-    return {
-      success: true,
-      data: providesCheck.data,
-      errors: []
-    };
-  };
-}
 async function executePipeline(config, args) {
+  const frozenArgs = Object.freeze({ ...args });
   if (config.argsSchema) {
-    const argsCheck = validateSchema(
-      config.argsSchema,
-      args,
-      `${config.name} args`,
-      ArgsValidationError
-    );
-    if (!argsCheck.success) {
-      const state2 = createExecutionState(args);
-      return pipelineFailure(
-        config.name,
-        args,
-        state2,
-        config.name,
-        argsCheck.errors,
-        Object.freeze({ completed: [], failed: [] })
+    const parsed = config.argsSchema.safeParse(frozenArgs);
+    if (!parsed.success) {
+      const error = new ArgsValidationError(
+        `${config.name} args: ${formatIssues(parsed.error.issues)}`
       );
+      const meta2 = aggregateMeta(config.name, frozenArgs, []);
+      const state2 = createExecutionState(frozenArgs);
+      return { result: aggregateFailure(error, meta2, config.name), state: state2 };
     }
   }
-  const state = createExecutionState(args);
+  const state = createExecutionState(frozenArgs);
   const middlewares = config.middleware ?? [];
-  for (const step of config.steps) {
-    try {
-      if (isConditionalStep(step) && !step.predicate(state.context)) {
-        state.stepsSkipped.push(step.name);
-        continue;
-      }
-    } catch (err) {
-      const cause = toError(err);
-      const error = new PredicateError(`${step.name} predicate: ${cause.message}`);
-      error.cause = cause;
-      const rollback = await executeRollback(state.executedSteps, state.snapshots, state.outputs);
-      return pipelineFailure(config.name, args, state, step.name, [error], rollback);
-    }
-    state.snapshots.push(state.context);
-    const baseExecutor = createStepExecutor(step);
-    const executor = applyMiddleware(
+  for (const step2 of config.steps) {
+    const snapshot = state.context;
+    const executor = middlewares.length > 0 ? applyMiddleware(
       middlewares,
-      { name: step.name, requires: step.requires, provides: step.provides },
-      baseExecutor
-    );
+      { name: step2.name, requires: step2.requires, provides: step2.provides },
+      (ctx) => step2.run(ctx)
+    ) : (ctx) => step2.run(ctx);
     let result;
     try {
       result = await executor(state.context);
     } catch (err) {
       const error = toError(err);
-      state.snapshots.pop();
-      const rollback = await executeRollback(state.executedSteps, state.snapshots, state.outputs);
-      return pipelineFailure(config.name, args, state, step.name, [error], rollback);
+      const rollback = await executeRollback(state.executed);
+      const meta2 = aggregateMeta(config.name, frozenArgs, [...state.stepsExecuted]);
+      return { result: aggregateFailure(error, meta2, step2.name, rollback), state };
     }
     if (!result.success) {
-      state.snapshots.pop();
-      const rollback = await executeRollback(state.executedSteps, state.snapshots, state.outputs);
-      return pipelineFailure(config.name, args, state, step.name, result.errors, rollback);
+      const rollback = await executeRollback(state.executed);
+      const meta2 = aggregateMeta(config.name, frozenArgs, [...state.stepsExecuted]);
+      return { result: aggregateFailure(result.error, meta2, step2.name, rollback), state };
     }
+    if (wasSkipped(result.meta)) continue;
     const output = result.data;
-    state.outputs.push(output);
-    state.executedSteps.push(step);
-    state.stepsExecuted.push(step.name);
+    state.executed.push({ step: step2, snapshot, output });
+    state.stepsExecuted.push(step2.name);
     state.context = Object.freeze({ ...state.context, ...output });
   }
-  return pipelineSuccess(config.name, args, state);
+  const meta = aggregateMeta(config.name, frozenArgs, [...state.stepsExecuted]);
+  return { result: aggregateSuccess(state.context, meta), state };
 }
-function buildPipeline(config) {
+function buildPipelineStep(config) {
   if (config.strict) checkStrictOverlap(config.steps);
-  return Object.freeze({
+  const pipelineConfig = config;
+  const stateMap = /* @__PURE__ */ new WeakMap();
+  const run = async (ctx) => {
+    const outcome = await executePipeline(pipelineConfig, ctx);
+    if (outcome.result.success) {
+      stateMap.set(outcome.result.data, outcome.state);
+    }
+    return outcome.result;
+  };
+  const rollback = async (_ctx, output) => {
+    const state = stateMap.get(output);
+    if (!state) return;
+    stateMap.delete(output);
+    const report = await executeRollback(state.executed);
+    if (report.failed.length > 0) {
+      throw new RollbackError(
+        `${config.name}: ${report.failed.length} rollback(s) failed`,
+        report.failed.map((f) => f.error)
+      );
+    }
+  };
+  return createStepObject({
     name: config.name,
-    run: (args) => executePipeline(config, args)
+    requires: config.argsSchema,
+    run,
+    rollback
+  });
+}
+function pipeline(config) {
+  if (config.steps) {
+    return buildPipelineStep(
+      config
+    );
+  }
+  return makeBuilder({
+    name: config.name,
+    steps: [],
+    middleware: config.middleware ? [...config.middleware] : [],
+    argsSchema: config.argsSchema,
+    strict: config.strict ?? false
   });
 }
 
 // src/parallel.ts
-async function executeInner(step, ctx) {
-  try {
-    if (isConditionalStep(step) && !step.predicate(ctx)) {
-      return { step, skipped: true };
-    }
-  } catch (err) {
-    const cause = toError(err);
-    const error = new PredicateError(`${step.name} predicate: ${cause.message}`);
-    error.cause = cause;
-    return { step, skipped: false, errors: [error] };
-  }
-  const result = await runInnerStep(step, ctx);
-  if (!result.success) return { step, skipped: false, errors: [...result.errors] };
-  return { step, skipped: false, output: result.data };
+async function executeInner(step2, ctx) {
+  const result = await step2.run(ctx);
+  if (!result.success) return { step: step2, skipped: false, error: result.error };
+  if (wasSkipped(result.meta)) return { step: step2, skipped: true };
+  return { step: step2, skipped: false, output: result.data };
 }
 function parallel(...steps) {
   const name = `parallel(${steps.map((s) => s.name).join(", ")})`;
   const innerSteps = steps;
+  const executedMap = /* @__PURE__ */ new WeakMap();
   const run = async (ctx) => {
-    const settled = await Promise.allSettled(innerSteps.map((step) => executeInner(step, ctx)));
+    const frozenCtx = Object.freeze({ ...ctx });
+    const settled = await Promise.allSettled(
+      innerSteps.map((step2) => executeInner(step2, frozenCtx))
+    );
     const succeeded = [];
     const allErrors = [];
+    const executed = [];
     for (const s of settled) {
       if (s.status === "rejected") {
         allErrors.push(toError(s.reason));
@@ -419,54 +462,67 @@ function parallel(...steps) {
         if (r.skipped) continue;
         if (r.output) {
           succeeded.push({ step: r.step, output: r.output });
-        } else if (r.errors) {
-          allErrors.push(...r.errors);
+          executed.push(r.step.name);
+        } else if (r.error) {
+          allErrors.push(r.error);
         }
       }
     }
     if (allErrors.length > 0) {
+      const rollbackErrors = [];
       for (let i = succeeded.length - 1; i >= 0; i--) {
-        const { step, output } = succeeded[i];
-        if (step.rollback) {
+        const { step: step2, output } = succeeded[i];
+        if (step2.rollback) {
           try {
-            await step.rollback(ctx, output);
-          } catch {
+            await step2.rollback(frozenCtx, output);
+          } catch (err) {
+            rollbackErrors.push(toError(err));
           }
         }
       }
-      return { success: false, errors: allErrors };
+      const error = collapseErrors(allErrors, `${name}: ${allErrors.length} step(s) failed`);
+      if (rollbackErrors.length > 0) {
+        error.cause = new RollbackError(
+          `${name}: ${rollbackErrors.length} partial-failure rollback(s) failed`,
+          rollbackErrors
+        );
+      }
+      const meta2 = aggregateMeta(name, frozenCtx, executed);
+      return aggregateFailure(error, meta2, name);
     }
     const merged = {};
     for (const { output } of succeeded) {
       Object.assign(merged, output);
     }
-    return { success: true, data: merged, errors: [] };
+    executedMap.set(
+      merged,
+      succeeded.map((s) => ({ step: s.step, output: s.output }))
+    );
+    const meta = aggregateMeta(name, frozenCtx, executed);
+    return aggregateSuccess(merged, meta);
   };
   const rollback = async (ctx, mergedOutput) => {
+    const entries = executedMap.get(mergedOutput);
+    if (!entries) return;
+    executedMap.delete(mergedOutput);
     const errors = [];
-    for (let i = innerSteps.length - 1; i >= 0; i--) {
-      const step = innerSteps[i];
-      if (!step.rollback) continue;
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const { step: step2, output } = entries[i];
+      if (!step2.rollback) continue;
       try {
-        await step.rollback(ctx, mergedOutput);
+        await step2.rollback(ctx, output);
       } catch (err) {
         errors.push(toError(err));
       }
     }
     if (errors.length > 0) {
-      const error = new RollbackError(`${name}: ${errors.length} rollback(s) failed`);
-      error.cause = errors;
-      throw error;
+      throw new RollbackError(`${name}: ${errors.length} rollback(s) failed`, errors);
     }
   };
-  return Object.freeze({
+  return createStepObject({
     name,
-    requires: void 0,
-    provides: void 0,
     run,
-    rollback,
-    retry: void 0,
-    timeout: void 0
+    rollback
   });
 }
 
@@ -479,309 +535,158 @@ function normalizeBranches(args) {
 }
 function choice(...args) {
   const innerBranches = normalizeBranches(args);
-  const name = `choice(${innerBranches.map(([, step]) => step.name).join(", ")})`;
+  const name = `choice(${innerBranches.map(([, step2]) => step2.name).join(", ")})`;
   const branchMap = /* @__PURE__ */ new WeakMap();
   const run = async (ctx) => {
+    const frozenCtx = Object.freeze({ ...ctx });
     for (let i = 0; i < innerBranches.length; i++) {
-      const [predicate, step] = innerBranches[i];
+      const [predicate, step2] = innerBranches[i];
       let matches;
       try {
-        matches = predicate(ctx);
+        matches = predicate(frozenCtx);
       } catch (err) {
         const cause = toError(err);
         const error = new PredicateError(`${name} predicate: ${cause.message}`);
         error.cause = cause;
-        return { success: false, errors: [error] };
+        const meta3 = aggregateMeta(name, frozenCtx, []);
+        return aggregateFailure(error, meta3, name);
       }
       if (!matches) continue;
-      const result = await runInnerStep(step, ctx);
-      if (!result.success) return result;
+      const result = await step2.run(frozenCtx);
+      if (!result.success) {
+        const meta3 = aggregateMeta(name, frozenCtx, [step2.name]);
+        return aggregateFailure(result.error, meta3, name);
+      }
       branchMap.set(result.data, i);
-      return { success: true, data: result.data, errors: [] };
+      const meta2 = aggregateMeta(name, frozenCtx, [step2.name]);
+      return aggregateSuccess(result.data, meta2);
     }
-    return {
-      success: false,
-      errors: [new ChoiceNoMatchError(`${name}: no branch matched`)]
-    };
+    const meta = aggregateMeta(name, frozenCtx, []);
+    return aggregateSuccess({}, meta);
   };
   const rollback = async (ctx, output) => {
     const branchIndex = branchMap.get(output);
     if (branchIndex === void 0) return;
-    const [, step] = innerBranches[branchIndex];
-    if (step.rollback) {
+    branchMap.delete(output);
+    const [, step2] = innerBranches[branchIndex];
+    if (step2.rollback) {
       try {
-        await step.rollback(ctx, output);
+        await step2.rollback(ctx, output);
       } catch (err) {
-        const error = new RollbackError(`${name}: 1 rollback(s) failed`);
-        error.cause = [toError(err)];
-        throw error;
+        throw new RollbackError(`${name}: 1 rollback(s) failed`, [toError(err)]);
       }
     }
   };
-  return Object.freeze({
+  return createStepObject({
     name,
-    requires: void 0,
-    provides: void 0,
     run,
-    rollback,
-    retry: void 0,
-    timeout: void 0
+    rollback
   });
 }
 
-// src/map.ts
-function isStep(x) {
-  return typeof x === "object" && x !== null && "run" in x && "name" in x;
+// src/distribute.ts
+function crossProduct(mapping, ctx) {
+  const entries = Object.entries(mapping);
+  let combinations = [{}];
+  for (const [contextKey, stepKey] of entries) {
+    const items = ctx[contextKey];
+    if (!Array.isArray(items) || items.length === 0) return [];
+    const next = [];
+    for (const combo of combinations) {
+      for (const item of items) {
+        next.push({ ...combo, [stepKey]: item });
+      }
+    }
+    combinations = next;
+  }
+  return combinations;
 }
-function map(key, collection, fnOrStep) {
-  const stepMode = isStep(fnOrStep);
-  const name = stepMode ? `map(${key}, ${fnOrStep.name})` : `map(${key})`;
+function distribute(key, mapping, step2) {
+  const stepName = `distribute(${key}, ${step2.name})`;
+  const arrayKeys = new Set(Object.keys(mapping));
   const executionMap = /* @__PURE__ */ new WeakMap();
   const run = async (ctx) => {
-    let items;
-    try {
-      items = collection(ctx);
-    } catch (err) {
-      return {
-        success: false,
-        errors: [toError(err)]
-      };
+    const frozenCtx = Object.freeze({ ...ctx });
+    const meta = baseMeta(stepName, frozenCtx);
+    const combinations = crossProduct(mapping, frozenCtx);
+    const baseCtx = {};
+    for (const k of Object.keys(frozenCtx)) {
+      if (!arrayKeys.has(k)) baseCtx[k] = frozenCtx[k];
     }
-    if (stepMode) {
-      return runStepMode(fnOrStep, items, ctx, name, key, executionMap);
-    } else {
-      return runFunctionMode(
-        fnOrStep,
-        items,
-        ctx,
-        key
-      );
+    const settled = await Promise.allSettled(
+      combinations.map(async (combo) => {
+        const itemCtx = Object.freeze({ ...baseCtx, ...combo });
+        return step2.run(itemCtx);
+      })
+    );
+    const succeeded = [];
+    const allErrors = [];
+    for (let i = 0; i < settled.length; i++) {
+      const s = settled[i];
+      if (s.status === "rejected") {
+        allErrors.push(toError(s.reason));
+      } else if (!s.value.success) {
+        allErrors.push(s.value.error);
+      } else {
+        succeeded.push({ index: i, output: s.value.data });
+      }
+    }
+    if (allErrors.length > 0) {
+      const rollbackErrors = [];
+      if (step2.rollback) {
+        for (let i = succeeded.length - 1; i >= 0; i--) {
+          try {
+            const combo = combinations[succeeded[i].index];
+            const itemCtx = Object.freeze({ ...baseCtx, ...combo });
+            await step2.rollback(itemCtx, succeeded[i].output);
+          } catch (err) {
+            rollbackErrors.push(toError(err));
+          }
+        }
+      }
+      const error = collapseErrors(allErrors, `${stepName}: ${allErrors.length} item(s) failed`);
+      if (rollbackErrors.length > 0) {
+        error.cause = new RollbackError(
+          `${stepName}: ${rollbackErrors.length} partial-failure rollback(s) failed`,
+          rollbackErrors
+        );
+      }
+      return stepFailure(error, meta, stepName);
     }
+    const results = succeeded.map((s) => s.output);
+    const data = { [key]: results };
+    executionMap.set(data, { combinations, baseCtx });
+    return stepSuccess(data, meta);
   };
-  const rollback = stepMode ? async (_ctx, output) => {
-    const step = fnOrStep;
-    if (!step.rollback) return;
+  const rollback = step2.rollback ? async (_ctx, output) => {
     const exec = executionMap.get(output);
     if (!exec) return;
+    executionMap.delete(output);
     const results = output[key];
     const errors = [];
     for (let i = results.length - 1; i >= 0; i--) {
       try {
-        const itemCtx = { ...exec.ctx, ...exec.items[i] };
-        await step.rollback(itemCtx, results[i]);
+        const itemCtx = Object.freeze({
+          ...exec.baseCtx,
+          ...exec.combinations[i]
+        });
+        await step2.rollback(itemCtx, results[i]);
       } catch (err) {
         errors.push(toError(err));
       }
     }
     if (errors.length > 0) {
-      const error = new RollbackError(`${name}: ${errors.length} rollback(s) failed`);
-      error.cause = errors;
-      throw error;
+      throw new RollbackError(`${stepName}: ${errors.length} rollback(s) failed`, errors);
     }
   } : void 0;
-  return Object.freeze({
-    name,
-    requires: void 0,
-    provides: void 0,
+  return createStepObject({
+    name: stepName,
     run,
-    rollback,
-    retry: void 0,
-    timeout: void 0
-  });
-}
-async function runStepMode(step, items, ctx, name, key, executionMap) {
-  const settled = await Promise.allSettled(
-    items.map(async (item) => {
-      const itemCtx = { ...ctx, ...item };
-      return runInnerStep(step, itemCtx);
-    })
-  );
-  const succeeded = [];
-  const allErrors = [];
-  for (let i = 0; i < settled.length; i++) {
-    const s = settled[i];
-    if (s.status === "rejected") {
-      allErrors.push(toError(s.reason));
-    } else if (!s.value.success) {
-      allErrors.push(...s.value.errors);
-    } else {
-      succeeded.push({ index: i, output: s.value.data });
-    }
-  }
-  if (allErrors.length > 0) {
-    if (step.rollback) {
-      for (let i = succeeded.length - 1; i >= 0; i--) {
-        try {
-          const itemCtx = { ...ctx, ...items[succeeded[i].index] };
-          await step.rollback(itemCtx, succeeded[i].output);
-        } catch {
-        }
-      }
-    }
-    return { success: false, errors: allErrors };
-  }
-  const results = succeeded.map((s) => s.output);
-  const data = { [key]: results };
-  executionMap.set(data, { items, ctx: { ...ctx } });
-  return { success: true, data, errors: [] };
-}
-async function runFunctionMode(fn, items, ctx, key) {
-  const settled = await Promise.allSettled(items.map(async (item) => fn(item, ctx)));
-  const results = [];
-  const allErrors = [];
-  for (const s of settled) {
-    if (s.status === "rejected") {
-      allErrors.push(toError(s.reason));
-    } else {
-      results.push(s.value);
-    }
-  }
-  if (allErrors.length > 0) {
-    return { success: false, errors: allErrors };
-  }
-  const data = { [key]: results };
-  return { success: true, data, errors: [] };
-}
-
-// src/filter.ts
-function filter(key, collection, predicate) {
-  const name = `filter(${key})`;
-  const run = async (ctx) => {
-    let items;
-    try {
-      items = collection(ctx);
-    } catch (err) {
-      return {
-        success: false,
-        errors: [toError(err)]
-      };
-    }
-    return runFilter(
-      items,
-      ctx,
-      predicate,
-      key
-    );
-  };
-  return Object.freeze({
-    name,
-    requires: void 0,
-    provides: void 0,
-    run,
-    rollback: void 0,
-    retry: void 0,
-    timeout: void 0
-  });
-}
-async function runFilter(items, ctx, predicate, key) {
-  const settled = await Promise.allSettled(items.map(async (item) => predicate(item, ctx)));
-  const results = [];
-  const allErrors = [];
-  for (let i = 0; i < settled.length; i++) {
-    const s = settled[i];
-    if (s.status === "rejected") {
-      allErrors.push(toError(s.reason));
-    } else if (s.value) {
-      results.push(items[i]);
-    }
-  }
-  if (allErrors.length > 0) {
-    return { success: false, errors: allErrors };
-  }
-  const data = { [key]: results };
-  return { success: true, data, errors: [] };
-}
-
-// src/flat-map.ts
-function flatMap(key, collection, fn) {
-  const name = `flatMap(${key})`;
-  const run = async (ctx) => {
-    let items;
-    try {
-      items = collection(ctx);
-    } catch (err) {
-      return {
-        success: false,
-        errors: [toError(err)]
-      };
-    }
-    return runFlatMap(
-      items,
-      ctx,
-      fn,
-      key
-    );
-  };
-  return Object.freeze({
-    name,
-    requires: void 0,
-    provides: void 0,
-    run,
-    rollback: void 0,
-    retry: void 0,
-    timeout: void 0
-  });
-}
-async function runFlatMap(items, ctx, fn, key) {
-  const settled = await Promise.allSettled(items.map(async (item) => fn(item, ctx)));
-  const results = [];
-  const allErrors = [];
-  for (const s of settled) {
-    if (s.status === "rejected") {
-      allErrors.push(toError(s.reason));
-    } else {
-      results.push(...s.value);
-    }
-  }
-  if (allErrors.length > 0) {
-    return { success: false, errors: allErrors };
-  }
-  const data = { [key]: results };
-  return { success: true, data, errors: [] };
-}
-
-// src/builder.ts
-function makeBuilder(state) {
-  return Object.freeze({
-    step: (step) => makeBuilder({
-      ...state,
-      steps: [...state.steps, step]
-    }),
-    use: (...middleware) => makeBuilder({
-      ...state,
-      middleware: [...state.middleware, ...middleware]
-    }),
-    build: () => buildPipeline({
-      name: state.name,
-      steps: state.steps,
-      middleware: state.middleware.length > 0 ? state.middleware : void 0,
-      argsSchema: state.argsSchema,
-      strict: state.strict || void 0
-    })
-  });
-}
-function createPipeline(name, schemaOrOptions, options) {
-  let argsSchema;
-  let strict = false;
-  if (schemaOrOptions != null) {
-    if ("safeParse" in schemaOrOptions) {
-      argsSchema = schemaOrOptions;
-      strict = options?.strict ?? false;
-    } else {
-      strict = schemaOrOptions.strict ?? false;
-    }
-  }
-  return makeBuilder({
-    name,
-    steps: [],
-    middleware: [],
-    argsSchema,
-    strict
+    rollback
   });
 }
 export {
   ArgsValidationError,
-  ChoiceNoMatchError,
   PredicateError,
   ProvidesValidationError,
   RequiresValidationError,
@@ -791,14 +696,11 @@ export {
   StrictOverlapError,
   TimeoutError,
   UnknownError,
-  buildPipeline,
   choice,
-  createPipeline,
-  defineStep,
-  filter,
-  flatMap,
-  map,
+  distribute,
   parallel,
+  pipeline,
+  step,
   when
 };
 //# sourceMappingURL=index.js.map