runsheet 0.5.0 → 0.6.0

package/dist/index.cjs

@@ -31,21 +31,17 @@ __export(index_exports, {
   StrictOverlapError: () => StrictOverlapError,
   TimeoutError: () => TimeoutError,
   UnknownError: () => UnknownError,
-  buildPipeline: () => buildPipeline,
   choice: () => choice,
-  createPipeline: () => createPipeline,
   defineStep: () => defineStep,
   filter: () => filter,
   flatMap: () => flatMap,
   map: () => map,
   parallel: () => parallel,
+  pipeline: () => pipeline,
   when: () => when
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/define-step.ts
-var import_composable_functions = require("composable-functions");
-
 // src/errors.ts
 var RunsheetError = class extends Error {
   /** Discriminant code identifying the type of library error. */
@@ -130,24 +126,72 @@ 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;
+    this.cause = causes.length === 1 ? causes[0] : new AggregateError(causes, message);
   }
 };
 
+// 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.join(".")}: ${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/define-step.ts
-function withTimeout(run, stepName, ms) {
-  return async (ctx) => {
+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);
     }
@@ -159,43 +203,111 @@ 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;
+    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 = (0, import_composable_functions.composable)(config.run);
-  const wrappedRun = wrapWithTimeoutAndRetry(baseRun, config.name, config.timeout, config.retry);
-  return Object.freeze({
+  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/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: () => buildPipelineStep({
+      name: state.name,
+      steps: state.steps,
+      middleware: state.middleware.length > 0 ? state.middleware : void 0,
+      argsSchema: state.argsSchema,
+      strict: state.strict || void 0
+    })
   });
 }
 
@@ -206,8 +318,17 @@ function applyMiddleware(middlewares, step, executor) {
 
 // src/when.ts
 function when(predicate, step) {
+  const base = createStepObject({
+    name: step.name,
+    run: step.run,
+    rollback: step.rollback,
+    requires: step.requires,
+    provides: step.provides,
+    retry: step.retry,
+    timeout: step.timeout
+  });
   return Object.freeze({
-    ...step,
+    ...base,
     predicate
   });
 }
@@ -215,39 +336,6 @@ 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);
-}
-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}`)
-  );
-}
-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;
-}
-
 // src/pipeline.ts
 function checkStrictOverlap(steps) {
   const seen = /* @__PURE__ */ new Map();
@@ -268,168 +356,121 @@ function checkStrictOverlap(steps) {
     }
   }
 }
-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);
+      const rollback = await executeRollback(state.executed);
+      const meta2 = aggregateMeta(config.name, frozenArgs, [...state.stepsExecuted]);
+      return { result: aggregateFailure(error, meta2, step.name, rollback), state };
     }
-    state.snapshots.push(state.context);
-    const baseExecutor = createStepExecutor(step);
-    const executor = applyMiddleware(
+    const snapshot = state.context;
+    const executor = middlewares.length > 0 ? applyMiddleware(
       middlewares,
       { name: step.name, requires: step.requires, provides: step.provides },
-      baseExecutor
-    );
+      (ctx) => step.run(ctx)
+    ) : (ctx) => step.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, step.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, step.name, rollback), state };
     }
     const output = result.data;
-    state.outputs.push(output);
-    state.executedSteps.push(step);
+    state.executed.push({ step, snapshot, output });
     state.stepsExecuted.push(step.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) {
+      stateMap.delete(output);
+      await executeRollback(state.executed);
+    }
+  };
+  return createStepObject({
+    name: config.name,
+    requires: config.argsSchema,
+    run,
+    rollback
+  });
+}
+function pipeline(config) {
+  if (config.steps) {
+    return buildPipelineStep(
+      config
+    );
+  }
+  return makeBuilder({
     name: config.name,
-    run: (args) => executePipeline(config, args)
+    steps: [],
+    middleware: config.middleware ? [...config.middleware] : [],
+    argsSchema: config.argsSchema,
+    strict: config.strict ?? false
   });
 }
 
@@ -443,19 +484,23 @@ async function executeInner(step, ctx) {
     const cause = toError(err);
     const error = new PredicateError(`${step.name} predicate: ${cause.message}`);
     error.cause = cause;
-    return { step, skipped: false, errors: [error] };
+    return { step, skipped: false, error };
   }
-  const result = await runInnerStep(step, ctx);
-  if (!result.success) return { step, skipped: false, errors: [...result.errors] };
+  const result = await step.run(ctx);
+  if (!result.success) return { step, skipped: false, error: result.error };
   return { step, skipped: false, output: result.data };
 }
 function parallel(...steps) {
   const name = `parallel(${steps.map((s) => s.name).join(", ")})`;
   const innerSteps = steps;
   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((step) => executeInner(step, frozenCtx))
+    );
     const succeeded = [];
     const allErrors = [];
+    const executed = [];
     for (const s of settled) {
       if (s.status === "rejected") {
         allErrors.push(toError(s.reason));
@@ -464,8 +509,9 @@ 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);
         }
       }
     }
@@ -474,44 +520,49 @@ function parallel(...steps) {
         const { step, output } = succeeded[i];
         if (step.rollback) {
           try {
-            await step.rollback(ctx, output);
+            await step.rollback(frozenCtx, output);
           } catch {
           }
         }
       }
-      return { success: false, errors: allErrors };
+      const error = collapseErrors(allErrors, `${name}: ${allErrors.length} step(s) failed`);
+      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 executedMap = /* @__PURE__ */ new WeakMap();
   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];
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const { step, output } = entries[i];
       if (!step.rollback) continue;
       try {
-        await step.rollback(ctx, mergedOutput);
+        await step.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
   });
 }
 
@@ -527,50 +578,49 @@ function choice(...args) {
   const name = `choice(${innerBranches.map(([, step]) => step.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];
       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 step.run(frozenCtx);
+      if (!result.success) {
+        const meta3 = aggregateMeta(name, frozenCtx, [step.name]);
+        return aggregateFailure(result.error, meta3, name);
+      }
       branchMap.set(result.data, i);
-      return { success: true, data: result.data, errors: [] };
+      const meta2 = aggregateMeta(name, frozenCtx, [step.name]);
+      return aggregateSuccess(result.data, meta2);
     }
-    return {
-      success: false,
-      errors: [new ChoiceNoMatchError(`${name}: no branch matched`)]
-    };
+    const meta = aggregateMeta(name, frozenCtx, []);
+    return aggregateFailure(new ChoiceNoMatchError(`${name}: no branch matched`), meta, name);
   };
   const rollback = async (ctx, output) => {
     const branchIndex = branchMap.get(output);
     if (branchIndex === void 0) return;
+    branchMap.delete(output);
     const [, step] = innerBranches[branchIndex];
     if (step.rollback) {
       try {
         await step.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
   });
 }
 
