@onrails/result 0.4.0 → 0.4.1

package/dist/railway.d.cts

@@ -1,30 +1,53 @@
-import { R as ResultAsync } from './async-DcXR7k9K.cjs';
-import { R as Result } from './types-BQ9vv0nD.cjs';
-
+import { ResultAsync } from "./async.js";
+import type { Result } from "./types.js";
 /**
  * Tracks whether a {@link Railway} workflow has crossed an async boundary.
  * Sync workflows return {@link Result}; async workflows return {@link ResultAsync}.
  */
-type RailwayMode = "sync" | "async";
+export type RailwayMode = "sync" | "async";
 /**
  * Mode-aware output type for a {@link Railway} workflow: sync mode →
  * `Result<T, E>`, async mode → `ResultAsync<T, E>`.
  */
-type RailwayOutput<T, E, M extends RailwayMode> = M extends "async" ? ResultAsync<T, E> : Result<T, E>;
-type BranchFn<C extends object> = (ctx: C) => ResultAsync<unknown, unknown>;
-type BranchRecord = Record<string, (ctx: never) => ResultAsync<unknown, unknown>>;
+export type RailwayOutput<T, E, M extends RailwayMode> = M extends "async" ? ResultAsync<T, E> : Result<T, E>;
+export type BranchFn<C extends object> = (ctx: C) => ResultAsync<unknown, unknown>;
+export type BranchRecord = Record<string, (ctx: never) => ResultAsync<unknown, unknown>>;
 type BranchOk<R> = R extends (ctx: never) => ResultAsync<infer T, infer _E> ? T : never;
 type BranchErr<R> = R extends (ctx: never) => ResultAsync<infer _T, infer E> ? E : never;
