@onrails/result 0.3.1 → 0.4.1

package/dist/internal/ctor.d.ts

@@ -0,0 +1,12 @@
+import type { Result } from "../types.js";
+/**
+ * Unlocked `Ok` constructor for library internals.
+ *
+ * The public {@link ok} takes a `const` type parameter so caller literals stay
+ * narrow. That is wrong inside a generic transform, where the payload type is
+ * an unresolved type parameter and the resulting `Locked<T>` would never reduce
+ * back to `T`. Internals build results through this constructor instead.
+ */
+export declare const mkOk: <T, E = never>(value: T) => Result<T, E>;
+/** Unlocked `Err` constructor for library internals. Mirror of {@link mkOk}. */
+export declare const mkErr: <T = never, E = unknown>(error: E) => Result<T, E>;

package/dist/internal/dual.d.cts

@@ -0,0 +1,42 @@
+/**
+ * @onrails/result internal — owning module for the **dual-form idiom**.
+ *
+ * Every dual-form transform in this package (`map`, `flatMap`, `match`, …)
+ * accepts either shape:
+ *
+ *   data-first: `map(result, fn)`  — full arity, runs immediately
+ *   curried:    `map(fn)(result)`  — arity minus the leading `self`, returns
+ *                                    a unary function awaiting the data
+ *
+ * {@link dual} is the single arity dispatcher those transforms derive from;
+ * hand-rolled `args.length` checks are not allowed elsewhere.
+ *
+ * NOTE: a twin copy of this module lives at `packages/maybe/src/internal/dual.ts`
+ * — keep the two in sync when editing.
+ *
+ * Internal only: not listed in package.json `exports` or tsup entries.
+ */
+/**
+ * Derive a dual-form (data-first / curried) function from a single
+ * data-first `body`.
+ *
+ * When called with `args.length >= arity` the wrapper runs `body(...args)`
+ * (data-first). With fewer arguments it returns `(self) => body(self, ...args)`
+ * — the curried, data-last-`self` form used with `pipe`/`flow`.
+ *
+ * The public type is supplied entirely by the caller: annotate the exported
+ * const with the exact overload set and let `F` be inferred from it.
+ *
+ * @example
+ * ```ts
+ * export 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>;
+ * } = dual(
+ *   2,
+ *   <T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> =>
+ *     isOk(result) ? ok(fn(result.value)) : err(result.error),
+ * );
+ * ```
+ */
+export declare const dual: <F>(arity: number, body: (...args: never[]) => unknown) => F;

package/dist/internal/dual.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @onrails/result internal — owning module for the **dual-form idiom**.
+ *
+ * Every dual-form transform in this package (`map`, `flatMap`, `match`, …)
+ * accepts either shape:
+ *
+ *   data-first: `map(result, fn)`  — full arity, runs immediately
+ *   curried:    `map(fn)(result)`  — arity minus the leading `self`, returns
+ *                                    a unary function awaiting the data
+ *
+ * {@link dual} is the single arity dispatcher those transforms derive from;
+ * hand-rolled `args.length` checks are not allowed elsewhere.
+ *
+ * NOTE: a twin copy of this module lives at `packages/maybe/src/internal/dual.ts`
+ * — keep the two in sync when editing.
+ *
+ * Internal only: not listed in package.json `exports` or tsup entries.
+ */
+/**
+ * Derive a dual-form (data-first / curried) function from a single
+ * data-first `body`.
+ *
+ * When called with `args.length >= arity` the wrapper runs `body(...args)`
+ * (data-first). With fewer arguments it returns `(self) => body(self, ...args)`
+ * — the curried, data-last-`self` form used with `pipe`/`flow`.
+ *
+ * The public type is supplied entirely by the caller: annotate the exported
+ * const with the exact overload set and let `F` be inferred from it.
+ *
+ * @example
+ * ```ts
+ * export 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>;
+ * } = dual(
+ *   2,
+ *   <T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> =>
+ *     isOk(result) ? ok(fn(result.value)) : err(result.error),
+ * );
+ * ```
+ */
+export declare const dual: <F>(arity: number, body: (...args: never[]) => unknown) => F;

package/dist/internal/infer.d.cts

