@onrails/result 0.4.0 → 0.4.2

package/dist/{async-DcXR7k9K.d.cts → async.d.ts}

@@ -1,56 +1,25 @@
-import { R as Result, U as UnexpectedError } from './types-BQ9vv0nD.cjs';
-
-/**
- * @onrails/result internal — the single payload-extraction pair.
- *
- * `InferOk` / `InferErr` pull the success/error type out of a {@link Result}
- * (tagged union) or a {@link ResultAsync} (class carrier), resolving to
- * `never` for anything else. Every module that needs to extract a payload
- * type imports from here; do not redeclare local copies.
- *
- * Internal only: not listed in package.json `exports` or tsup entries.
- * The package index re-exports the pair under the same names.
- */
-
-/**
- * Extracts the `Ok` value type from a {@link Result} or {@link ResultAsync},
- * resolving to `never` for any other type.
- *
- * @example
- * ```ts
- * type T = InferOk<Result<number, string>>;        // number
- * type U = InferOk<ResultAsync<User, AppError>>;    // User
- * ```
- */
-type InferOk<R> = R extends {
-    _tag: "Ok";
-    readonly value: infer T;
-} ? T : R extends ResultAsync<infer T, unknown> ? T : never;
+import type { InferErr, InferOk } from "./internal/infer.js";
+import type { Payload } from "./internal/payload.js";
+import type { Result } from "./types.js";
+import { UnexpectedError } from "./types.js";
+type PromiseFactory<T, E> = () => Promise<Result<T, E>>;
+type AnyResultAsync = ResultAsync<unknown, unknown>;
 /**
- * Extracts the `Err` error type from a {@link Result} or {@link ResultAsync},
- * resolving to `never` for any other type. Mirror of {@link InferOk}.
- *
- * @example
- * ```ts
- * type E = InferErr<Result<number, string>>;        // string
- * type F = InferErr<ResultAsync<User, AppError>>;    // AppError
- * ```
+ * Mirrors the sync `CombineTuple` in `./collections.ts`: the element check
+ * lives in the RETURN type, never in the parameter constraint. A
+ * `ResultAsync<unknown, unknown>` constraint contextually types the arguments
+ * and widens `okAsync(1)`'s defaulted `E = never` to `unknown`, so call sites
+ * would need hoisted intermediates to keep their error union.
  */
-type InferErr<R> = R extends {
-    _tag: "Err";
-    readonly error: infer E;
-} ? E : R extends ResultAsync<unknown, infer E> ? E : never;
-
-type PromiseFactory<T, E> = () => Promise<Result<T, E>>;
-type CombineTupleAsync<R extends readonly ResultAsync<unknown, unknown>[]> = ResultAsync<{
+type CombineTupleAsync<R extends readonly unknown[]> = R[number] extends AnyResultAsync ? ResultAsync<{
     [K in keyof R]: InferOk<R[K]>;
-}, {
-    [K in keyof R]: InferErr<R[K]>;
-}[number]>;
+}, InferErr<R[number]>> : never;
+/** Mirrors `TupleGuard` in `./collections.ts` — see the note there. */
+type AsyncTupleGuard<R extends readonly unknown[]> = R[number] extends AnyResultAsync ? [] : [error: "expected an array of ResultAsync values"];
 /**
  * Async railway carrier. Wraps a deferred `Promise<Result<T, E>>` and exposes
- * the same dual-track transforms as the sync {@link Result} — `map`, `flatMap`,
- * `recover`, `tap`, `match`. The public API never surfaces `Promise<Result<…>>`
+ * the same dual-track transforms as the sync {@link Result} — `map`, `mapErr`,
+ * `bimap`, `flatMap`, `recover`, `tap`, `match`. The public API never surfaces `Promise<Result<…>>`
  * directly: `await` the instance (it is thenable) or call {@link resolve} /
  * {@link match} to settle it.
  *
@@ -69,7 +38,7 @@ type CombineTupleAsync<R extends readonly ResultAsync<unknown, unknown>[]> = Res
  * const r = await user;          // Result<Profile, AppError>
  * ```
  */
