@onrails/result 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,10 +1,15 @@
-import { R as ResultAsync } from './async-1fIhfzFu.js';
-import { R as Result, E as Err, O as Ok } from './types-BQ9vv0nD.js';
-export { U as UnexpectedError } from './types-BQ9vv0nD.js';
-export { InferErr, InferOk, asyncAfter, fromAsync, fromResult } from './interop.js';
+import { R as ResultAsync, I as InferErr, a as InferOk } from './async-SZ7BEl0g.js';
+import { R as Result, U as UnexpectedError, E as Err, O as Ok } from './types-BQ9vv0nD.js';
 export { flow } from './pipe.js';
 export { $, tryGen, yieldResult } from './try-gen.js';
 
+/**
+ * @onrails/result — THE lift module. Every "value → {@link ResultAsync}"
+ * entry point is defined exactly once, here: `okAsync`, `errAsync`,
+ * `fromPromise`, `fromSafePromise`, `fromResult`, `fromAsync`, `asyncAfter`,
+ * `tryAsync`.
+ */
+
 /**
  * Lifts a value into an `Ok` async result.
  *
@@ -42,20 +47,49 @@ declare const fromPromise: typeof ResultAsync.fromPromise;
  */
 declare const fromSafePromise: typeof ResultAsync.fromSafePromise;
 /**
- * Heterogeneous async tuple combine — branches overlap in wall-clock time.
- * Returns the first `Err` in **input** order (not completion order).
+ * Lifts an already-settled sync {@link Result} into a {@link ResultAsync}, so
+ * it can be chained alongside async steps in a railway.
+ *
+ * @example
+ * ```ts
+ * const ra = fromResult(ok(1));            // ResultAsync<number, never>
+ * await fromResult(err(error)).resolve();  // Err(error)
+ * ```
+ */
+declare const fromResult: typeof ResultAsync.fromResult;
+/**
+ * Bind a sync {@link Result} into an async step without widening defects.
+ * Dual-form: data-first for one-shots, data-last (curried) for `pipe`/`flow`.
  *
  * @example
  * ```ts
- * const combined = parallelTupleAsync([
- *   loadProfile(id),
- *   loadMetrics(id),
- *   loadFlags(id),
- * ] as const);
- * // ResultAsync<readonly [Profile, Metrics, Flags], …>
+ * asyncAfter(result, (u) => tryAsync(db.insert(u), toErr)); // data-first
+ * asyncAfter((u) => tryAsync(db.insert(u), toErr));         // data-last
  * ```
  */