@@ -0,0 +1,40 @@
+/**
+ * @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.
+ */
+import type { ResultAsync } from "../async.js";
+/**
+ * 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
+ * ```
+ */
+export type InferOk<R> = R extends {
+    _tag: "Ok";
+    readonly value: infer T;
+} ? T : R extends ResultAsync<infer T, unknown> ? T : never;
+/**
+ * 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
+ * ```
+ */
+export type InferErr<R> = R extends {
+    _tag: "Err";
+    readonly error: infer E;
+} ? E : R extends ResultAsync<unknown, infer E> ? E : never;

package/dist/internal/infer.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @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.
+ */
+import type { ResultAsync } from "../async.js";
+/**
+ * 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
+ * ```
+ */
+export type InferOk<R> = R extends {
+    _tag: "Ok";
+    readonly value: infer T;
+} ? T : R extends ResultAsync<infer T, unknown> ? T : never;
+/**
+ * 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
+ * ```
+ */
+export type InferErr<R> = R extends {
+    _tag: "Err";
+    readonly error: infer E;
+} ? E : R extends ResultAsync<unknown, infer E> ? E : never;

package/dist/internal/lock.d.cts

@@ -0,0 +1,16 @@
+/**
+ * Payload type produced by the literal-locking constructors (`ok` / `err` and
+ * their async twins). Those take a `const` type parameter, so an inline literal
+ * keeps its narrow type instead of widening (`"a"` stays `"a"`, not `string`).
+ *
+ * `const` inference also turns every array literal into a `readonly` tuple,
+ * which would stop `ok([1, 2])` from satisfying `Result<number[], E>`. This
+ * type undoes exactly that side effect and nothing else:
+ *
+ *   • tuple (fixed length)   → same positions, `readonly` dropped, elements locked
+ *   • unbounded array        → left as authored (a `readonly T[]` input stays readonly)
+ *   • anything else          → untouched (objects keep their deep-readonly literal shape)
+ */
+export type Locked<T> = T extends readonly unknown[] ? number extends T["length"] ? T : {
+    -readonly [K in keyof T]: Locked<T[K]>;
+} : T;

package/dist/internal/lock.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Payload type produced by the literal-locking constructors (`ok` / `err` and
+ * their async twins). Those take a `const` type parameter, so an inline literal
+ * keeps its narrow type instead of widening (`"a"` stays `"a"`, not `string`).
+ *
+ * `const` inference also turns every array literal into a `readonly` tuple,
+ * which would stop `ok([1, 2])` from satisfying `Result<number[], E>`. This
+ * type undoes exactly that side effect and nothing else:
+ *
+ *   • tuple (fixed length)   → same positions, `readonly` dropped, elements locked
+ *   • unbounded array        → left as authored (a `readonly T[]` input stays readonly)
+ *   • anything else          → untouched (objects keep their deep-readonly literal shape)
+ */
+export type Locked<T> = T extends readonly unknown[] ? number extends T["length"] ? T : {
+    -readonly [K in keyof T]: Locked<T[K]>;
+} : T;

package/dist/internal/to-error.d.cts

@@ -0,0 +1,2 @@
+/** Normalizes an unknown thrown/rejected value into an `Error`. */
+export declare const toError: (error: unknown) => Error;

package/dist/internal/to-error.d.ts

@@ -0,0 +1,2 @@
+/** Normalizes an unknown thrown/rejected value into an `Error`. */
+export declare const toError: (error: unknown) => Error;

package/dist/pipe.cjs

@@ -1,6 +1,13 @@
 'use strict';
 
 // src/pipe.ts