-declare class ResultAsync<T, E> {
+export declare class ResultAsync<T, E> {
     protected readonly run: PromiseFactory<T, E>;
     private promise;
     protected constructor(run: PromiseFactory<T, E>);
@@ -129,13 +98,15 @@ declare class ResultAsync<T, E> {
      * const r = ResultAsync.ok(42);   // ResultAsync<number, never>
      * ```
      */
-    static ok<T>(value: T): ResultAsync<T, never>;
+    static ok<const T extends Payload[]>(value: T): ResultAsync<T, never>;
+    static ok<const T>(value: T): ResultAsync<T, never>;
     static ok<T, E>(value: T): ResultAsync<T, E>;
     /**
      * Fantasy Land `pure` — alias of {@link ResultAsync.ok}. One lift name
      * shared across the trio (`of` / `Maybe.of` / `ResultAsync.of`).
      */
-    static of<T>(value: T): ResultAsync<T, never>;
+    static of<const T extends Payload[]>(value: T): ResultAsync<T, never>;
+    static of<const T>(value: T): ResultAsync<T, never>;
     static of<T, E>(value: T): ResultAsync<T, E>;
     /**
      * Lifts an error into an `Err` async result.
@@ -145,7 +116,9 @@ declare class ResultAsync<T, E> {
      * const r = ResultAsync.err({ kind: "not_found" as const });
      * ```
      */
-    static err<T = never, E = unknown>(error: E): ResultAsync<T, E>;
+    static err<const E extends Payload[]>(error: E): ResultAsync<never, E>;
+    static err<const E>(error: E): ResultAsync<never, E>;
+    static err<T, E>(error: E): ResultAsync<T, E>;
     /**
      * Lifts an existing `Promise<Result<T, E>>` (e.g. from interop code) into a
      * {@link ResultAsync}. A thrown defect is routed through `onDefect`,
@@ -179,7 +152,7 @@ declare class ResultAsync<T, E> {
      *
      * @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)) {
@@ -187,7 +160,7 @@ declare class ResultAsync<T, E> {
      * }
      * ```
      */
-    static combineTuple<const R extends readonly ResultAsync<unknown, unknown>[]>(results: R): CombineTupleAsync<R>;
+    static combineTuple<const R extends readonly unknown[]>(results: R, ..._guard: AsyncTupleGuard<R>): CombineTupleAsync<R>;
     /**
      * Like {@link combineTuple}, but starts every branch before awaiting (wall-clock
      * parallel for independent IO). On failure, returns the first `Err` in input order.
@@ -198,10 +171,10 @@ declare class ResultAsync<T, E> {
      * const combined = ResultAsync.combineTupleParallel([
      *   loadProfile(id),
      *   loadMetrics(id),
-     * ] as const);
+     * ]);
      * ```
      */
-    static combineTupleParallel<const R extends readonly ResultAsync<unknown, unknown>[]>(results: R): CombineTupleAsync<R>;
+    static combineTupleParallel<const R extends readonly unknown[]>(results: R, ..._guard: AsyncTupleGuard<R>): CombineTupleAsync<R>;
     /**
      * Transforms the `Ok` value, passing `Err` through unchanged.
      *
@@ -221,6 +194,16 @@ declare class ResultAsync<T, E> {
      * ```
      */
     mapErr<F>(fn: (error: E) => F): ResultAsync<T, F>;
+    /**
+     * 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<U, F>(onOk: (value: T) => U, onErr: (error: E) => F): ResultAsync<U, F>;
     /**
      * Canonical bind — chains a step that itself returns a `ResultAsync` or sync
      * `Result`, short-circuiting on `Err`. Error types accumulate (`E | F`).
@@ -328,5 +311,9 @@ declare class ResultAsync<T, E> {
      */
     then<R1 = Result<T, E>, R2 = never>(onfulfilled?: ((value: Result<T, E>) => R1 | PromiseLike<R1>) | undefined | null, onrejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | undefined | null): Promise<R1 | R2>;
 }
-
-export { type InferErr as I, ResultAsync as R, type InferOk as a };
+export {};
+/**
+ * The free-function lift helpers (`okAsync`, `errAsync`, `fromPromise`,
+ * `fromSafePromise`, `fromResult`, `fromAsync`, `asyncAfter`, `tryAsync`)
+ * live in `./async-lift.ts` and are re-exported from the package index.
+ */

package/dist/collections.d.cts

@@ -0,0 +1,105 @@
+/**
+ * @onrails/result — sync aggregation, one module, two axes:
+ *
+ *   short-circuit (first `Err` wins)      — {@link combine} / {@link combineTuple}
+ *   accumulate expected failures          — {@link validateAll} / {@link validateTuple}
+ *
+ * The accumulate pair collects every failure into a readonly array by
+ * default, or folds them with an explicit `combineErrors` when given one.
+ */
+import type { InferErr, InferOk } from "./internal/infer.js";
+import type { Result } from "./types.js";
+/**
+ * Combines a homogeneous array of results into a single result holding an
+ * array of the `Ok` values, in input order. Short-circuits on the first `Err`
+ * (first failure wins). For heterogeneous tuples that preserve per-index
+ * types, use {@link combineTuple}.
+ *
+ * @example
+ * ```ts
+ * combine([ok(1), ok(2)]);        // Ok([1, 2])
+ * combine([ok(1), err("e")]);     // Err("e")
+ * ```
+ */
+export declare const combine: <T, E>(results: readonly Result<T, E>[]) => Result<T[], E>;
+type AnyResult = Result<unknown, unknown>;
+/** Positionally preserved `Ok` payloads for a tuple of results. */
+type OkTuple<R extends readonly unknown[]> = {
+    [K in keyof R]: InferOk<R[K]>;
+};
+/**
+ * The element check lives in the RETURN type, never in the parameter
+ * constraint. A `readonly Result<unknown, unknown>[]` constraint contextually
+ * types the arguments, which widens `ok(1)`'s defaulted `E = never` — and
+ * `err(e)`'s `T = never` — all the way to `unknown`. Holding the parameter at
+ * a bare `R` keeps both channels precise for inline literals, so call sites
+ * need neither `as const` nor hoisted intermediates.
+ */
+type CombineTuple<R extends readonly unknown[]> = R[number] extends AnyResult ? Result<OkTuple<R>, InferErr<R[number]>> : never;
+/**
+ * Restores the "every element is a Result" check the parameter constraint used
+ * to provide. Resolves to `[]` for a well-formed tuple and to a one-element
+ * tuple otherwise, so a bad call fails at the call site (with the message
+ * visible in signature help) instead of silently yielding `never`.
+ */
+type TupleGuard<R extends readonly unknown[]> = R[number] extends AnyResult ? [] : [error: "expected an array of Result values"];
+/**
+ * Heterogeneous tuple combine — like {@link combine} but preserves each
+ * branch's `Ok` type by position, so the result destructures type-safely.
+ * Short-circuits on the first `Err` in input order (neverthrow-style).
+ *
+ * @example
+ * ```ts
+ * const r = combineTuple([ok(1), ok("x")]);
+ * // Result<readonly [number, string], never> — no `as const` needed
+ * if (isOk(r)) {
+ *   const [n, s] = r.value;   // typed per position
+ * }
+ * ```
+ */
+export declare const combineTuple: <const R extends readonly unknown[]>(results: R, ..._guard: TupleGuard<R>) => CombineTuple<R>;
+/**
+ * Accumulate independent validation failures. Returns `Ok<T[]>` only when
+ * every input is `Ok`. Without a combiner, failures are collected into a
+ * readonly array; with `combineErrors` they are folded into a single `E`.
+ *
+ * Unlike {@link combine}, this does **not** short-circuit on first failure —
+ * use for independent checks where you want to report all problems at once.
+ *
+ * @example
+ * ```ts
+ * const checks: Result<string, string[]>[] = [ok("Ada"), err(["age required"])];
+ *
+ * validateAll(checks);
+ * // Result<string[], readonly string[][]>
+ *
+ * validateAll(checks, (left, right) => [...left, ...right]);
+ * // Result<string[], string[]>
+ * ```
+ */
+export declare function validateAll<T, E>(results: readonly Result<T, E>[]): Result<T[], readonly E[]>;
+export declare function validateAll<T, E>(results: readonly Result<T, E>[], combineErrors: (left: E, right: E) => E): Result<T[], E>;
+/**
+ * Tuple-preserving variant of {@link validateAll}. Heterogeneous input tuple
+ * → preserved `Ok` tuple shape. Without a combiner, the error union is
+ * collected into a readonly array; with `combineErrors`, all inputs must
+ * share the error type `E` and failures fold into a single `E`.
+ *
+ * Like {@link combineTuple}, the element check lives in the return type, so
+ * inline literals keep their precise error types without `as const`.
+ *
+ * @example
+ * ```ts
+ * const name: Result<string, string[]> = ok("Ada");
+ * const age: Result<number, string[]> = ok(36);
+ *
+ * validateTuple([name, age]);
+ * // Result<readonly [string, number], readonly string[][]>
+ *
+ * validateTuple([name, age], (l, r) => [...l, ...r]);
+ * // Result<readonly [string, number], string[]>
+ * ```
+ */
+export declare function validateTuple<const R extends readonly unknown[]>(results: R, ..._guard: TupleGuard<R>): R[number] extends AnyResult ? Result<OkTuple<R>, readonly InferErr<R[number]>[]> : never;
+export declare function validateTuple<const R extends readonly unknown[], E = InferErr<R[number]>>(results: R, combineErrors: (left: E, right: E) => E, ..._guard: TupleGuard<R>): R[number] extends AnyResult ? Result<OkTuple<R>, E> : never;
+export {};

package/dist/collections.d.ts

@@ -0,0 +1,105 @@
+/**
+ * @onrails/result — sync aggregation, one module, two axes:
+ *
+ *   short-circuit (first `Err` wins)      — {@link combine} / {@link combineTuple}
+ *   accumulate expected failures          — {@link validateAll} / {@link validateTuple}
+ *
+ * The accumulate pair collects every failure into a readonly array by
+ * default, or folds them with an explicit `combineErrors` when given one.
+ */
+import type { InferErr, InferOk } from "./internal/infer.js";
+import type { Result } from "./types.js";
+/**
+ * Combines a homogeneous array of results into a single result holding an
+ * array of the `Ok` values, in input order. Short-circuits on the first `Err`
+ * (first failure wins). For heterogeneous tuples that preserve per-index
+ * types, use {@link combineTuple}.
+ *
+ * @example
+ * ```ts
+ * combine([ok(1), ok(2)]);        // Ok([1, 2])
+ * combine([ok(1), err("e")]);     // Err("e")
+ * ```
+ */
+export declare const combine: <T, E>(results: readonly Result<T, E>[]) => Result<T[], E>;
+type AnyResult = Result<unknown, unknown>;
+/** Positionally preserved `Ok` payloads for a tuple of results. */
+type OkTuple<R extends readonly unknown[]> = {
+    [K in keyof R]: InferOk<R[K]>;
+};
+/**
+ * The element check lives in the RETURN type, never in the parameter
+ * constraint. A `readonly Result<unknown, unknown>[]` constraint contextually
+ * types the arguments, which widens `ok(1)`'s defaulted `E = never` — and
+ * `err(e)`'s `T = never` — all the way to `unknown`. Holding the parameter at
+ * a bare `R` keeps both channels precise for inline literals, so call sites
+ * need neither `as const` nor hoisted intermediates.
+ */
+type CombineTuple<R extends readonly unknown[]> = R[number] extends AnyResult ? Result<OkTuple<R>, InferErr<R[number]>> : never;
+/**
+ * Restores the "every element is a Result" check the parameter constraint used
+ * to provide. Resolves to `[]` for a well-formed tuple and to a one-element
+ * tuple otherwise, so a bad call fails at the call site (with the message
+ * visible in signature help) instead of silently yielding `never`.
+ */
+type TupleGuard<R extends readonly unknown[]> = R[number] extends AnyResult ? [] : [error: "expected an array of Result values"];
+/**
+ * Heterogeneous tuple combine — like {@link combine} but preserves each
+ * branch's `Ok` type by position, so the result destructures type-safely.
+ * Short-circuits on the first `Err` in input order (neverthrow-style).
+ *
+ * @example
+ * ```ts
+ * const r = combineTuple([ok(1), ok("x")]);
+ * // Result<readonly [number, string], never> — no `as const` needed
+ * if (isOk(r)) {
+ *   const [n, s] = r.value;   // typed per position
+ * }
+ * ```
+ */
+export declare const combineTuple: <const R extends readonly unknown[]>(results: R, ..._guard: TupleGuard<R>) => CombineTuple<R>;
+/**
+ * Accumulate independent validation failures. Returns `Ok<T[]>` only when
+ * every input is `Ok`. Without a combiner, failures are collected into a
+ * readonly array; with `combineErrors` they are folded into a single `E`.
+ *
+ * Unlike {@link combine}, this does **not** short-circuit on first failure —
+ * use for independent checks where you want to report all problems at once.
+ *
+ * @example
+ * ```ts
+ * const checks: Result<string, string[]>[] = [ok("Ada"), err(["age required"])];
+ *
+ * validateAll(checks);
+ * // Result<string[], readonly string[][]>
+ *
+ * validateAll(checks, (left, right) => [...left, ...right]);
+ * // Result<string[], string[]>
+ * ```
+ */
+export declare function validateAll<T, E>(results: readonly Result<T, E>[]): Result<T[], readonly E[]>;
+export declare function validateAll<T, E>(results: readonly Result<T, E>[], combineErrors: (left: E, right: E) => E): Result<T[], E>;
+/**
+ * Tuple-preserving variant of {@link validateAll}. Heterogeneous input tuple
+ * → preserved `Ok` tuple shape. Without a combiner, the error union is
+ * collected into a readonly array; with `combineErrors`, all inputs must
+ * share the error type `E` and failures fold into a single `E`.
+ *
+ * Like {@link combineTuple}, the element check lives in the return type, so
+ * inline literals keep their precise error types without `as const`.
+ *
+ * @example
+ * ```ts
+ * const name: Result<string, string[]> = ok("Ada");
+ * const age: Result<number, string[]> = ok(36);
+ *
+ * validateTuple([name, age]);
+ * // Result<readonly [string, number], readonly string[][]>
+ *
+ * validateTuple([name, age], (l, r) => [...l, ...r]);
+ * // Result<readonly [string, number], string[]>
+ * ```
+ */
+export declare function validateTuple<const R extends readonly unknown[]>(results: R, ..._guard: TupleGuard<R>): R[number] extends AnyResult ? Result<OkTuple<R>, readonly InferErr<R[number]>[]> : never;
+export declare function validateTuple<const R extends readonly unknown[], E = InferErr<R[number]>>(results: R, combineErrors: (left: E, right: E) => E, ..._guard: TupleGuard<R>): R[number] extends AnyResult ? Result<OkTuple<R>, E> : never;
+export {};

package/dist/compat/neverthrow.cjs

@@ -1,5 +1,15 @@
 'use strict';
 
+// 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;
@@ -8,38 +18,34 @@ 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)
 );
 var unwrapOr = dual(
   2,
   (result, defaultValue) => isOk(result) ? result.value : defaultValue
 );