@@ -583,23 +633,24 @@ function map(key, collection, fnOrStep) {
   const name = stepMode ? `map(${key}, ${fnOrStep.name})` : `map(${key})`;
   const executionMap = /* @__PURE__ */ new WeakMap();
   const run = async (ctx) => {
+    const frozenCtx = Object.freeze({ ...ctx });
+    const meta = baseMeta(name, frozenCtx);
     let items;
     try {
-      items = collection(ctx);
+      items = collection(frozenCtx);
     } catch (err) {
-      return {
-        success: false,
-        errors: [toError(err)]
-      };
+      return stepFailure(toError(err), meta, name);
     }
     if (stepMode) {
-      return runStepMode(fnOrStep, items, ctx, name, key, executionMap);
+      return runStepMode(fnOrStep, items, frozenCtx, name, key, executionMap, meta);
     } else {
       return runFunctionMode(
         fnOrStep,
         items,
-        ctx,
-        key
+        frozenCtx,
+        key,
+        name,
+        meta
       );
     }
   };
@@ -608,37 +659,32 @@ function map(key, collection, fnOrStep) {
     if (!step.rollback) return;
     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] };
+        const itemCtx = Object.freeze({ ...exec.ctx, ...exec.items[i] });
         await step.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(`${name}: ${errors.length} rollback(s) failed`, errors);
     }
   } : void 0;