+function pipe(value, ...fns) {
+  let acc = value;
+  for (const fn of fns) {
+    acc = fn(acc);
+  }
+  return acc;
+}
 function flow(first, ...rest) {
   return (...args) => {
     let acc = first(...args);
@@ -12,5 +19,6 @@ function flow(first, ...rest) {
 }
 
 exports.flow = flow;
+exports.pipe = pipe;
 //# sourceMappingURL=pipe.cjs.map
 //# sourceMappingURL=pipe.cjs.map

package/dist/pipe.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/pipe.ts"],"names":[],"mappings":";;;AAoEO,SAAS,IAAA,CACd,UACG,IAAA,EAC8B;AACjC,EAAA,OAAO,IAAI,IAAA,KAAoB;AAC7B,IAAA,IAAI,GAAA,GAAM,KAAA,CAAM,GAAG,IAAI,CAAA;AACvB,IAAA,KAAA,MAAW,MAAM,IAAA,EAAM;AACrB,MAAA,GAAA,GAAM,GAAG,GAAG,CAAA;AAAA,IACd;AACA,IAAA,OAAO,GAAA;AAAA,EACT,CAAA;AACF","file":"pipe.cjs","sourcesContent":["/**\n * Variadic point-free composition — chains up to nine unary fns left-to-right\n * into one reusable function. The first fn may take multiple arguments; the\n * rest are unary. Use {@link pipe} from `@onrails/result` when you already\n * have a starting value; use {@link flow} to define a reusable composed\n * function with no value yet.\n *\n * @example\n * ```ts\n * const parseUserName = flow(\n *   (raw: string) => parseConfig(raw),\n *   map((cfg) => cfg.user),\n *   flatMap((u) => (u.name ? ok(u.name) : err({ kind: \"missing\" as const }))),\n * );\n *\n * parseUserName(raw); // Result<string, ParseError | { kind: \"missing\" }>\n * ```\n */\nexport function flow<A extends readonly unknown[], B>(ab: (...a: A) => B): (...a: A) => B;\nexport function flow<A extends readonly unknown[], B, C>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n): (...a: A) => C;\nexport function flow<A extends readonly unknown[], B, C, D>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n): (...a: A) => D;\nexport function flow<A extends readonly unknown[], B, C, D, E>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n): (...a: A) => E;\nexport function flow<A extends readonly unknown[], B, C, D, E, F>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n): (...a: A) => F;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n): (...a: A) => G;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): (...a: A) => H;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): (...a: A) => I;\nexport function flow(\n  first: (...args: unknown[]) => unknown,\n  ...rest: ReadonlyArray<(x: unknown) => unknown>\n): (...args: unknown[]) => unknown {\n  return (...args: unknown[]) => {\n    let acc = first(...args);\n    for (const fn of rest) {\n      acc = fn(acc);\n    }\n    return acc;\n  };\n}\n"]}
+{"version":3,"sources":["../src/pipe.ts"],"names":[],"mappings":";;;AAyIO,SAAS,IAAA,CAAK,UAAmB,GAAA,EAAsD;AAC5F,EAAA,IAAI,GAAA,GAAM,KAAA;AACV,EAAA,KAAA,MAAW,MAAM,GAAA,EAAK;AACpB,IAAA,GAAA,GAAM,GAAG,GAAG,CAAA;AAAA,EACd;AACA,EAAA,OAAO,GAAA;AACT;AAwHO,SAAS,IAAA,CACd,UACG,IAAA,EAC8B;AACjC,EAAA,OAAO,IAAI,IAAA,KAAoB;AAC7B,IAAA,IAAI,GAAA,GAAM,KAAA,CAAM,GAAG,IAAI,CAAA;AACvB,IAAA,KAAA,MAAW,MAAM,IAAA,EAAM;AACrB,MAAA,GAAA,GAAM,GAAG,GAAG,CAAA;AAAA,IACd;AACA,IAAA,OAAO,GAAA;AAAA,EACT,CAAA;AACF","file":"pipe.cjs","sourcesContent":["/**\n * `@onrails/result/pipe` — the two composition entry points.\n *\n * {@link pipe} threads a starting value left-to-right through unary steps.\n * {@link flow} composes the steps into a reusable function with no value yet;\n * its first step may take multiple arguments.\n *\n * Both are hand-written overload towers rather than one recursive variadic\n * signature. That is deliberate: a variadic `...fns: F` cannot give each step a\n * contextual type from the previous step's output, so lambda parameters degrade\n * to `unknown` (`map((cfg) => cfg.user)` stops inferring). The tower costs lines\n * and caps the chain length; the alternative costs inference everywhere.\n *\n * The cap is {@link MAX_STEPS} steps. Longer chains nest — `pipe(pipe(v, ...), ...)`\n * — or factor a segment into a named `flow`.\n */\n\n/** Documented step cap for {@link pipe} and {@link flow}. */\nexport type MAX_STEPS = 12;\n\n/**\n * Variadic value-first pipe — threads `value` through up to twelve unary fns,\n * left-to-right. Use {@link pipe} when you already have a starting value; use\n * {@link flow} to define a reusable composed function with no value yet.\n *\n * @example\n * ```ts\n * pipe(\n *   parseConfig(raw),\n *   map((cfg) => cfg.user),\n *   flatMap((u) => (u.name ? ok(u.name) : err({ kind: \"missing\" as const }))),\n * );\n * ```\n */\nexport function pipe<A>(value: A): A;\nexport function pipe<A, B>(value: A, ab: (a: A) => B): B;\nexport function pipe<A, B, C>(value: A, ab: (a: A) => B, bc: (b: B) => C): C;\nexport function pipe<A, B, C, D>(value: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n): E;\nexport function pipe<A, B, C, D, E, F>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n): F;\nexport function pipe<A, B, C, D, E, F, G>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): I;\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n): J;\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n  jk: (j: J) => K,\n): K;\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n  jk: (j: J) => K,\n  kl: (k: K) => L,\n): L;\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n  jk: (j: J) => K,\n  kl: (k: K) => L,\n  lm: (l: L) => M,\n): M;\nexport function pipe(value: unknown, ...fns: ReadonlyArray<(x: unknown) => unknown>): unknown {\n  let acc = value;\n  for (const fn of fns) {\n    acc = fn(acc);\n  }\n  return acc;\n}\n\n/**\n * Variadic point-free composition — chains up to twelve unary fns left-to-right\n * into one reusable function. The first fn may take multiple arguments; the\n * rest are unary. Use {@link pipe} from `@onrails/result` when you already\n * have a starting value; use {@link flow} to define a reusable composed\n * function with no value yet.\n *\n * @example\n * ```ts\n * const parseUserName = flow(\n *   (raw: string) => parseConfig(raw),\n *   map((cfg) => cfg.user),\n *   flatMap((u) => (u.name ? ok(u.name) : err({ kind: \"missing\" as const }))),\n * );\n *\n * parseUserName(raw); // Result<string, ParseError | { kind: \"missing\" }>\n * ```\n */\nexport function flow<A extends readonly unknown[], B>(ab: (...a: A) => B): (...a: A) => B;\nexport function flow<A extends readonly unknown[], B, C>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n): (...a: A) => C;\nexport function flow<A extends readonly unknown[], B, C, D>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n): (...a: A) => D;\nexport function flow<A extends readonly unknown[], B, C, D, E>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n): (...a: A) => E;\nexport function flow<A extends readonly unknown[], B, C, D, E, F>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n): (...a: A) => F;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n): (...a: A) => G;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): (...a: A) => H;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): (...a: A) => I;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n): (...a: A) => J;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J, K>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n  jk: (j: J) => K,\n): (...a: A) => K;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J, K, L>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n  jk: (j: J) => K,\n  kl: (k: K) => L,\n): (...a: A) => L;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J, K, L, M>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n  jk: (j: J) => K,\n  kl: (k: K) => L,\n  lm: (l: L) => M,\n): (...a: A) => M;\nexport function flow(\n  first: (...args: unknown[]) => unknown,\n  ...rest: ReadonlyArray<(x: unknown) => unknown>\n): (...args: unknown[]) => unknown {\n  return (...args: unknown[]) => {\n    let acc = first(...args);\n    for (const fn of rest) {\n      acc = fn(acc);\n    }\n    return acc;\n  };\n}\n"]}