-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));
     }
   };
 }
@@ -59,11 +65,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) {
@@ -100,9 +106,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));
       }
     });
   }
@@ -116,7 +122,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
@@ -134,21 +140,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
@@ -166,7 +164,7 @@ var ResultAsync = class _ResultAsync {
       try {
         return await promise;
       } catch (error) {
-        return err(mapDefect(error));
+        return mkErr(mapDefect(error));
       }
     });
   }
@@ -188,11 +186,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);
     });
   }
   /**
@@ -204,7 +202,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)) {
@@ -212,7 +210,7 @@ var ResultAsync = class _ResultAsync {
    * }
    * ```
    */
-  static combineTuple(results) {
+  static combineTuple(results, ..._guard) {
     return _ResultAsync.combine(
       results
     );
@@ -227,12 +225,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()))
+      )
     );
   }
   /**
@@ -258,6 +258,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`).
@@ -426,12 +438,12 @@ var ResultAsync = class _ResultAsync {
 var combine = (results) => {
   const values = [];
   for (const result of results) {
-    if (isErr(result)) return err(result.error);
+    if (isErr(result)) return mkErr(result.error);
     values.push(result.value);
   }
-  return ok(values);
+  return mkOk(values);
 };
-var combineTuple = (results) => (
+var combineTuple = (results, ..._guard) => (
   // Runtime identical to combine; the cast restores per-index tuple types.
   combine(results)
 );
@@ -443,7 +455,7 @@ var CompatResult = class _CompatResult {
   }
   inner;
   static fromThrowable(fn, onThrow) {
-    const wrapped = trySync(fn, onThrow);
+    const wrapped = fromThrowable(fn, onThrow);
     return (...args) => new _CompatResult(wrapped(...args));
   }
   static combine(results) {
@@ -498,8 +510,8 @@ var CompatResult = class _CompatResult {
   }
 };
 var Result = CompatResult;
-var ok2 = (value) => new CompatResult(ok(value));
-var err2 = (error) => new CompatResult(err(error));
+var ok = (value) => new CompatResult(mkOk(value));
+var err = (error) => new CompatResult(mkErr(error));
 var CompatResultAsync = class _CompatResultAsync {
   constructor(inner) {
     this.inner = inner;
@@ -626,11 +638,11 @@ exports.CompatResult = CompatResult;
 exports.CompatResultAsync = CompatResultAsync;
 exports.Result = Result;
 exports.ResultAsync = CompatResultAsync;
-exports.err = err2;
+exports.err = err;
 exports.errAsync = errAsync;
 exports.fromPromise = fromPromise;
 exports.fromSafePromise = fromSafePromise;
-exports.ok = ok2;
+exports.ok = ok;
 exports.okAsync = okAsync;
 //# sourceMappingURL=neverthrow.cjs.map
 //# sourceMappingURL=neverthrow.cjs.map