-declare const parallelTupleAsync: typeof ResultAsync.combineTupleParallel;
+declare const asyncAfter: {
+    <T, U, E, F>(result: Result<T, E>, fn: (value: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
+    <T, U, F>(fn: (value: T) => ResultAsync<U, F>): <E>(result: Result<T, E>) => ResultAsync<U, E | F>;
+};
+type AnyResult = Result<unknown, unknown>;
+/**
+ * Lifts a `(...args) => Promise<Result<T, E>>` function (typical of interop or
+ * boundary code) into one returning `(...args) => ResultAsync<T, E>`. Expected
+ * `Err`s pass through; an unexpected promise rejection (a defect) is routed via
+ * `onDefect`, defaulting to {@link UnexpectedError} and widening the error union.
+ *
+ * @param fn - a function returning a promise that already yields a `Result`
+ * @param onDefect - maps an unexpected rejection to the `Err` channel
+ *
+ * @example
+ * ```ts
+ * const loadUser = fromAsync(
+ *   (id: string): Promise<Result<User, NotFound>> => api.getUser(id),
+ * );
+ * const ra = loadUser("u1");   // ResultAsync<User, NotFound | UnexpectedError>
+ * ```
+ */
+declare const fromAsync: <A extends readonly unknown[], R extends AnyResult>(fn: (...args: A) => Promise<R>, onDefect?: (error: unknown) => InferErr<R> | UnexpectedError) => ((...args: A) => ResultAsync<InferOk<R>, InferErr<R> | UnexpectedError>);
 /**
  * Convenience wrapper over {@link fromPromise} with default `Error`
  * normalization. Call without `onReject` to get `ResultAsync<T, Error>`,
@@ -76,6 +110,16 @@ declare const parallelTupleAsync: typeof ResultAsync.combineTupleParallel;
 declare function tryAsync<T>(promise: PromiseLike<T>): ResultAsync<T, Error>;
 declare function tryAsync<T, E>(promise: PromiseLike<T>, onReject: (error: unknown) => E): ResultAsync<T, E>;
 
+/**
+ * @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.
+ */
+
 /**
  * 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`
@@ -89,6 +133,11 @@ declare function tryAsync<T, E>(promise: PromiseLike<T>, onReject: (error: unkno
  * ```
  */
 declare const combine: <T, E>(results: readonly Result<T, E>[]) => Result<T[], E>;
+type CombineTuple<R extends readonly Result<unknown, unknown>[]> = Result<{
+    [K in keyof R]: InferOk<R[K]>;
+}, {
+    [K in keyof R]: InferErr<R[K]>;
+}[number]>;
 /**
  * Heterogeneous tuple combine — like {@link combine} but preserves each
  * branch's `Ok` type by position, so the result destructures type-safely.
@@ -104,19 +153,51 @@ declare const combine: <T, E>(results: readonly Result<T, E>[]) => Result<T[], E
  * ```
  */
 declare const combineTuple: <const R extends readonly Result<unknown, unknown>[]>(results: R) => CombineTuple<R>;
-type _OkValue<R> = R extends {
-    _tag: "Ok";
-    readonly value: infer T;
-} ? T : never;
-type _ErrValue<R> = R extends {
-    _tag: "Err";
-    readonly error: infer E;
-} ? E : never;
-type CombineTuple<R extends readonly Result<unknown, unknown>[]> = Result<{
-    [K in keyof R]: _OkValue<R[K]>;
-}, {
-    [K in keyof R]: _ErrValue<R[K]>;
-}[number]>;
+/**
+ * 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[]>
+ * ```
+ */
+declare function validateAll<T, E>(results: readonly Result<T, E>[]): Result<T[], readonly E[]>;
+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`.
+ *
+ * @example
+ * ```ts
+ * const name: Result<string, string[]> = ok("Ada");
+ * const age: Result<number, string[]> = ok(36);
+ *
+ * validateTuple([name, age] as const);
+ * // Result<readonly [string, number], readonly string[][]>
+ *
+ * validateTuple([name, age] as const, (l, r) => [...l, ...r]);
+ * // Result<readonly [string, number], string[]>
+ * ```
+ */
+declare function validateTuple<const R extends readonly Result<unknown, unknown>[]>(results: R): Result<{
+    [K in keyof R]: InferOk<R[K]>;
+}, readonly InferErr<R[number]>[]>;
+declare function validateTuple<const R extends readonly Result<unknown, unknown>[], E = InferErr<R[number]>>(results: R & readonly Result<unknown, E>[], combineErrors: (left: E, right: E) => E): Result<{
+    [K in keyof R]: InferOk<R[K]>;
+}, E>;
 
 /**
  * Lifts a value into the success track.
@@ -170,8 +251,10 @@ declare const isErr: <T, E>(result: Result<T, E>) => result is Err<T, E>;
  * pipe(ok("x"), map((s) => s.length));// Ok 1 — curried
  * ```
  */
-declare function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
-declare function map<T, U>(fn: (value: T) => U): <E>(result: Result<T, E>) => Result<U, E>;
+declare const map: {
+    <T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+    <T, U>(fn: (value: T) => U): <E>(result: Result<T, E>) => Result<U, E>;
+};
 /**
  * Transform the `Err` value, passing `Ok` through unchanged. Useful for
  * unifying heterogeneous failure types into one app-level union.
@@ -185,8 +268,10 @@ declare function map<T, U>(fn: (value: T) => U): <E>(result: Result<T, E>) => Re
  * );
  * ```
  */
-declare function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
-declare function mapErr<E, F>(fn: (error: E) => F): <T>(result: Result<T, E>) => Result<T, F>;
+declare const mapErr: {
+    <T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
+    <E, F>(fn: (error: E) => F): <T>(result: Result<T, E>) => Result<T, F>;
+};
 /**
  * Transform both tracks at once — `Ok` via `onOk`, `Err` via `onErr`.
  * Equivalent to `mapErr(onErr)(map(onOk)(result))` but in one pass.
@@ -196,8 +281,10 @@ declare function mapErr<E, F>(fn: (error: E) => F): <T>(result: Result<T, E>) =>
  * bimap(parsed, (cfg) => cfg.name, (e) => ({ kind: "input", cause: e }));
  * ```
  */
-declare function bimap<T, U, E, F>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => F): Result<U, F>;
-declare function bimap<T, U, E, F>(onOk: (value: T) => U, onErr: (error: E) => F): (result: Result<T, E>) => Result<U, F>;
+declare const bimap: {
+    <T, U, E, F>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => F): Result<U, F>;
+    <T, U, E, F>(onOk: (value: T) => U, onErr: (error: E) => F): (result: Result<T, E>) => Result<U, F>;
+};
 /**
  * Canonical bind (Fantasy Land `chain`). Chains a Result-returning step,
  * widening the error union to `E | F`. Short-circuits on `Err`.
@@ -210,8 +297,10 @@ declare function bimap<T, U, E, F>(onOk: (value: T) => U, onErr: (error: E) => F
  * // Result<Data, ParseError | { kind: "missing_id" }>
  * ```
  */