-  return Object.freeze({
+  return createStepObject({
     name,
-    requires: void 0,
-    provides: void 0,
     run,
-    rollback,
-    retry: void 0,
-    timeout: void 0
+    rollback
   });
 }
-async function runStepMode(step, items, ctx, name, key, executionMap) {
+async function runStepMode(step, items, ctx, name, key, executionMap, meta) {
   const settled = await Promise.allSettled(
     items.map(async (item) => {
       const itemCtx = { ...ctx, ...item };
-      return runInnerStep(step, itemCtx);
+      return step.run(itemCtx);
     })
   );
   const succeeded = [];
@@ -648,7 +694,7 @@ async function runStepMode(step, items, ctx, name, key, executionMap) {
     if (s.status === "rejected") {
       allErrors.push(toError(s.reason));
     } else if (!s.value.success) {
-      allErrors.push(...s.value.errors);
+      allErrors.push(s.value.error);
     } else {
       succeeded.push({ index: i, output: s.value.data });
     }
@@ -657,172 +703,135 @@ async function runStepMode(step, items, ctx, name, key, executionMap) {
     if (step.rollback) {
       for (let i = succeeded.length - 1; i >= 0; i--) {
         try {
-          const itemCtx = { ...ctx, ...items[succeeded[i].index] };
+          const itemCtx = Object.freeze({ ...ctx, ...items[succeeded[i].index] });
           await step.rollback(itemCtx, succeeded[i].output);
         } catch {
         }
       }
     }
-    return { success: false, errors: allErrors };
+    return stepFailure(
+      collapseErrors(allErrors, `${name}: ${allErrors.length} item(s) failed`),
+      meta,
+      name
+    );
   }
   const results = succeeded.map((s) => s.output);
   const data = { [key]: results };
   executionMap.set(data, { items, ctx: { ...ctx } });
-  return { success: true, data, errors: [] };
+  return stepSuccess(data, meta);
 }
-async function runFunctionMode(fn, items, ctx, key) {
+async function runFunctionMode(fn, items, ctx, key, stepName, meta) {
   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 (s.status === "rejected") allErrors.push(toError(s.reason));
   }
   if (allErrors.length > 0) {
-    return { success: false, errors: allErrors };
+    return stepFailure(
+      collapseErrors(allErrors, `${stepName}: ${allErrors.length} item(s) failed`),
+      meta,
+      stepName
+    );
   }
+  const results = settled.map((s) => s.value);
   const data = { [key]: results };
-  return { success: true, data, errors: [] };
+  return stepSuccess(data, meta);
 }
 
 // src/filter.ts
 function filter(key, collection, predicate) {
   const name = `filter(${key})`;
   const run = async (ctx) => {
+    const frozenCtx = Object.freeze({ ...ctx });
+    const meta = baseMeta(name, frozenCtx);
     let items;
     try {
-      items = collection(ctx);
+      items = collection(frozenCtx);
     } catch (err) {
-      return {
-        success: false,
-        errors: [toError(err)]
-      };
+      return stepFailure(toError(err), meta, name);
     }
     return runFilter(
       items,
-      ctx,
+      frozenCtx,
       predicate,
-      key
+      key,
+      name,
+      meta
     );
   };
-  return Object.freeze({
+  return createStepObject({
     name,
-    requires: void 0,
-    provides: void 0,
-    run,
-    rollback: void 0,
-    retry: void 0,
-    timeout: void 0
+    run
   });
 }
-async function runFilter(items, ctx, predicate, key) {
+async function runFilter(items, ctx, predicate, key, name, meta) {
   const settled = await Promise.allSettled(items.map(async (item) => predicate(item, ctx)));
-  const results = [];
   const allErrors = [];
+  for (const s of settled) {
+    if (s.status === "rejected") allErrors.push(toError(s.reason));
+  }
+  if (allErrors.length > 0) {
+    return stepFailure(
+      collapseErrors(allErrors, `${name}: ${allErrors.length} predicate(s) failed`),
+      meta,
+      name
+    );
+  }
+  const results = [];
   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) {
+    if (settled[i].value) {
       results.push(items[i]);
     }
   }
-  if (allErrors.length > 0) {
-    return { success: false, errors: allErrors };
-  }
   const data = { [key]: results };
-  return { success: true, data, errors: [] };
+  return stepSuccess(data, meta);
 }
 
 // src/flat-map.ts
 function flatMap(key, collection, fn) {
   const name = `flatMap(${key})`;
   const run = async (ctx) => {
+    const frozenCtx = Object.freeze({ ...ctx });
+    const meta = baseMeta(name, frozenCtx);
     let items;
     try {
-      items = collection(ctx);
+      items = collection(frozenCtx);
     } catch (err) {
-      return {
-        success: false,
-        errors: [toError(err)]
-      };
+      return stepFailure(toError(err), meta, name);
     }
     return runFlatMap(
       items,
-      ctx,
+      frozenCtx,
       fn,
-      key
+      key,
+      name,
+      meta
     );
   };
-  return Object.freeze({
+  return createStepObject({
     name,
-    requires: void 0,
-    provides: void 0,
-    run,
-    rollback: void 0,
-    retry: void 0,
-    timeout: void 0
+    run
   });
 }
-async function runFlatMap(items, ctx, fn, key) {
+async function runFlatMap(items, ctx, fn, key, name, meta) {
   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 (s.status === "rejected") allErrors.push(toError(s.reason));
   }
   if (allErrors.length > 0) {
-    return { success: false, errors: allErrors };
+    return stepFailure(
+      collapseErrors(allErrors, `${name}: ${allErrors.length} callback(s) failed`),
+      meta,
+      name
+    );
   }
-  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;
-    }
+  const results = [];
+  for (const s of settled) {
+    results.push(...s.value);
   }
-  return makeBuilder({
-    name,
-    steps: [],
-    middleware: [],
-    argsSchema,
-    strict
-  });
+  const data = { [key]: results };
+  return stepSuccess(data, meta);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -837,14 +846,13 @@ function createPipeline(name, schemaOrOptions, options) {
   StrictOverlapError,
   TimeoutError,
   UnknownError,
-  buildPipeline,
   choice,
-  createPipeline,
   defineStep,
   filter,
   flatMap,
   map,
   parallel,
+  pipeline,
   when
 });
 //# sourceMappingURL=index.cjs.map