package/dist/pipe.d.cts

@@ -1,5 +1,50 @@
 /**
- * Variadic point-free composition — chains up to nine unary fns left-to-right
+ * `@onrails/result/pipe` — the two composition entry points.
+ *
+ * {@link pipe} threads a starting value left-to-right through unary steps.
+ * {@link flow} composes the steps into a reusable function with no value yet;
+ * its first step may take multiple arguments.
+ *
+ * Both are hand-written overload towers rather than one recursive variadic
+ * signature. That is deliberate: a variadic `...fns: F` cannot give each step a
+ * contextual type from the previous step's output, so lambda parameters degrade
+ * to `unknown` (`map((cfg) => cfg.user)` stops inferring). The tower costs lines
+ * and caps the chain length; the alternative costs inference everywhere.
+ *
+ * The cap is {@link MAX_STEPS} steps. Longer chains nest — `pipe(pipe(v, ...), ...)`
+ * — or factor a segment into a named `flow`.
+ */
+/** Documented step cap for {@link pipe} and {@link flow}. */
+export type MAX_STEPS = 12;
+/**
+ * Variadic value-first pipe — threads `value` through up to twelve unary fns,
+ * left-to-right. Use {@link pipe} when you already have a starting value; use
+ * {@link flow} to define a reusable composed function with no value yet.
+ *
+ * @example
+ * ```ts
+ * pipe(
+ *   parseConfig(raw),
+ *   map((cfg) => cfg.user),
+ *   flatMap((u) => (u.name ? ok(u.name) : err({ kind: "missing" as const }))),
+ * );
+ * ```
+ */
+export declare function pipe<A>(value: A): A;
+export declare function pipe<A, B>(value: A, ab: (a: A) => B): B;
+export declare function pipe<A, B, C>(value: A, ab: (a: A) => B, bc: (b: B) => C): C;
+export declare function pipe<A, B, C, D>(value: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
+export declare function pipe<A, B, C, D, E>(value: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
+export declare function pipe<A, B, C, D, E, F>(value: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;
+export declare function pipe<A, B, C, D, E, F, G>(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): G;
+export 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;
+export 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 declare function pipe<A, B, C, D, E, F, G, H, I, J>(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, ij: (i: I) => J): J;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(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, ij: (i: I) => J, jk: (j: J) => K): K;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(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, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L): L;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(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, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M): M;
+/**
+ * Variadic point-free composition — chains up to twelve unary fns left-to-right
  * into one reusable function. The first fn may take multiple arguments; the
  * rest are unary. Use {@link pipe} from `@onrails/result` when you already
  * have a starting value; use {@link flow} to define a reusable composed
@@ -16,13 +61,15 @@
  * parseUserName(raw); // Result<string, ParseError | { kind: "missing" }>
  * ```
  */
-declare function flow<A extends readonly unknown[], B>(ab: (...a: A) => B): (...a: A) => B;
-declare function flow<A extends readonly unknown[], B, C>(ab: (...a: A) => B, bc: (b: B) => C): (...a: A) => C;
-declare function flow<A extends readonly unknown[], B, C, D>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...a: A) => D;
-declare function flow<A extends readonly unknown[], B, C, D, E>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): (...a: A) => E;
-declare function flow<A extends readonly unknown[], B, C, D, E, F>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): (...a: A) => F;
-declare function flow<A extends readonly unknown[], B, C, D, E, F, G>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): (...a: A) => G;
-declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H>(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): (...a: A) => H;
-declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I>(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): (...a: A) => I;
-
-export { flow };
+export declare function flow<A extends readonly unknown[], B>(ab: (...a: A) => B): (...a: A) => B;
+export declare function flow<A extends readonly unknown[], B, C>(ab: (...a: A) => B, bc: (b: B) => C): (...a: A) => C;
+export declare function flow<A extends readonly unknown[], B, C, D>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...a: A) => D;
+export declare function flow<A extends readonly unknown[], B, C, D, E>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): (...a: A) => E;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): (...a: A) => F;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F, G>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): (...a: A) => G;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H>(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): (...a: A) => H;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I>(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): (...a: A) => I;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J>(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, ij: (i: I) => J): (...a: A) => J;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J, K>(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, ij: (i: I) => J, jk: (j: J) => K): (...a: A) => K;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J, K, L>(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, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L): (...a: A) => L;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J, K, L, M>(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, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M): (...a: A) => M;