-declare function flatMap<T, U, E, F>(result: Result<T, E>, fn: (value: T) => Result<U, F>): Result<U, E | F>;
-declare function flatMap<T, U, F>(fn: (value: T) => Result<U, F>): <E>(result: Result<T, E>) => Result<U, E | F>;
+declare const flatMap: {
+    <T, U, E, F>(result: Result<T, E>, fn: (value: T) => Result<U, F>): Result<U, E | F>;
+    <T, U, F>(fn: (value: T) => Result<U, F>): <E>(result: Result<T, E>) => Result<U, E | F>;
+};
 /**
  * Error-track bind — runs `fn` only when the result is `Err`, allowing
  * a failed workflow to recover to `Ok` or remap the failure. Mirror of
@@ -224,8 +313,10 @@ declare function flatMap<T, U, F>(fn: (value: T) => Result<U, F>): <E>(result: R
  * );
  * ```
  */
-declare function recover<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F>;
-declare function recover<T, E, F>(fn: (error: E) => Result<T, F>): (result: Result<T, E>) => Result<T, F>;
+declare const recover: {
+    <T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F>;
+    <T, E, F>(fn: (error: E) => Result<T, F>): (result: Result<T, E>) => Result<T, F>;
+};
 /**
  * Observe the `Ok` value for side effects (logging, metrics) without
  * changing the carried value. Passes `Err` through untouched.
@@ -239,8 +330,10 @@ declare function recover<T, E, F>(fn: (error: E) => Result<T, F>): (result: Resu
  * );
  * ```
  */
-declare function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;
-declare function tap<T>(fn: (value: T) => void): <E>(result: Result<T, E>) => Result<T, E>;
+declare const tap: {
+    <T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;
+    <T>(fn: (value: T) => void): <E>(result: Result<T, E>) => Result<T, E>;
+};
 /**
  * Observe the `Err` value for side effects (logging, metrics) without
  * changing the carried error. Passes `Ok` through untouched.
@@ -253,8 +346,10 @@ declare function tap<T>(fn: (value: T) => void): <E>(result: Result<T, E>) => Re
  * );
  * ```
  */
-declare function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;
-declare function tapErr<E>(fn: (error: E) => void): <T>(result: Result<T, E>) => Result<T, E>;
+declare const tapErr: {
+    <T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;
+    <E>(fn: (error: E) => void): <T>(result: Result<T, E>) => Result<T, E>;
+};
 /**
  * Terminal collapse — fold both tracks into a single value. Dual-form:
  * 3-args data-first, 2-args curried for {@link pipe}. Returns whatever
@@ -269,8 +364,10 @@ declare function tapErr<E>(fn: (error: E) => void): <T>(result: Result<T, E>) =>
  * const html = match(parsed, (cfg) => render(cfg), (e) => renderError(e));
  * ```
  */
-declare function match<T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U;
-declare function match<T, E, U>(onOk: (value: T) => U, onErr: (error: E) => U): (result: Result<T, E>) => U;
+declare const match: {
+    <T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U;
+    <T, E, U>(onOk: (value: T) => U, onErr: (error: E) => U): (result: Result<T, E>) => U;
+};
 /**
  * Returns the `Ok` value, or `defaultValue` when the result is `Err`.
  *
@@ -279,7 +376,10 @@ declare function match<T, E, U>(onOk: (value: T) => U, onErr: (error: E) => U):
  * unwrapOr(parsedSetting, "default-value");
  * ```
  */