-type ParallelOutput<R extends BranchRecord> = {
+export type ParallelOutput<R extends BranchRecord> = {
     [K in keyof R]: BranchOk<R[K]>;
 };
-type ParallelError<R extends BranchRecord> = BranchErr<R[keyof R]>;
+export type ParallelError<R extends BranchRecord> = BranchErr<R[keyof R]>;
+/** Collapses an intersection into a single displayed object type. */
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * The context after one more named step. Chaining `C & Record<K, T>` instead
+ * builds an intersection that TS echoes verbatim in every hover and error
+ * message (`Record<never, never> & Record<"id", string> & …`); `Omit` keeps
+ * property modifiers and `Prettify` collapses the result to a flat object.
+ */
+type Extend<C extends object, K extends string, T> = Prettify<Omit<C, K> & Record<K, T>>;
+/**
+ * Rejects a key already present in the context. Railway merges each step with
+ * a spread, so a repeated key overwrites at runtime while the old
+ * `C & Record<K, T>` type intersected the two field types — `number & string`
+ * became `never` and nothing complained. Resolves to `[]` for a fresh key and
+ * to an unsatisfiable extra parameter otherwise, so the collision fails at the
+ * call site with the offending name in the message.
+ */
+type FreshKey<C, K extends string> = K extends keyof C ? [error: `key "${K}" already exists in the workflow context`] : [];
+/** {@link FreshKey} for a whole record of parallel branches. */
+type FreshKeys<C, R> = Extract<keyof R, keyof C> extends never ? [] : [
+    error: `branch key "${Extract<keyof R, keyof C> & string}" already exists in the workflow context`
+];
 /**
  * Named-context workflow builder. Each step appends a typed field to the
  * accumulating context object; the workflow tracks sync/async mode so the
  * final output type ({@link RailwayOutput}) is correct.
  */
-declare class Railway<C extends object, E, M extends RailwayMode> {
+export declare class Railway<C extends object, E, M extends RailwayMode> {
     private readonly state;
     private constructor();
     /** Start an empty sync workflow with no fields in context. */
@@ -55,24 +78,31 @@ declare class Railway<C extends object, E, M extends RailwayMode> {
     private out;
     /** Lift the carried result into `ResultAsync` for async-upgrading steps. */
     private toAsync;
+    /**
+     * Internal plumbing for a sync field append. Public steps wrap this and add
+     * the {@link FreshKey} collision guard; the static factories bypass the
+     * guard because they always start from an empty context.
+     */
+    private addSync;
+    /** Internal plumbing for an async field append — upgrades the mode. */
+    private addAsync;
     /** Pure sync derivation. */
-    derive<K extends string, T>(key: K, fn: (ctx: C) => T): Railway<C & Record<K, T>, E, M>;
+    derive<K extends string, T>(key: K, fn: (ctx: C) => T, ..._guard: FreshKey<C, K>): Railway<Extend<C, K, T>, E, M>;
     /** Throwing sync transform. */
-    fromSync<K extends string, T, F>(key: K, fn: (ctx: C) => T, onThrow: (error: unknown) => F): Railway<C & Record<K, T>, E | F, M>;
+    fromSync<K extends string, T, F>(key: K, fn: (ctx: C) => T, onThrow: (error: unknown) => F, ..._guard: FreshKey<C, K>): Railway<Extend<C, K, T>, E | F, M>;
     /** Sync `Result`-returning step. */
-    fromResult<K extends string, T, F>(key: K, fn: (ctx: C) => Result<T, F>): Railway<C & Record<K, T>, E | F, M>;
+    fromResult<K extends string, T, F>(key: K, fn: (ctx: C) => Result<T, F>, ..._guard: FreshKey<C, K>): Railway<Extend<C, K, T>, E | F, M>;
     /** Promise-returning step — upgrades the workflow to async mode. */
-    fromPromise<K extends string, T, F>(key: K, fn: (ctx: C) => PromiseLike<T>, onReject: (error: unknown) => F): Railway<C & Record<K, T>, E | F, "async">;
+    fromPromise<K extends string, T, F>(key: K, fn: (ctx: C) => PromiseLike<T>, onReject: (error: unknown) => F, ..._guard: FreshKey<C, K>): Railway<Extend<C, K, T>, E | F, "async">;
     /** `ResultAsync`-returning step — upgrades the workflow to async mode. */
-    fromAsync<K extends string, T, F>(key: K, fn: (ctx: C) => ResultAsync<T, F>): Railway<C & Record<K, T>, E | F, "async">;
+    fromAsync<K extends string, T, F>(key: K, fn: (ctx: C) => ResultAsync<T, F>, ..._guard: FreshKey<C, K>): Railway<Extend<C, K, T>, E | F, "async">;
     /** Narrow a nullable context field into a required non-null field. */
-    require<K extends string, S extends keyof C, F>(key: K, source: S, onMissing: (ctx: C) => F): Railway<C & Record<K, NonNullable<C[S]>>, E | F, M>;
+    require<K extends string, S extends keyof C, F>(key: K, source: S, onMissing: (ctx: C) => F, ..._guard: FreshKey<C, K>): Railway<Extend<C, K, NonNullable<C[S]>>, E | F, M>;
     /** Run independent `ResultAsync` branches concurrently and merge outputs. */
-    parallel<R extends Record<string, BranchFn<C>>>(branches: R): Railway<C & ParallelOutput<R>, E | ParallelError<R>, "async">;
+    parallel<R extends Record<string, BranchFn<C>>>(branches: R, ..._guard: FreshKeys<C, R>): Railway<Prettify<Omit<C, keyof R> & ParallelOutput<R>>, E | ParallelError<R>, "async">;
     /** Project the final context into the workflow's output type. */
     select<T>(fn: (ctx: C) => T): RailwayOutput<T, E, M>;
     /** Return the accumulated context as-is. */
     done(): RailwayOutput<C, E, M>;
 }
-
-export { type BranchFn, type BranchRecord, type ParallelError, type ParallelOutput, Railway, type RailwayMode, type RailwayOutput };
+export {};

package/dist/railway.d.ts

@@ -1,30 +1,53 @@
-import { R as ResultAsync } from './async-Ci6WSL5-.js';
-import { R as Result } from './types-BQ9vv0nD.js';
-
+import { ResultAsync } from "./async.js";
+import type { Result } from "./types.js";
 /**
  * Tracks whether a {@link Railway} workflow has crossed an async boundary.
  * Sync workflows return {@link Result}; async workflows return {@link ResultAsync}.
  */
-type RailwayMode = "sync" | "async";
+export type RailwayMode = "sync" | "async";
 /**
  * Mode-aware output type for a {@link Railway} workflow: sync mode →
  * `Result<T, E>`, async mode → `ResultAsync<T, E>`.
  */
-type RailwayOutput<T, E, M extends RailwayMode> = M extends "async" ? ResultAsync<T, E> : Result<T, E>;
-type BranchFn<C extends object> = (ctx: C) => ResultAsync<unknown, unknown>;
-type BranchRecord = Record<string, (ctx: never) => ResultAsync<unknown, unknown>>;
+export type RailwayOutput<T, E, M extends RailwayMode> = M extends "async" ? ResultAsync<T, E> : Result<T, E>;
+export type BranchFn<C extends object> = (ctx: C) => ResultAsync<unknown, unknown>;
+export type BranchRecord = Record<string, (ctx: never) => ResultAsync<unknown, unknown>>;
 type BranchOk<R> = R extends (ctx: never) => ResultAsync<infer T, infer _E> ? T : never;
 type BranchErr<R> = R extends (ctx: never) => ResultAsync<infer _T, infer E> ? E : never;
-type ParallelOutput<R extends BranchRecord> = {
+export type ParallelOutput<R extends BranchRecord> = {
     [K in keyof R]: BranchOk<R[K]>;
 };
-type ParallelError<R extends BranchRecord> = BranchErr<R[keyof R]>;
+export type ParallelError<R extends BranchRecord> = BranchErr<R[keyof R]>;
+/** Collapses an intersection into a single displayed object type. */
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * The context after one more named step. Chaining `C & Record<K, T>` instead
+ * builds an intersection that TS echoes verbatim in every hover and error
+ * message (`Record<never, never> & Record<"id", string> & …`); `Omit` keeps
+ * property modifiers and `Prettify` collapses the result to a flat object.
+ */
+type Extend<C extends object, K extends string, T> = Prettify<Omit<C, K> & Record<K, T>>;
+/**
+ * Rejects a key already present in the context. Railway merges each step with
+ * a spread, so a repeated key overwrites at runtime while the old
+ * `C & Record<K, T>` type intersected the two field types — `number & string`
+ * became `never` and nothing complained. Resolves to `[]` for a fresh key and
+ * to an unsatisfiable extra parameter otherwise, so the collision fails at the
+ * call site with the offending name in the message.
+ */
+type FreshKey<C, K extends string> = K extends keyof C ? [error: `key "${K}" already exists in the workflow context`] : [];
+/** {@link FreshKey} for a whole record of parallel branches. */
+type FreshKeys<C, R> = Extract<keyof R, keyof C> extends never ? [] : [
+    error: `branch key "${Extract<keyof R, keyof C> & string}" already exists in the workflow context`
+];
 /**
  * Named-context workflow builder. Each step appends a typed field to the
  * accumulating context object; the workflow tracks sync/async mode so the
  * final output type ({@link RailwayOutput}) is correct.
  */
-declare class Railway<C extends object, E, M extends RailwayMode> {
+export declare class Railway<C extends object, E, M extends RailwayMode> {
     private readonly state;
     private constructor();
     /** Start an empty sync workflow with no fields in context. */
@@ -55,24 +78,31 @@ declare class Railway<C extends object, E, M extends RailwayMode> {
     private out;
     /** Lift the carried result into `ResultAsync` for async-upgrading steps. */
     private toAsync;
+    /**
+     * Internal plumbing for a sync field append. Public steps wrap this and add
+     * the {@link FreshKey} collision guard; the static factories bypass the
+     * guard because they always start from an empty context.
+     */
+    private addSync;
+    /** Internal plumbing for an async field append — upgrades the mode. */
+    private addAsync;
     /** Pure sync derivation. */
-    derive<K extends string, T>(key: K, fn: (ctx: C) => T): Railway<C & Record<K, T>, E, M>;
+    derive<K extends string, T>(key: K, fn: (ctx: C) => T, ..._guard: FreshKey<C, K>): Railway<Extend<C, K, T>, E, M>;
     /** Throwing sync transform. */
-    fromSync<K extends string, T, F>(key: K, fn: (ctx: C) => T, onThrow: (error: unknown) => F): Railway<C & Record<K, T>, E | F, M>;
+    fromSync<K extends string, T, F>(key: K, fn: (ctx: C) => T, onThrow: (error: unknown) => F, ..._guard: FreshKey<C, K>): Railway<Extend<C, K, T>, E | F, M>;
     /** Sync `Result`-returning step. */
-    fromResult<K extends string, T, F>(key: K, fn: (ctx: C) => Result<T, F>): Railway<C & Record<K, T>, E | F, M>;
+    fromResult<K extends string, T, F>(key: K, fn: (ctx: C) => Result<T, F>, ..._guard: FreshKey<C, K>): Railway<Extend<C, K, T>, E | F, M>;
     /** Promise-returning step — upgrades the workflow to async mode. */
-    fromPromise<K extends string, T, F>(key: K, fn: (ctx: C) => PromiseLike<T>, onReject: (error: unknown) => F): Railway<C & Record<K, T>, E | F, "async">;
+    fromPromise<K extends string, T, F>(key: K, fn: (ctx: C) => PromiseLike<T>, onReject: (error: unknown) => F, ..._guard: FreshKey<C, K>): Railway<Extend<C, K, T>, E | F, "async">;
     /** `ResultAsync`-returning step — upgrades the workflow to async mode. */
-    fromAsync<K extends string, T, F>(key: K, fn: (ctx: C) => ResultAsync<T, F>): Railway<C & Record<K, T>, E | F, "async">;
+    fromAsync<K extends string, T, F>(key: K, fn: (ctx: C) => ResultAsync<T, F>, ..._guard: FreshKey<C, K>): Railway<Extend<C, K, T>, E | F, "async">;
     /** Narrow a nullable context field into a required non-null field. */
-    require<K extends string, S extends keyof C, F>(key: K, source: S, onMissing: (ctx: C) => F): Railway<C & Record<K, NonNullable<C[S]>>, E | F, M>;
+    require<K extends string, S extends keyof C, F>(key: K, source: S, onMissing: (ctx: C) => F, ..._guard: FreshKey<C, K>): Railway<Extend<C, K, NonNullable<C[S]>>, E | F, M>;
     /** Run independent `ResultAsync` branches concurrently and merge outputs. */
-    parallel<R extends Record<string, BranchFn<C>>>(branches: R): Railway<C & ParallelOutput<R>, E | ParallelError<R>, "async">;
+    parallel<R extends Record<string, BranchFn<C>>>(branches: R, ..._guard: FreshKeys<C, R>): Railway<Prettify<Omit<C, keyof R> & ParallelOutput<R>>, E | ParallelError<R>, "async">;
     /** Project the final context into the workflow's output type. */
     select<T>(fn: (ctx: C) => T): RailwayOutput<T, E, M>;
     /** Return the accumulated context as-is. */
     done(): RailwayOutput<C, E, M>;
 }
-
-export { type BranchFn, type BranchRecord, type ParallelError, type ParallelOutput, Railway, type RailwayMode, type RailwayOutput };
+export {};

package/dist/railway.js

@@ -1,3 +1,13 @@
+// src/internal/ctor.ts
+var mkOk = (value) => ({
+  _tag: "Ok",
+  value
+});
+var mkErr = (error) => ({
+  _tag: "Err",
+  error
+});
+
 // src/internal/dual.ts
 var dual = (arity, body) => {
   const run = body;
@@ -6,34 +16,30 @@ var dual = (arity, body) => {
 };
 
 // src/result.ts
-var ok = (value) => ({
-  _tag: "Ok",
-  value
-});
-var err = (error) => ({
-  _tag: "Err",
-  error
-});
 var isOk = (result) => result._tag === "Ok";
 var isErr = (result) => result._tag === "Err";
 var map = dual(
   2,
-  (result, fn) => isOk(result) ? ok(fn(result.value)) : err(result.error)
+  (result, fn) => isOk(result) ? mkOk(fn(result.value)) : mkErr(result.error)
 );
 var mapErr = dual(
   2,
-  (result, fn) => isErr(result) ? err(fn(result.error)) : ok(result.value)
+  (result, fn) => isErr(result) ? mkErr(fn(result.error)) : mkOk(result.value)
+);
+var bimap = dual(
+  3,
+  (result, onOk, onErr) => isOk(result) ? mkOk(onOk(result.value)) : mkErr(onErr(result.error))
 );
 var flatMap = dual(
   2,
-  (result, fn) => isOk(result) ? fn(result.value) : err(result.error)
+  (result, fn) => isOk(result) ? fn(result.value) : mkErr(result.error)
 );
-function trySync(fn, onThrow) {
+function fromThrowable(fn, onThrow) {
   return (...args) => {
     try {
-      return ok(fn(...args));
+      return mkOk(fn(...args));
     } catch (error) {
-      return err(onThrow(error));
+      return mkErr(onThrow(error));
     }
   };
 }
@@ -53,11 +59,11 @@ var sequenceSettled = (settled) => {
   const values = [];
   for (const result of settled) {
     if (isErr(result)) {
-      return err(result.error);
+      return mkErr(result.error);
     }
     values.push(result.value);
   }
-  return ok(values);
+  return mkOk(values);
 };
 var ResultAsync = class _ResultAsync {
   constructor(run) {
@@ -94,9 +100,9 @@ var ResultAsync = class _ResultAsync {
   static fromPromise(promise, onReject) {
     return new _ResultAsync(async () => {
       try {
-        return ok(await promise);
+        return mkOk(await promise);
       } catch (error) {
-        return err(onReject(error));
+        return mkErr(onReject(error));
       }
     });
   }
@@ -110,7 +116,7 @@ var ResultAsync = class _ResultAsync {
    * ```
    */
   static fromSafePromise(promise) {
-    return new _ResultAsync(async () => ok(await promise));
+    return new _ResultAsync(async () => mkOk(await promise));
   }
   /**
    * Defers work until {@link resolve}. Unlike {@link fromPromise}, the factory
@@ -128,21 +134,13 @@ var ResultAsync = class _ResultAsync {
     return new _ResultAsync(fn);
   }
   static ok(value) {
-    return new _ResultAsync(async () => ok(value));
+    return new _ResultAsync(async () => mkOk(value));
   }
   static of(value) {
     return _ResultAsync.ok(value);
   }
-  /**
-   * Lifts an error into an `Err` async result.
-   *
-   * @example
-   * ```ts
-   * const r = ResultAsync.err({ kind: "not_found" as const });
-   * ```
-   */
   static err(error) {
-    return new _ResultAsync(async () => err(error));
+    return new _ResultAsync(async () => mkErr(error));
   }
   /**
    * Lifts an existing `Promise<Result<T, E>>` (e.g. from interop code) into a
@@ -160,7 +158,7 @@ var ResultAsync = class _ResultAsync {
       try {
         return await promise;
       } catch (error) {
-        return err(mapDefect(error));
+        return mkErr(mapDefect(error));
       }
     });
   }
@@ -182,11 +180,11 @@ var ResultAsync = class _ResultAsync {
       for (const ra of results) {
         const result = await ra.resolve();
         if (isErr(result)) {
-          return err(result.error);
+          return mkErr(result.error);
         }
         values.push(result.value);
       }
-      return ok(values);
+      return mkOk(values);
     });
   }
   /**
@@ -198,7 +196,7 @@ var ResultAsync = class _ResultAsync {
    *
    * @example
    * ```ts
-   * const combined = ResultAsync.combineTuple([loadCfg(), loadCatalog()] as const);
+   * const combined = ResultAsync.combineTuple([loadCfg(), loadCatalog()]);
    * // ResultAsync<readonly [Cfg, Catalog], CfgError | CatalogError>
    * const r = await combined;
    * if (isOk(r)) {
@@ -206,7 +204,7 @@ var ResultAsync = class _ResultAsync {
    * }
    * ```
    */
-  static combineTuple(results) {
+  static combineTuple(results, ..._guard) {
     return _ResultAsync.combine(
       results
     );
@@ -221,12 +219,14 @@ var ResultAsync = class _ResultAsync {
    * const combined = ResultAsync.combineTupleParallel([
    *   loadProfile(id),
    *   loadMetrics(id),
-   * ] as const);
+   * ]);
    * ```
    */
-  static combineTupleParallel(results) {
+  static combineTupleParallel(results, ..._guard) {
     return new _ResultAsync(
-      async () => sequenceSettled(await Promise.all(results.map((ra) => ra.resolve())))
+      async () => sequenceSettled(
+        await Promise.all(results.map((ra) => ra.resolve()))
+      )
     );
   }
   /**
@@ -252,6 +252,18 @@ var ResultAsync = class _ResultAsync {
   mapErr(fn) {
     return new _ResultAsync(async () => mapErr(await this.resolve(), fn));
   }
+  /**
+   * Transforms both tracks in one step — the async mirror of the sync
+   * `bimap`. Exactly one of `onOk` / `onErr` runs.
+   *
+   * @example
+   * ```ts
+   * load(id).bimap(toDto, (e): AppError => ({ kind: "load", cause: e }));
+   * ```
+   */
+  bimap(onOk, onErr) {
+    return new _ResultAsync(async () => bimap(await this.resolve(), onOk, onErr));
+  }
   /**
    * Canonical bind — chains a step that itself returns a `ResultAsync` or sync
    * `Result`, short-circuiting on `Err`. Error types accumulate (`E | F`).
@@ -425,27 +437,27 @@ var Railway = class _Railway {
   state;
   /** Start an empty sync workflow with no fields in context. */
   static empty() {
-    return new _Railway({ mode: "sync", result: ok({}) });
+    return new _Railway({ mode: "sync", result: mkOk({}) });
   }
   /** Start a sync workflow with the given context as the initial state. */
   static context(context) {
-    return new _Railway({ mode: "sync", result: ok(context) });
+    return new _Railway({ mode: "sync", result: mkOk(context) });
   }
   /** Start a sync workflow with a throwing function. */
   static fromSync(key, fn, onThrow) {
-    return _Railway.empty().fromSync(key, fn, onThrow);
+    return _Railway.empty().addSync(key, () => fromThrowable(fn, onThrow)());
   }
   /** Start a sync workflow with a `Result`-returning function. */
   static fromResult(key, fn) {
-    return _Railway.empty().fromResult(key, fn);
+    return _Railway.empty().addSync(key, fn);
   }
   /** Start an async workflow with a `PromiseLike`-returning function. */
   static fromPromise(key, fn, onReject) {
-    return _Railway.empty().fromPromise(key, fn, onReject);
+    return _Railway.empty().addAsync(key, () => ResultAsync.fromPromise(fn(), onReject));
   }
   /** Start an async workflow with a `ResultAsync`-returning function. */
   static fromAsync(key, fn) {
-    return _Railway.empty().fromAsync(key, fn);
+    return _Railway.empty().addAsync(key, fn);
   }
   /**
    * Rebuild the workflow in its current mode after transforming the carried
@@ -470,16 +482,12 @@ var Railway = class _Railway {
   toAsync() {
     return this.state.mode === "sync" ? ResultAsync.fromResult(this.state.result) : this.state.result;
   }
-  /** Pure sync derivation. */
-  derive(key, fn) {
-    return this.fromResult(key, (ctx) => ok(fn(ctx)));
-  }
-  /** Throwing sync transform. */
-  fromSync(key, fn, onThrow) {
-    return this.fromResult(key, (ctx) => trySync(fn, onThrow)(ctx));
-  }
-  /** Sync `Result`-returning step. */
-  fromResult(key, fn) {
+  /**
+   * Internal plumbing for a sync field append. Public steps wrap this and add
+   * the {@link FreshKey} collision guard; the static factories bypass the
+   * guard because they always start from an empty context.
+   */
+  addSync(key, fn) {
     return this.step(
       (result) => flatMap(result, (ctx) => map(fn(ctx), (value) => addField(ctx, key, value))),
       (result) => result.flatMap(
@@ -487,26 +495,42 @@ var Railway = class _Railway {
       )
     );
   }
-  /** Promise-returning step — upgrades the workflow to async mode. */
-  fromPromise(key, fn, onReject) {
-    return this.fromAsync(key, (ctx) => ResultAsync.fromPromise(fn(ctx), onReject));
-  }
-  /** `ResultAsync`-returning step — upgrades the workflow to async mode. */
-  fromAsync(key, fn) {
+  /** Internal plumbing for an async field append — upgrades the mode. */
+  addAsync(key, fn) {
     return new _Railway({
       mode: "async",
       result: this.toAsync().flatMap((ctx) => fn(ctx).map((value) => addField(ctx, key, value)))
     });
   }
+  /** Pure sync derivation. */
+  derive(key, fn, ..._guard) {
+    return this.addSync(key, (ctx) => mkOk(fn(ctx)));
+  }
+  /** Throwing sync transform. */
+  fromSync(key, fn, onThrow, ..._guard) {
+    return this.addSync(key, (ctx) => fromThrowable(fn, onThrow)(ctx));
+  }
+  /** Sync `Result`-returning step. */
+  fromResult(key, fn, ..._guard) {
+    return this.addSync(key, fn);
+  }
+  /** Promise-returning step — upgrades the workflow to async mode. */
+  fromPromise(key, fn, onReject, ..._guard) {
+    return this.addAsync(key, (ctx) => ResultAsync.fromPromise(fn(ctx), onReject));
+  }
+  /** `ResultAsync`-returning step — upgrades the workflow to async mode. */
+  fromAsync(key, fn, ..._guard) {
+    return this.addAsync(key, fn);
+  }
   /** Narrow a nullable context field into a required non-null field. */
-  require(key, source, onMissing) {
-    return this.fromResult(key, (ctx) => {
+  require(key, source, onMissing, ..._guard) {
+    return this.addSync(key, (ctx) => {
       const value = ctx[source];
-      return value == null ? err(onMissing(ctx)) : ok(value);
+      return value == null ? mkErr(onMissing(ctx)) : mkOk(value);
     });
   }
   /** Run independent `ResultAsync` branches concurrently and merge outputs. */
-  parallel(branches) {
+  parallel(branches, ..._guard) {
     const merged = this.toAsync().flatMap(
       (ctx) => ResultAsync.combineTupleParallel(
         Object.entries(branches).map(([, branch]) => branch(ctx))