package/dist/pipe.d.ts

@@ -1,5 +1,50 @@
 /**
- * Variadic point-free composition — chains up to nine unary fns left-to-right
+ * `@onrails/result/pipe` — the two composition entry points.
+ *
+ * {@link pipe} threads a starting value left-to-right through unary steps.
+ * {@link flow} composes the steps into a reusable function with no value yet;
+ * its first step may take multiple arguments.
+ *
+ * Both are hand-written overload towers rather than one recursive variadic
+ * signature. That is deliberate: a variadic `...fns: F` cannot give each step a
+ * contextual type from the previous step's output, so lambda parameters degrade
+ * to `unknown` (`map((cfg) => cfg.user)` stops inferring). The tower costs lines
+ * and caps the chain length; the alternative costs inference everywhere.
+ *
+ * The cap is {@link MAX_STEPS} steps. Longer chains nest — `pipe(pipe(v, ...), ...)`
+ * — or factor a segment into a named `flow`.
+ */
+/** Documented step cap for {@link pipe} and {@link flow}. */
+export type MAX_STEPS = 12;
+/**
+ * Variadic value-first pipe — threads `value` through up to twelve unary fns,
+ * left-to-right. Use {@link pipe} when you already have a starting value; use
+ * {@link flow} to define a reusable composed function with no value yet.
+ *
+ * @example
+ * ```ts
+ * pipe(
+ *   parseConfig(raw),
+ *   map((cfg) => cfg.user),
+ *   flatMap((u) => (u.name ? ok(u.name) : err({ kind: "missing" as const }))),
+ * );
+ * ```
+ */
+export declare function pipe<A>(value: A): A;
+export declare function pipe<A, B>(value: A, ab: (a: A) => B): B;
+export declare function pipe<A, B, C>(value: A, ab: (a: A) => B, bc: (b: B) => C): C;
+export declare function pipe<A, B, C, D>(value: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
+export declare function pipe<A, B, C, D, E>(value: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
+export declare function pipe<A, B, C, D, E, F>(value: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;
+export declare function pipe<A, B, C, D, E, F, G>(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): G;
+export 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;
+export 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 declare function pipe<A, B, C, D, E, F, G, H, I, J>(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, ij: (i: I) => J): J;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(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, ij: (i: I) => J, jk: (j: J) => K): K;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(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, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L): L;
+export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(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, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M): M;
+/**
+ * Variadic point-free composition — chains up to twelve unary fns left-to-right
  * into one reusable function. The first fn may take multiple arguments; the
  * rest are unary. Use {@link pipe} from `@onrails/result` when you already
  * have a starting value; use {@link flow} to define a reusable composed
@@ -16,13 +61,15 @@
  * parseUserName(raw); // Result<string, ParseError | { kind: "missing" }>
  * ```
  */
-declare function flow<A extends readonly unknown[], B>(ab: (...a: A) => B): (...a: A) => B;
-declare function flow<A extends readonly unknown[], B, C>(ab: (...a: A) => B, bc: (b: B) => C): (...a: A) => C;
-declare function flow<A extends readonly unknown[], B, C, D>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...a: A) => D;
-declare function flow<A extends readonly unknown[], B, C, D, E>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): (...a: A) => E;
-declare function flow<A extends readonly unknown[], B, C, D, E, F>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): (...a: A) => F;
-declare function flow<A extends readonly unknown[], B, C, D, E, F, G>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): (...a: A) => G;
-declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H>(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): (...a: A) => H;
-declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I>(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): (...a: A) => I;
-
-export { flow };
+export declare function flow<A extends readonly unknown[], B>(ab: (...a: A) => B): (...a: A) => B;
+export declare function flow<A extends readonly unknown[], B, C>(ab: (...a: A) => B, bc: (b: B) => C): (...a: A) => C;
+export declare function flow<A extends readonly unknown[], B, C, D>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...a: A) => D;
+export declare function flow<A extends readonly unknown[], B, C, D, E>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): (...a: A) => E;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): (...a: A) => F;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F, G>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): (...a: A) => G;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H>(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): (...a: A) => H;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I>(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): (...a: A) => I;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J>(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, ij: (i: I) => J): (...a: A) => J;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J, K>(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, ij: (i: I) => J, jk: (j: J) => K): (...a: A) => K;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J, K, L>(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, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L): (...a: A) => L;
+export declare function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J, K, L, M>(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, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M): (...a: A) => M;