-declare const unwrapOr: <T, E>(result: Result<T, E>, defaultValue: T) => T;
+declare const unwrapOr: {
+    <T, E>(result: Result<T, E>, defaultValue: T): T;
+    <T>(defaultValue: T): <E>(result: Result<T, E>) => T;
+};
 /**
  * Test/assert helper — returns the `Ok` value, or **throws the original `Err`
  * value** when called on an `Err`. This is the assertion tier (RFC 0001 §4):
@@ -298,6 +398,8 @@ declare const unwrapOr: <T, E>(result: Result<T, E>, defaultValue: T) => T;
  * ```
  */
 declare function unwrapOk<T, E>(result: Result<T, E>): T;
+/** Alias of {@link unwrapOk} for syntax cohesion with `@onrails/maybe`. */
+declare const unwrap: typeof unwrapOk;
 /**
  * Test/assert helper — returns the `Err` value, or **throws a `TypeError`**
  * when called on an `Ok`. Mirror of {@link unwrapOk} on the error track and
@@ -364,4 +466,4 @@ declare function pipe<A, B, C, D, E, F, G>(value: A, ab: (a: A) => B, bc: (b: B)
 declare function pipe<A, B, C, D, E, F, G, H>(value: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): H;
 declare function pipe<A, B, C, D, E, F, G, H, I>(value: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): I;
 
-export { Err, Ok, Result, ResultAsync, bimap, combine, combineTuple, err, errAsync, flatMap, fromPromise, fromSafePromise, isErr, isOk, map, mapErr, match, ok, okAsync, parallelTupleAsync, pipe, recover, tap, tapErr, tryAsync, trySync, unwrapErr, unwrapOk, unwrapOr };
+export { Err, InferErr, InferOk, Ok, Result, ResultAsync, UnexpectedError, asyncAfter, bimap, combine, combineTuple, err, errAsync, flatMap, fromAsync, fromPromise, fromResult, fromSafePromise, isErr, isOk, map, mapErr, match, ok, okAsync, pipe, recover, tap, tapErr, tryAsync, trySync, unwrap, unwrapErr, unwrapOk, unwrapOr, validateAll, validateTuple };

package/dist/index.js

@@ -1,3 +1,10 @@
+// src/internal/dual.ts
+var dual = (arity, body) => {
+  const run = body;
+  const dispatcher = (...args) => args.length >= arity ? run(...args) : (self) => run(self, ...args);
+  return dispatcher;
+};
+
 // src/result.ts
 var ok = (value) => ({
   _tag: "Ok",
@@ -9,65 +16,47 @@ var err = (error) => ({
 });
 var isOk = (result) => result._tag === "Ok";
 var isErr = (result) => result._tag === "Err";
-var mapImpl = (result, fn) => isOk(result) ? ok(fn(result.value)) : err(result.error);
-function map(...args) {
-  if (args.length === 2) return mapImpl(args[0], args[1]);
-  const fn = args[0];
-  return (result) => mapImpl(result, fn);
-}
-var mapErrImpl = (result, fn) => isErr(result) ? err(fn(result.error)) : ok(result.value);
-function mapErr(...args) {
-  if (args.length === 2) return mapErrImpl(args[0], args[1]);
-  const fn = args[0];
-  return (result) => mapErrImpl(result, fn);
-}
-var bimapImpl = (result, onOk, onErr) => isOk(result) ? ok(onOk(result.value)) : err(onErr(result.error));
-function bimap(...args) {
-  if (args.length === 3) return bimapImpl(args[0], args[1], args[2]);
-  const [onOk, onErr] = args;
-  return (result) => bimapImpl(result, onOk, onErr);
-}
-var flatMapImpl = (result, fn) => isOk(result) ? fn(result.value) : err(result.error);
-function flatMap(...args) {
-  if (args.length === 2) return flatMapImpl(args[0], args[1]);
-  const fn = args[0];
-  return (result) => flatMapImpl(result, fn);
-}
-var recoverImpl = (result, fn) => isErr(result) ? fn(result.error) : ok(result.value);
-function recover(...args) {
-  if (args.length === 2) return recoverImpl(args[0], args[1]);
-  const fn = args[0];
-  return (result) => recoverImpl(result, fn);
-}
-var tapImpl = (result, fn) => {
+var map = dual(
+  2,
+  (result, fn) => isOk(result) ? ok(fn(result.value)) : err(result.error)
+);
+var mapErr = dual(
+  2,
+  (result, fn) => isErr(result) ? err(fn(result.error)) : ok(result.value)
+);
+var bimap = dual(
+  3,
+  (result, onOk, onErr) => isOk(result) ? ok(onOk(result.value)) : err(onErr(result.error))
+);
+var flatMap = dual(
+  2,
+  (result, fn) => isOk(result) ? fn(result.value) : err(result.error)
+);
+var recover = dual(
+  2,
+  (result, fn) => isErr(result) ? fn(result.error) : ok(result.value)
+);
+var tap = dual(2, (result, fn) => {
   if (isOk(result)) fn(result.value);
   return result;
-};
-function tap(...args) {
-  if (args.length === 2) return tapImpl(args[0], args[1]);
-  const fn = args[0];
-  return (result) => tapImpl(result, fn);
-}
-var tapErrImpl = (result, fn) => {
+});
+var tapErr = dual(2, (result, fn) => {
   if (isErr(result)) fn(result.error);
   return result;
-};
-function tapErr(...args) {
-  if (args.length === 2) return tapErrImpl(args[0], args[1]);
-  const fn = args[0];
-  return (result) => tapErrImpl(result, fn);
-}
-var matchImpl = (result, onOk, onErr) => isOk(result) ? onOk(result.value) : onErr(result.error);
-function match(...args) {
-  if (args.length === 3) return matchImpl(args[0], args[1], args[2]);
-  const [onOk, onErr] = args;
-  return (result) => matchImpl(result, onOk, onErr);
-}
-var unwrapOr = (result, defaultValue) => isOk(result) ? result.value : defaultValue;
+});
+var match = dual(
+  3,
+  (result, onOk, onErr) => isOk(result) ? onOk(result.value) : onErr(result.error)
+);
+var unwrapOr = dual(
+  2,
+  (result, defaultValue) => isOk(result) ? result.value : defaultValue
+);
 function unwrapOk(result) {
   if (isErr(result)) throw result.error;
   return result.value;
 }
+var unwrap = unwrapOk;
 function unwrapErr(result) {
   if (isOk(result)) throw new TypeError("unwrapErr called on Ok");
   return result.error;
@@ -100,17 +89,6 @@ var UnexpectedError = class extends Error {
 };
 
 // src/async.ts
-var liftPromiseResult = async (promise, onDefect) => {
-  try {
-    const result = await promise;
-    if (isErr(result)) {
-      return result;
-    }
-    return isResultLike(result.value) ? result.value : result;
-  } catch (error) {
-    return err(onDefect(error));
-  }
-};
 var sequenceSettled = (settled) => {
   const values = [];
   for (const result of settled) {
@@ -205,16 +183,23 @@ var ResultAsync = class _ResultAsync {
   }
   /**
    * Lifts an existing `Promise<Result<T, E>>` (e.g. from interop code) into a
-   * {@link ResultAsync}, auto-flattening one level of double-wrapping. A thrown
-   * defect is routed through `onDefect`, defaulting to {@link UnexpectedError}.
+   * {@link ResultAsync}. A thrown defect is routed through `onDefect`,
+   * defaulting to {@link UnexpectedError}. The `Ok` value passes through
+   * verbatim — even when it happens to be Result-shaped.
    *
    * @param promise - a promise that already yields a `Result`
    * @param onDefect - maps an unexpected throw to the `Err` channel
-   * @see {@link fromAsync} from `@onrails/result/interop`
+   * @see {@link fromAsync} from `@onrails/result`
    */
   static fromResultPromise(promise, onDefect) {
     const mapDefect = onDefect ?? ((error) => new UnexpectedError("Unexpected async defect", error));
-    return new _ResultAsync(() => liftPromiseResult(promise, mapDefect));
+    return new _ResultAsync(async () => {
+      try {
+        return await promise;
+      } catch (error) {
+        return err(mapDefect(error));
+      }
+    });
   }
   /**
    * Combines a homogeneous array of async results into one. Resolves
@@ -298,7 +283,7 @@ var ResultAsync = class _ResultAsync {
    *
    * @example
    * ```ts
-   * load(id).mapErr((e): AppError => ({ kind: "load", cause: e }));
+   * load(id).mapErr((e): AppError => ({ kind: "load", cause: e })); // ResultAsync<T, AppError>
    * ```
    */
   mapErr(fn) {
@@ -322,18 +307,12 @@ var ResultAsync = class _ResultAsync {
         return first;
       }
       const next = fn(first.value);
-      if (next instanceof _ResultAsync) {
-        return next.resolve();
-      }
-      if (isResultLike(next)) {
-        return next;
-      }
-      return isCompatLike(next) ? next.inner : next;
+      return next instanceof _ResultAsync ? next.resolve() : next;
     });
   }
   /**
    * neverthrow-compat alias of {@link flatMap}. Kept as the documented compat
-   * tier; prefer `flatMap` in new code.
+   * tier; prefer {@link flatMap} in new code.
    *
    * @example
    * ```ts
@@ -350,7 +329,7 @@ var ResultAsync = class _ResultAsync {
    *
    * @example
    * ```ts
-   * loadFromCache(id).recover(() => loadFromOrigin(id));
+   * loadFromCache(id).recover(() => loadFromOrigin(id)); // ResultAsync<T, F>
    * ```
    */
   recover(fn) {
@@ -365,7 +344,7 @@ var ResultAsync = class _ResultAsync {
   }
   /**
    * neverthrow-compat alias of {@link recover}. Kept as the documented compat
-   * tier; prefer `recover` in new code.
+   * tier; prefer {@link recover} in new code.
    *
    * @example
    * ```ts
@@ -473,19 +452,18 @@ var ResultAsync = class _ResultAsync {
     );
   }
 };
-function isResultLike(v) {
-  return typeof v === "object" && v !== null && "_tag" in v && (v._tag === "Ok" || v._tag === "Err");
-}
-function isCompatLike(v) {
-  return typeof v === "object" && v !== null && "inner" in v && isResultLike(v.inner);
-}
 
 // src/async-lift.ts
 var okAsync = ResultAsync.ok;
 var errAsync = ResultAsync.err;
 var fromPromise = ResultAsync.fromPromise;
 var fromSafePromise = ResultAsync.fromSafePromise;
-var parallelTupleAsync = ResultAsync.combineTupleParallel;
+var fromResult = ResultAsync.fromResult;
+var asyncAfter = dual(
+  2,
+  (result, fn) => fromResult(result).flatMap(fn)
+);
+var fromAsync = (fn, onDefect) => (...args) => ResultAsync.fromResultPromise(fn(...args), onDefect);
 var toError = (error) => error instanceof Error ? error : new Error(String(error));
 function tryAsync(promise, onReject) {
   return onReject ? ResultAsync.fromPromise(promise, onReject) : ResultAsync.fromPromise(promise, toError);
@@ -504,17 +482,22 @@ var combineTuple = (results) => (
   // Runtime identical to combine; the cast restores per-index tuple types.
   combine(results)
 );
-
-// src/interop.ts
-var fromResult = (result) => ResultAsync.fromResult(result);
-function asyncAfter(resultOrFn, fn) {
-  if (fn === void 0) {
-    const f = resultOrFn;
-    return (result) => fromResult(result).flatMap(f);
+function validateAll(results, combineErrors) {
+  const values = [];
+  const errors = [];
+  for (const result of results) {
+    if (isErr(result)) {
+      errors.push(result.error);
+    } else {
+      values.push(result.value);
+    }
   }
-  return fromResult(resultOrFn).flatMap(fn);
+  if (errors.length === 0) return ok(values);
+  return err(combineErrors ? errors.reduce(combineErrors) : errors);
+}
+function validateTuple(results, combineErrors) {
+  return combineErrors ? validateAll(results, combineErrors) : validateAll(results);
 }
-var fromAsync = (fn, onDefect) => (...args) => ResultAsync.fromResultPromise(fn(...args), onDefect);
 
 // src/pipe.ts
 function flow(first, ...rest) {
@@ -553,6 +536,6 @@ var tryGen = (fn) => {
   }
 };
 
-export { $, ResultAsync, asyncAfter, bimap, combine, combineTuple, err, errAsync, flatMap, flow, fromAsync, fromPromise, fromResult, fromSafePromise, isErr, isOk, map, mapErr, match, ok, okAsync, parallelTupleAsync, pipe, recover, tap, tapErr, tryAsync, tryGen, trySync, unwrapErr, unwrapOk, unwrapOr, yieldResult };
+export { $, ResultAsync, UnexpectedError, asyncAfter, bimap, combine, combineTuple, err, errAsync, flatMap, flow, fromAsync, fromPromise, fromResult, fromSafePromise, isErr, isOk, map, mapErr, match, ok, okAsync, pipe, recover, tap, tapErr, tryAsync, tryGen, trySync, unwrap, unwrapErr, unwrapOk, unwrapOr, validateAll, validateTuple, yieldResult };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map