package/dist/pipe.js

@@ -1,4 +1,11 @@
 // src/pipe.ts
+function pipe(value, ...fns) {
+  let acc = value;
+  for (const fn of fns) {
+    acc = fn(acc);
+  }
+  return acc;
+}
 function flow(first, ...rest) {
   return (...args) => {
     let acc = first(...args);
@@ -9,6 +16,6 @@ function flow(first, ...rest) {
   };
 }
 
-export { flow };
+export { flow, pipe };
 //# sourceMappingURL=pipe.js.map
 //# sourceMappingURL=pipe.js.map

package/dist/pipe.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/pipe.ts"],"names":[],"mappings":";AAoEO,SAAS,IAAA,CACd,UACG,IAAA,EAC8B;AACjC,EAAA,OAAO,IAAI,IAAA,KAAoB;AAC7B,IAAA,IAAI,GAAA,GAAM,KAAA,CAAM,GAAG,IAAI,CAAA;AACvB,IAAA,KAAA,MAAW,MAAM,IAAA,EAAM;AACrB,MAAA,GAAA,GAAM,GAAG,GAAG,CAAA;AAAA,IACd;AACA,IAAA,OAAO,GAAA;AAAA,EACT,CAAA;AACF","file":"pipe.js","sourcesContent":["/**\n * Variadic point-free composition — chains up to nine unary fns left-to-right\n * into one reusable function. The first fn may take multiple arguments; the\n * rest are unary. Use {@link pipe} from `@onrails/result` when you already\n * have a starting value; use {@link flow} to define a reusable composed\n * function with no value yet.\n *\n * @example\n * ```ts\n * const parseUserName = flow(\n *   (raw: string) => parseConfig(raw),\n *   map((cfg) => cfg.user),\n *   flatMap((u) => (u.name ? ok(u.name) : err({ kind: \"missing\" as const }))),\n * );\n *\n * parseUserName(raw); // Result<string, ParseError | { kind: \"missing\" }>\n * ```\n */\nexport function flow<A extends readonly unknown[], B>(ab: (...a: A) => B): (...a: A) => B;\nexport function flow<A extends readonly unknown[], B, C>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n): (...a: A) => C;\nexport function flow<A extends readonly unknown[], B, C, D>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n): (...a: A) => D;\nexport function flow<A extends readonly unknown[], B, C, D, E>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n): (...a: A) => E;\nexport function flow<A extends readonly unknown[], B, C, D, E, F>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n): (...a: A) => F;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n): (...a: A) => G;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): (...a: A) => H;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): (...a: A) => I;\nexport function flow(\n  first: (...args: unknown[]) => unknown,\n  ...rest: ReadonlyArray<(x: unknown) => unknown>\n): (...args: unknown[]) => unknown {\n  return (...args: unknown[]) => {\n    let acc = first(...args);\n    for (const fn of rest) {\n      acc = fn(acc);\n    }\n    return acc;\n  };\n}\n"]}
+{"version":3,"sources":["../src/pipe.ts"],"names":[],"mappings":";AAyIO,SAAS,IAAA,CAAK,UAAmB,GAAA,EAAsD;AAC5F,EAAA,IAAI,GAAA,GAAM,KAAA;AACV,EAAA,KAAA,MAAW,MAAM,GAAA,EAAK;AACpB,IAAA,GAAA,GAAM,GAAG,GAAG,CAAA;AAAA,EACd;AACA,EAAA,OAAO,GAAA;AACT;AAwHO,SAAS,IAAA,CACd,UACG,IAAA,EAC8B;AACjC,EAAA,OAAO,IAAI,IAAA,KAAoB;AAC7B,IAAA,IAAI,GAAA,GAAM,KAAA,CAAM,GAAG,IAAI,CAAA;AACvB,IAAA,KAAA,MAAW,MAAM,IAAA,EAAM;AACrB,MAAA,GAAA,GAAM,GAAG,GAAG,CAAA;AAAA,IACd;AACA,IAAA,OAAO,GAAA;AAAA,EACT,CAAA;AACF","file":"pipe.js","sourcesContent":["/**\n * `@onrails/result/pipe` — the two composition entry points.\n *\n * {@link pipe} threads a starting value left-to-right through unary steps.\n * {@link flow} composes the steps into a reusable function with no value yet;\n * its first step may take multiple arguments.\n *\n * Both are hand-written overload towers rather than one recursive variadic\n * signature. That is deliberate: a variadic `...fns: F` cannot give each step a\n * contextual type from the previous step's output, so lambda parameters degrade\n * to `unknown` (`map((cfg) => cfg.user)` stops inferring). The tower costs lines\n * and caps the chain length; the alternative costs inference everywhere.\n *\n * The cap is {@link MAX_STEPS} steps. Longer chains nest — `pipe(pipe(v, ...), ...)`\n * — or factor a segment into a named `flow`.\n */\n\n/** Documented step cap for {@link pipe} and {@link flow}. */\nexport type MAX_STEPS = 12;\n\n/**\n * Variadic value-first pipe — threads `value` through up to twelve unary fns,\n * left-to-right. Use {@link pipe} when you already have a starting value; use\n * {@link flow} to define a reusable composed function with no value yet.\n *\n * @example\n * ```ts\n * pipe(\n *   parseConfig(raw),\n *   map((cfg) => cfg.user),\n *   flatMap((u) => (u.name ? ok(u.name) : err({ kind: \"missing\" as const }))),\n * );\n * ```\n */\nexport function pipe<A>(value: A): A;\nexport function pipe<A, B>(value: A, ab: (a: A) => B): B;\nexport function pipe<A, B, C>(value: A, ab: (a: A) => B, bc: (b: B) => C): C;\nexport function pipe<A, B, C, D>(value: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n): E;\nexport function pipe<A, B, C, D, E, F>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n): F;\nexport function pipe<A, B, C, D, E, F, G>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): I;\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n): J;\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n  jk: (j: J) => K,\n): K;\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n  jk: (j: J) => K,\n  kl: (k: K) => L,\n): L;\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n  jk: (j: J) => K,\n  kl: (k: K) => L,\n  lm: (l: L) => M,\n): M;\nexport function pipe(value: unknown, ...fns: ReadonlyArray<(x: unknown) => unknown>): unknown {\n  let acc = value;\n  for (const fn of fns) {\n    acc = fn(acc);\n  }\n  return acc;\n}\n\n/**\n * Variadic point-free composition — chains up to twelve unary fns left-to-right\n * into one reusable function. The first fn may take multiple arguments; the\n * rest are unary. Use {@link pipe} from `@onrails/result` when you already\n * have a starting value; use {@link flow} to define a reusable composed\n * function with no value yet.\n *\n * @example\n * ```ts\n * const parseUserName = flow(\n *   (raw: string) => parseConfig(raw),\n *   map((cfg) => cfg.user),\n *   flatMap((u) => (u.name ? ok(u.name) : err({ kind: \"missing\" as const }))),\n * );\n *\n * parseUserName(raw); // Result<string, ParseError | { kind: \"missing\" }>\n * ```\n */\nexport function flow<A extends readonly unknown[], B>(ab: (...a: A) => B): (...a: A) => B;\nexport function flow<A extends readonly unknown[], B, C>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n): (...a: A) => C;\nexport function flow<A extends readonly unknown[], B, C, D>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n): (...a: A) => D;\nexport function flow<A extends readonly unknown[], B, C, D, E>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n): (...a: A) => E;\nexport function flow<A extends readonly unknown[], B, C, D, E, F>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n): (...a: A) => F;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n): (...a: A) => G;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): (...a: A) => H;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): (...a: A) => I;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n): (...a: A) => J;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J, K>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n  jk: (j: J) => K,\n): (...a: A) => K;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J, K, L>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n  jk: (j: J) => K,\n  kl: (k: K) => L,\n): (...a: A) => L;\nexport function flow<A extends readonly unknown[], B, C, D, E, F, G, H, I, J, K, L, M>(\n  ab: (...a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n  ij: (i: I) => J,\n  jk: (j: J) => K,\n  kl: (k: K) => L,\n  lm: (l: L) => M,\n): (...a: A) => M;\nexport function flow(\n  first: (...args: unknown[]) => unknown,\n  ...rest: ReadonlyArray<(x: unknown) => unknown>\n): (...args: unknown[]) => unknown {\n  return (...args: unknown[]) => {\n    let acc = first(...args);\n    for (const fn of rest) {\n      acc = fn(acc);\n    }\n    return acc;\n  };\n}\n"]}