@railway-ts/pipelines 0.1.7 → 0.1.8

package/README.md

@@ -4,7 +4,7 @@
 
 Railway-oriented programming for TypeScript. Result and Option types that don't suck.
 
-**Design philosophy:** Small, focused API surface. Practical over academic. No fp-ts complexity, no Effect-TS kitchen sink.
+Small, focused API surface. Errors propagate automatically, you handle them once at the end.
 
 ## Install
 
@@ -14,11 +14,53 @@ bun add @railway-ts/pipelines  # or npm, pnpm, yarn
 
 Requires TypeScript 5.0+ and Node.js 18+.
 
-## Quick Start
+## Quick Example
 
 ```typescript
 import { pipe } from '@railway-ts/pipelines/composition';
-import { ok, match, andThen } from '@railway-ts/pipelines/result';
+import { ok, err, mapWith, match } from '@railway-ts/pipelines/result';
+
+const divide = (a: number, b: number) =>
+  b === 0 ? err('div by zero') : ok(a / b);
+
+const result = pipe(
+  divide(10, 2),
+  mapWith((x) => x * 3),
+);
+
+match(result, {
+  ok: (value) => console.log(value),   // 15
+  err: (error) => console.error(error),
+});
+```
+
+## Documentation
+
+-> **[Getting Started](docs/GETTING_STARTED.md)** - Guided walkthrough from first principles to full pipelines
+-> **[Recipes](docs/RECIPES.md)** - Point-free composition, error recovery, async pipelines, validation patterns
+-> **[Advanced](docs/ADVANCED.md)** - Symbol branding, type inference, implementation details
+-> **[Examples](examples/)** - Working code you can run
+
+For a complete real-world pipeline, see the [Launch Decision Pipeline](docs/RECIPES.md#full-example-launch-decision-pipeline) -- validates input, fetches weather data, and makes a GO/NO-GO decision.
+
+## What's Included
+
+- **Result\<T, E\>** -- typed success/failure with map, flatMap, match, and recovery
+- **Option\<T\>** -- nullable handling without null checks
+- **Schema validation** -- parse unknown data, accumulate all errors, infer TypeScript types
+- **Composition** -- `pipe`, `flow`, `pipeAsync`, `flowAsync`, `curry`
+- **Async** -- sync-preserving overloads, parallel field validation, seamless sync/async mixing
+- **Standard Schema v1** -- `toStandardSchema()` for tRPC, TanStack Form, React Hook Form, and other consumers
+
+## Two Styles
+
+Same task, two approaches -- use whichever fits your codebase.
+
+**Pipeline-first** -- keep validation and computation as separate pipeline steps:
+
+```typescript
+import { pipeAsync } from '@railway-ts/pipelines/composition';
+import { mapWith, match } from '@railway-ts/pipelines/result';
 import {
   validate,
   object,
@@ -36,8 +78,11 @@ const schema = object({
   y: required(chain(parseNumber(), min(1))),
 });
 
-async function compute(input: unknown): Promise<ValidationResult<number>> {
-  const result = await pipe(validate(input, schema), (r) => andThen(r, ({ x, y }) => ok(x / y)));
+async function compute(input: unknown) {
+  const result = await pipeAsync(
+    validate(input, schema),
+    mapWith(({ x, y }) => x / y),
+  );
 
   return match<number, ValidationError[], ValidationResult<number>>(result, {
     ok: (value) => ({ valid: true, data: value }),
@@ -45,40 +90,51 @@ async function compute(input: unknown): Promise<ValidationResult<number>> {
   });
 }
 
-await compute({ x: 10, y: 2 }).then(console.log); // { valid: true, data: 5 }
+await compute({ x: '10', y: '2' }).then(console.log); // { valid: true, data: 5 }
 ```
 
-**The pattern:** Validate at boundaries, chain operations, branch once at the end. Errors propagate automatically.
-
-## Documentation
-
-→ **[Getting Started](GETTING_STARTED.md)** - Your first pipeline  
-→ **[Recipes](docs/RECIPES.md)** - Common patterns (point-free composition, async, validation)  
-→ **[Advanced](docs/ADVANCED.md)** - Symbol branding, tuple preservation, type inference  
-→ **[Examples](examples/)** - Working code you can run
+**Schema-first** -- fold the transform into the schema, get the result in one call:
 
-## Why This Library
-
-**Focused scope:** Result, Option, validation, composition. That's it. No monads seminar.
+```typescript
+import {
+  validateAndFormatResult,
+  object,
+  required,
+  chain,
+  parseNumber,
+  min,
+  transform,
+} from '@railway-ts/pipelines/schema';
 
-**Practical:** Eliminates boilerplate for real patterns. Documentation shows you how, doesn't make it part of the API.
+const schema = chain(
+  object({
+    x: required(chain(parseNumber(), min(0))),
+    y: required(chain(parseNumber(), min(1))),
+  }),
+  transform(({ x, y }) => x / y),
+);
 
-**Type-safe:** Symbol branding prevents duck typing bugs. Tuple preservation means no type casts.
+const result = validateAndFormatResult({ x: '10', y: '2' }, schema);
+console.log(result); // { valid: true, data: 5 }
+```
 
-**Railway-oriented:** Errors propagate automatically. Write happy path code, handle errors once at the end.
+**The pattern:** Validate at boundaries, chain operations, branch once at the end. Errors propagate automatically.
 
 ## API Reference
 
 ### Option
 
-Handle nullable values without `if (x != null)` everywhere.
+Handle nullable values without `if (x !== null)` everywhere.
 
 ```typescript
 import { pipe } from '@railway-ts/pipelines/composition';
-import { some, map, match } from '@railway-ts/pipelines/option';
+import { some, mapWith, match } from '@railway-ts/pipelines/option';
 
 const user = some({ name: 'Alice', age: 25 });
-const name = pipe(user, (o) => map(o, (u) => u.name));
+const name = pipe(
+  user,
+  mapWith((u) => u.name),
+);
 
 match(name, {
   some: (n) => console.log(n),
@@ -86,11 +142,12 @@ match(name, {
 }); // Output: Alice
 ```
 
-**Core:** `some`, `none`, `isSome`, `isNone`  
-**Transform:** `map`, `flatMap`, `bimap`, `filter`, `tap`  
-**Unwrap:** `unwrap`, `unwrapOr`, `unwrapOrElse`  
-**Combine:** `combine`  
-**Convert:** `fromNullable`, `mapToResult`  
+**Core:** `some`, `none`, `isSome`, `isNone`
+**Transform:** `map`, `flatMap`, `bimap`, `filter`, `tap`
+**Curried:** `mapWith`, `flatMapWith`, `filterWith`, `tapWith`
+**Unwrap:** `unwrap`, `unwrapOr`, `unwrapOrElse`
+**Combine:** `combine`
+**Convert:** `fromNullable`, `mapToResult`
 **Branch:** `match`
 
 ### Result
@@ -99,11 +156,14 @@ Explicit error handling. No exceptions, no try-catch pyramids.
 
 ```typescript
 import { pipe } from '@railway-ts/pipelines/composition';
-import { ok, err, map, match } from '@railway-ts/pipelines/result';
+import { ok, err, mapWith, match } from '@railway-ts/pipelines/result';
 
 const divide = (a: number, b: number) => (b === 0 ? err('div by zero') : ok(a / b));
 
-const result = pipe(divide(10, 2), (r) => map(r, (x) => x * 3));
+const result = pipe(
+  divide(10, 2),
+  mapWith((x) => x * 3),
+);
 
 match(result, {
   ok: (value) => console.log(value),
@@ -111,18 +171,21 @@ match(result, {
 }); // Output: 15
 ```
 
-**Core:** `ok`, `err`, `isOk`, `isErr`  
-**Transform:** `map`, `mapErr`, `flatMap`, `bimap`, `filter`, `tap`, `tapErr`  
-**Unwrap:** `unwrap`, `unwrapOr`, `unwrapOrElse`  
-**Combine:** `combine`, `combineAll`  
-**Convert:** `fromTry`, `fromTryWithError`, `fromPromise`, `fromPromiseWithError`, `toPromise`, `mapToOption`  
-**Async:** `andThen`  
+**Core:** `ok`, `err`, `isOk`, `isErr`
+**Transform:** `map`, `mapErr`, `flatMap`, `bimap`, `filter`, `tap`, `tapErr`
+**Curried:** `mapWith`, `flatMapWith`, `mapErrWith`, `filterWith`, `tapWith`, `tapErrWith`
+**Recovery:** `orElse`, `orElseWith`
+**Unwrap:** `unwrap`, `unwrapOr`, `unwrapOrElse`
+**Combine:** `combine`, `combineAll`
+**Convert:** `fromTry`, `fromTryWithError`, `fromPromise`, `fromPromiseWithError`, `toPromise`, `mapToOption`
 **Branch:** `match`
 
 ### Schema
 
 Parse untrusted data into typed values. Accumulates all validation errors.
 
+> **Standard Schema v1 compliant** — use `toStandardSchema()` for interop with tRPC, TanStack Form, React Hook Form, and other Standard Schema consumers. See [Recipes → Standard Schema Interop](docs/RECIPES.md#standard-schema-interop).
+
 ```typescript
 import {
   validate,
@@ -150,23 +213,29 @@ const result = validate(input, userSchema);
 // Result<User, ValidationError[]>
 ```
 
-**Primitives:** `string`, `number`, `boolean`, `date`, `bigint`  
-**Parsers:** `parseNumber`, `parseInt`, `parseFloat`, `parseJSON`, `parseString`, `parseBigInt`, `parseBool`, `parseDate`, `parseISODate`, `parseURL`, `parseEnum`  
-**Structures:** `object`, `array`, `tuple`, `tupleOf`  
-**Unions:** `union`, `discriminatedUnion`, `literal`  
-**Modifiers:** `required`, `optional`, `nullable`, `emptyAsOptional`  
-**String Constraints:** `minLength`, `maxLength`, `pattern`, `nonEmpty`, `email`, `phoneNumber`  
-**Number Constraints:** `min`, `max`, `integer`, `finite`, `between`  
-**Enums:** `stringEnum`, `numberEnum`  
-**Combinators:** `chain`, `transform`, `refine`, `matches`  
-**Utilities:** `validate`, `formatErrors`, `InferSchemaType`, `Validator`, `ValidationError`
+**Primitives:** `string`, `number`, `boolean`, `date`, `bigint`
+**Parsers:** `parseNumber`, `parseString`, `parseBool`, `parseBigInt`, `parseDate`, `parseISODate`, `parseJSON`, `parseURL`, `parseEnum`
+**Structures:** `object`, `array`, `tuple`, `tupleOf`
+**Unions:** `union`, `discriminatedUnion`, `literal`
+**Modifiers:** `required`, `optional`, `nullable`, `emptyAsOptional`
+**String Constraints:** `minLength`, `maxLength`, `pattern`, `nonEmpty`, `email`, `phoneNumber`
+**Number Constraints:** `min`, `max`, `integer`, `finite`, `between`, `positive`, `negative`, `nonZero`, `divisibleBy`, `precision`
+**Date Constraints:** `dateRange`, `pastDate`, `futureDate`, `todayOrFuture`
+**Enums:** `stringEnum`, `enumValue`, `oneOf`
+**Boolean Constraints:** `matches`
+**Array Constraints:** `minItems`, `maxItems`, `notEmpty`, `unique`
+**Combinators:** `chain`, `transform`, `refine`
+**Cross-field:** `refineAt`, `refineAtAsync`
+**Async:** `chainAsync`, `refineAsync`, `refineAtAsync`
+**Utilities:** `validate`, `validateAndFormatResult`, `formatErrors`, `toStandardSchema`, `ROOT_ERROR_KEY`
+**Types:** `Validator`, `AsyncValidator`, `MaybeAsyncValidator`, `Schema`, `SyncSchema`, `InferSchemaType`, `ValidatorMapOutput`, `ValidationError`, `ValidationResult`, `StandardSchemaV1`
 
 ### Composition
 
 Build pipelines. No nested function calls.
 
 ```typescript
-import { pipe, flow, curry } from '@railway-ts/pipelines/composition';
+import { pipe, flow, pipeAsync, flowAsync } from '@railway-ts/pipelines/composition';
 
 // Immediate execution
 const result = pipe(
@@ -175,34 +244,24 @@ const result = pipe(
   (x) => x + 1,
 ); // 11
 
-// Build reusable pipeline
+// Reusable pipeline
 const process = flow(
   (x: number) => x * 2,
   (x) => x + 1,
 );
 process(5); // 11
-```
-
-**Functions:** `pipe`, `flow`, `curry`, `uncurry`, `tupled`, `untupled`
 
-## Import Patterns
+// Async pipeline (awaits each step)
+const data = await pipeAsync(userId, fetchUser, validateUser, enrichProfile);
 
-### Subpath imports (recommended for tree-shaking)
-
-```typescript
-import { some, none, map } from '@railway-ts/pipelines/option';
-import { ok, err, flatMap } from '@railway-ts/pipelines/result';
-import { pipe, flow } from '@railway-ts/pipelines/composition';
-import { string, number, validate } from '@railway-ts/pipelines/schema';
-```
-
-### Root imports (adds type suffixes)
-
-```typescript
-import { mapOption, mapResult, pipe, ok, validate } from '@railway-ts/pipelines';
+// Reusable async pipeline
+const processOrder = flowAsync(validateOrder, chargePayment, createShipment);
+await processOrder(orderInput);
 ```
 
-Functions that exist in both Result and Option get suffixes when imported from root: `mapResult`, `mapOption`, etc. Result-only functions stay unsuffixed: `mapErr`, `andThen`.
+**Sync:** `pipe`, `flow`, `curry`, `uncurry`, `tupled`, `untupled`
+**Async:** `pipeAsync`, `flowAsync`
+**Types:** `MaybeAsync`
 
 ## Examples
 
@@ -217,10 +276,10 @@ bun run examples/index.ts
 
 **What's in there:**
 
-- `option/` - Nullable handling patterns
-- `result/` - Error handling patterns
-- `schema/` - Validation (basic, unions, tuples)
-- `composition/` - Function composition techniques
+- `option/` - Nullable handling patterns, curried helpers
+- `result/` - Error handling patterns, curried helpers, recovery
+- `schema/` - Validation (basic, unions, tuples, async validation)
+- `composition/` - Function composition (sync and async)
 - `complete-pipelines/` - Full examples with validation + async + logic
 
 Start with `examples/complete-pipelines/async-launch.ts` for a real-world pattern.

package/dist/composition/index.cjs

@@ -24,6 +24,26 @@ function flow(...fns) {
   };
 }
 
+// src/composition/pipe-async.ts
+async function pipeAsync(a, ...fns) {
+  let result = await a;
+  for (const fn of fns) {
+    result = await fn(result);
+  }
+  return result;
+}
+
+// src/composition/flow-async.ts
+function flowAsync(first, ...fns) {
+  return async (...args) => {
+    let result = await first(...args);
+    for (const fn of fns) {
+      result = await fn(result);
+    }
+    return result;
+  };
+}
+
 // src/composition/curry.ts
 function curry(fn) {
   const arity = fn.length;
@@ -64,7 +84,9 @@ function untupled(fn) {
 
 exports.curry = curry;
 exports.flow = flow;
+exports.flowAsync = flowAsync;
 exports.pipe = pipe;
+exports.pipeAsync = pipeAsync;
 exports.tupled = tupled;
 exports.uncurry = uncurry;
 exports.untupled = untupled;

package/dist/composition/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/composition/pipe.ts","../../src/composition/flow.ts","../../src/composition/curry.ts","../../src/composition/uncurry.ts","../../src/composition/tupled.ts","../../src/composition/untupled.ts"],"names":[],"mappings":";;;AA8GO,SAAS,IAAA,CAAK,UAAmB,GAAA,EAAiC;AACvE,EAAA,IAAI,MAAA,GAAS,KAAA;AACb,EAAA,KAAA,MAAW,MAAM,GAAA,EAAK;AACpB,IAAA,MAAA,GAAS,GAAG,MAAM,CAAA;AAAA,EACpB;AACA,EAAA,OAAO,MAAA;AACT;;;ACkBO,SAAS,QAAQ,GAAA,EAA+D;AACrF,EAAA,IAAI,GAAA,CAAI,WAAW,CAAA,EAAG;AACpB,IAAA,OAAO,IAAI,CAAC,CAAA;AAAA,EACd;AAEA,EAAA,MAAM,CAAC,KAAA,EAAO,GAAG,IAAI,CAAA,GAAI,GAAA;AACzB,EAAA,OAAO,IAAI,IAAA,KAA6B;AACtC,IAAA,IAAI,MAAA,GAAS,KAAA,CAAM,GAAG,IAAI,CAAA;AAC1B,IAAA,KAAA,MAAW,MAAM,IAAA,EAAM;AACrB,MAAA,MAAA,GAAS,GAAG,MAAM,CAAA;AAAA,IACpB;AACA,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AACF;;;AC9FO,SAAS,MAAiC,EAAA,EAAwB;AACvE,EAAA,MAAM,QAAQ,EAAA,CAAG,MAAA;AAEjB,EAAA,OAAO,SAAS,WAAW,IAAA,EAA0B;AACnD,IAAA,IAAI,IAAA,CAAK,UAAU,KAAA,EAAO;AACxB,MAAA,OAAQ,EAAA,CAAuB,GAAG,IAAI,CAAA;AAAA,IACxC;AAEA,IAAA,OAAO,YAAa,QAAA,EAA8B;AAChD,MAAA,OAAO,OAAA,CAAQ,GAAG,IAAA,EAAM,GAAG,QAAQ,CAAA;AAAA,IACrC,CAAA;AAAA,EACF,CAAA;AACF;;;ACPO,SAAS,QAAQ,EAAA,EAAsB;AAC5C,EAAA,OAAO,SAAS,aAAa,IAAA,EAA0B;AAErD,IAAA,IAAI,MAAA,GAAS,EAAA;AAEb,IAAA,KAAA,MAAW,OAAO,IAAA,EAAM;AACtB,MAAA,MAAA,GAAU,OAA2B,GAAG,CAAA;AAAA,IAC1C;AAEA,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AACF;;;ACbO,SAAS,OAAkC,EAAA,EAAqC;AACrF,EAAA,OAAO,SAAS,SAAS,IAAA,EAA0B;AACjD,IAAA,OAAO,EAAA,CAAG,GAAG,IAAI,CAAA;AAAA,EACnB,CAAA;AACF;;;ACPO,SAAS,SAAoC,EAAA,EAAwB;AAC1E,EAAA,OAAO,SAAS,cAAc,IAAA,EAA0B;AACtD,IAAA,OAAO,GAAG,IAAI,CAAA;AAAA,EAChB,CAAA;AACF","file":"index.cjs","sourcesContent":["type UnknownFunction = (...params: unknown[]) => unknown;\n\n/**\n * Pipes a value through a series of functions, from left to right.\n * Each function receives the output of the previous function.\n * Unlike flow, pipe immediately executes the functions with the provided initial value.\n *\n * @example\n * // Basic usage\n * const result = pipe(\n *   5,\n *   (n) => n * 2,      // 10\n *   (n) => n + 1,      // 11\n *   (n) => n.toString() // \"11\"\n * );\n * // result: \"11\"\n *\n * @example\n * // With Option\n * import { some, mapOption } from \"@railway-ts/pipelines/option\";\n *\n * const optionResult = pipe(\n *   some(5),\n *   (o) => mapOption(o, (n) => n * 2),\n *   (o) => mapOption(o, (n) => n.toString())\n * );\n * // optionResult: Option<string> containing \"10\"\n *\n * @example\n * // With Result\n * import { ok, mapResult } from \"@railway-ts/pipelines/result\";\n *\n * const resultValue = pipe(\n *   ok(5),\n *   (r) => mapResult(r, (n) => n * 2),\n *   (r) => mapResult(r, (n) => n.toString())\n * );\n * // resultValue: Result<string, never> containing \"10\"\n *\n * @param a - The initial value to pipe through the functions\n * @param ab - The first function to apply to the initial value\n * @param functions - Additional functions to apply in sequence\n * @returns The final result after applying all functions\n */\n\nexport function pipe<A, B>(a: A, ab: (this: void, a: A) => B): B;\nexport function pipe<A, B, C>(a: A, ab: (this: void, a: A) => B, bc: (this: void, b: B) => C): C;\nexport function pipe<A, B, C, D>(\n  a: A,\n  ab: (this: void, a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n): D;\nexport function pipe<A, B, C, D, E>(\n  a: A,\n  ab: (this: void, a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n): E;\nexport function pipe<A, B, C, D, E, F>(\n  a: A,\n  ab: (this: void, a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n): F;\nexport function pipe<A, B, C, D, E, F, G>(\n  a: A,\n  ab: (this: void, a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  a: A,\n  ab: (this: void, a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n  gh: (this: void, g: G) => H,\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  a: A,\n  ab: (this: void, a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n  gh: (this: void, g: G) => H,\n  hi: (this: void, h: H) => I,\n): I;\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(\n  a: A,\n  ab: (this: void, a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n  gh: (this: void, g: G) => H,\n  hi: (this: void, h: H) => I,\n  ij: (this: void, i: I) => J,\n): J;\nexport function pipe(value: unknown, ...fns: UnknownFunction[]): unknown {\n  let result = value;\n  for (const fn of fns) {\n    result = fn(result);\n  }\n  return result;\n}\n","type UnknownFunction = (...params: unknown[]) => unknown;\n\n/**\n * Creates a new function that is the composition of the provided functions, applied from left to right.\n * Unlike pipe, flow doesn't immediately execute the functions but returns a new function that,\n * when called, will run the composed functions in sequence.\n *\n * @example\n * // Basic usage\n * const processNumber = flow(\n *   (n: number) => n * 2,\n *   (n) => n + 1,\n *   (n) => n.toString()\n * );\n *\n * const result = processNumber(5); // \"11\"\n *\n * @example\n * // With multiple arguments\n * const formatName = flow(\n *   (first: string, last: string) => `${first} ${last}`,\n *   (name) => name.toUpperCase()\n * );\n *\n * const name = formatName(\"John\", \"Doe\"); // \"JOHN DOE\"\n *\n * @example\n * // With Option type\n * import { some, none, mapOption, flatMapOption, type Option } from \"@railway-ts/pipelines/option\";\n *\n * const safeParseInt = (radix: number) => (str: string): Option<number> => {\n *   const n = Number.parseInt(str, radix);\n *   return Number.isNaN(n) ? none() : some(n);\n * };\n *\n * const processString = flow(\n *   (s: string) => some(s),\n *   (o) => mapOption(o, (s) => s + \"0\"),\n *   (o) => flatMapOption(o, safeParseInt(10))\n * );\n *\n * const option = processString(\"42\"); // Option<number> containing 420\n *\n * @example\n * // With Result type\n * import { ok, err, flatMapResult } from \"@railway-ts/pipelines/result\";\n *\n * const validatePositive = (n: number) => (n > 0 ? ok(n) : err(\"Not positive\"));\n *\n * const validateNumber = flow(\n *   (n: number) => ok(n),\n *   (r) => flatMapResult(r, validatePositive),\n *   (r) => flatMapResult(r, (n) => ok(n * 2))\n * );\n *\n * const result = validateNumber(5); // Result<number, string> containing 10\n *\n * @param ab - The first function in the composition\n * @param functions - Additional functions to compose in sequence\n * @returns A new function that applies all the composed functions in sequence\n */\nexport function flow<A extends unknown[], B>(ab: (this: void, ...a: A) => B): (...a: A) => B;\nexport function flow<A extends unknown[], B, C>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n): (...a: A) => C;\nexport function flow<A extends unknown[], B, C, D>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n): (...a: A) => D;\nexport function flow<A extends unknown[], B, C, D, E>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n): (...a: A) => E;\nexport function flow<A extends unknown[], B, C, D, E, F>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n): (...a: A) => F;\nexport function flow<A extends unknown[], B, C, D, E, F, G>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n): (...a: A) => G;\nexport function flow<A extends unknown[], B, C, D, E, F, G, H>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n  gh: (this: void, g: G) => H,\n): (...a: A) => H;\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n  gh: (this: void, g: G) => H,\n  hi: (this: void, h: H) => I,\n): (...a: A) => I;\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n  gh: (this: void, g: G) => H,\n  hi: (this: void, h: H) => I,\n  ij: (this: void, i: I) => J,\n): (...a: A) => J;\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n  gh: (this: void, g: G) => H,\n  hi: (this: void, h: H) => I,\n  ij: (this: void, i: I) => J,\n  jk: (this: void, j: J) => K,\n): (...a: A) => K;\nexport function flow(...fns: [UnknownFunction, ...UnknownFunction[]]): UnknownFunction {\n  if (fns.length === 1) {\n    return fns[0];\n  }\n\n  const [first, ...rest] = fns;\n  return (...args: unknown[]): unknown => {\n    let result = first(...args);\n    for (const fn of rest) {\n      result = fn(result);\n    }\n    return result;\n  };\n}\n","type UnknownFunction = (...params: unknown[]) => unknown;\n\n/**\n * Curries a multi-parameter function into a sequence of unary functions.\n * Enables partial application at any depth and composes cleanly with `pipe`.\n *\n * Note: This curry is unary-only at each step to ensure compatibility with `pipe` and `flow`.\n *\n * @example\n * // Basic (2-arity)\n * const add = (a: number, b: number) => a + b;\n * const add5 = curry(add)(5);\n * add5(3); // 8\n *\n * @example\n * // 3-arity and partial application\n * const multiply = (a: number, b: number, c: number) => a * b * c;\n * const curriedMultiply = curry(multiply);\n * curriedMultiply(2)(3)(4); // 24\n *\n * @example\n * // With pipe\n * import { pipe } from \"@/utils\";\n * const divide = (divisor: number, dividend: number) => dividend / divisor;\n * const result = pipe(100, curry(divide)(2), (n) => n + 1); // 51\n *\n * @example\n * // With Result validators\n * import { ok, err, flatMapResult, type Result } from \"@/index\";\n * const between = (min: number, max: number, n: number): Result<number, string> =>\n *   n >= min && n <= max ? ok(n) : err(`Value must be between ${min} and ${max}`);\n * const validateAge = curry(between)(0)(120);\n * pipe(ok(25), (r) => flatMapResult(r, validateAge)); // ok(25)\n *\n * @param fn - The multi-argument function to transform into a unary curried chain\n * @returns A curried function that takes one argument at each application step\n */\n\n// 2-arity\nexport function curry<A, B, R>(fn: (a: A, b: B) => R): (a: A) => (b: B) => R;\n\n// 3-arity\nexport function curry<A, B, C, R>(fn: (a: A, b: B, c: C) => R): (a: A) => (b: B) => (c: C) => R;\n\n// 4-arity\nexport function curry<A, B, C, D, R>(fn: (a: A, b: B, c: C, d: D) => R): (a: A) => (b: B) => (c: C) => (d: D) => R;\n\n// 5-arity\nexport function curry<A, B, C, D, E, R>(\n  fn: (a: A, b: B, c: C, d: D, e: E) => R,\n): (a: A) => (b: B) => (c: C) => (d: D) => (e: E) => R;\n\n// Implementation\nexport function curry<T extends UnknownFunction>(fn: T): UnknownFunction {\n  const arity = fn.length;\n\n  return function curried(...args: unknown[]): unknown {\n    if (args.length >= arity) {\n      return (fn as UnknownFunction)(...args);\n    }\n\n    return function (...nextArgs: unknown[]): unknown {\n      return curried(...args, ...nextArgs);\n    };\n  };\n}\n","type UnknownFunction = (...params: unknown[]) => unknown;\n\n/**\n * Uncurries a curried unary function chain back into a multi-argument function.\n * Inverse of `curry`. Useful when calling curried APIs with positional arguments.\n *\n * Note: Expects strictly unary nesting (the shape produced by `curry`).\n *\n * @example\n * // 2-arity\n * const addCurried = (a: number) => (b: number) => a + b;\n * const add = uncurry(addCurried);\n * add(5, 3); // 8\n *\n * @example\n * // 3-arity\n * const multiplyCurried = (a: number) => (b: number) => (c: number) => a * b * c;\n * const multiply = uncurry(multiplyCurried);\n * multiply(2, 3, 4); // 24\n *\n * @example\n * // Round-trip with curry\n * import { curry } from \"@railway-ts/pipelines\";\n * const divide = (divisor: number, dividend: number) => dividend / divisor;\n * const divideCurried = curry(divide);\n * const divideUncurried = uncurry(divideCurried);\n * divideUncurried(2, 100); // 50\n *\n * @param fn - A curried unary function chain (e.g., a => b => c => r)\n * @returns A multi-argument function equivalent to applying the curried chain in sequence\n */\n\n// Overloads ordered from most specific (5-arity) to least specific (2-arity)\n// This ensures TypeScript matches the correct overload\n\n// 5-arity\nexport function uncurry<A, B, C, D, E, R>(\n  fn: (a: A) => (b: B) => (c: C) => (d: D) => (e: E) => R,\n): (a: A, b: B, c: C, d: D, e: E) => R;\n\n// 5-arity\nexport function uncurry<A, B, C, D, E, R>(\n  fn: (a: A) => (b: B) => (c: C) => (d: D) => (e: E) => R,\n): (a: A, b: B, c: C, d: D, e: E) => R;\n\n// 4-arity\nexport function uncurry<A, B, C, D, R>(fn: (a: A) => (b: B) => (c: C) => (d: D) => R): (a: A, b: B, c: C, d: D) => R;\n\n// 3-arity\nexport function uncurry<A, B, C, R>(fn: (a: A) => (b: B) => (c: C) => R): (a: A, b: B, c: C) => R;\n\n// 2-arity\nexport function uncurry<A, B, R>(fn: (a: A) => (b: B) => R): (a: A, b: B) => R;\n\n// 1-arity (identity - technically not curried, but allows for consistent API)\nexport function uncurry<A, R>(fn: (a: A) => R): (a: A) => R;\n\n// Implementation - looser types allow overloads to work correctly\nexport function uncurry(fn: unknown): unknown {\n  return function uncurried(...args: unknown[]): unknown {\n    // Apply arguments sequentially to the curried function chain\n    let result = fn;\n\n    for (const arg of args) {\n      result = (result as UnknownFunction)(arg);\n    }\n\n    return result;\n  };\n}\n","type UnknownFunction = (...params: unknown[]) => unknown;\n\n/**\n * Transforms a multi-argument function into one that accepts a single tuple argument.\n * This makes multi-arg functions composable in `pipe`/`flow` when your data is a tuple.\n *\n * @example\n * // Basic\n * const add = (a: number, b: number) => a + b;\n * const tupledAdd = tupled(add);\n * tupledAdd([5, 3]); // 8\n *\n * @example\n * // With pipe (tuple input)\n * import { pipe } from \"@/utils\";\n * const distance = (x: number, y: number) => Math.hypot(x, y);\n * pipe([3, 4] as [number, number], tupled(distance)); // 5\n *\n * @example\n * // With Result\n * import { ok, err, flatMapResult, mapResult, type Result } from \"@railway-ts/pipelines/result\";\n * const divide = (dividend: number, divisor: number): Result<number, string> =>\n *   divisor === 0 ? err(\"Division by zero\") : ok(dividend / divisor);\n * const tupledDivide = tupled(divide);\n * pipe(ok<[number, number], string>([10, 2]),\n *   (r) => flatMapResult(r, tupledDivide),\n *   (r) => mapResult(r, (n) => n * 2)\n * ); // ok(10)\n *\n * @example\n * // With Option\n * import { some, none, flatMapOption, type Option } from \"@railway-ts/pipelines/option\";\n * const safeParse = (str: string, radix: number): Option<number> => {\n *   const n = Number.parseInt(str, radix);\n *   return Number.isNaN(n) ? none() : some(n);\n * };\n * const tupledParse = tupled(safeParse);\n * flatMapOption(some([\"FF\", 16] as [string, number]), tupledParse); // some(255)\n *\n * @param fn - A function taking positional arguments to be adapted to a single tuple argument\n * @returns A function that takes a tuple and applies it to `fn` as positional args\n */\n\n// 2-arity\nexport function tupled<A, B, R>(fn: (a: A, b: B) => R): (args: [A, B]) => R;\n\n// 3-arity\nexport function tupled<A, B, C, R>(fn: (a: A, b: B, c: C) => R): (args: [A, B, C]) => R;\n\n// 4-arity\nexport function tupled<A, B, C, D, R>(fn: (a: A, b: B, c: C, d: D) => R): (args: [A, B, C, D]) => R;\n\n// 5-arity\nexport function tupled<A, B, C, D, E, R>(fn: (a: A, b: B, c: C, d: D, e: E) => R): (args: [A, B, C, D, E]) => R;\n\n// Implementation\nexport function tupled<T extends UnknownFunction>(fn: T): (args: unknown[]) => unknown {\n  return function tupledFn(args: unknown[]): unknown {\n    return fn(...args);\n  };\n}\n","type UnknownFunction = (...params: unknown[]) => unknown;\n\n/**\n * Transforms a function that accepts a tuple into a multi-argument function.\n * Inverse of `tupled`. Useful when callers have positional arguments but your core API uses tuples.\n *\n * @example\n * // Basic\n * const tupledAdd = ([a, b]: [number, number]) => a + b;\n * const add = untupled(tupledAdd);\n * add(5, 3); // 8\n *\n * @example\n * // 3-arity\n * const sum3Tupled = ([a, b, c]: [number, number, number]) => a + b + c;\n * const sum3 = untupled(sum3Tupled);\n * sum3(1, 2, 3); // 6\n *\n * @example\n * // With Result\n * import { ok, err, flatMapResult, type Result } from \"@railway-ts/pipelines/result\";\n * const validateRange = ([min, max, value]: [number, number, number]): Result<number, string> =>\n *   value >= min && value <= max ? ok(value) : err(`Value ${value} not between ${min} and ${max}`);\n * const validate = untupled(validateRange);\n * flatMapResult(ok(50), (n) => validate(0, 100, n)); // ok(50)\n *\n * @example\n * // With Option\n * import { some, none, type Option } from \"@railway-ts/pipelines/option\";\n * const parsePair = ([x, y]: [string, string]): Option<number> => {\n *   const a = Number(x), b = Number(y);\n *   return Number.isNaN(a) || Number.isNaN(b) ? none() : some(a + b);\n * };\n * const parse = untupled(parsePair);\n * parse(\"2\", \"3\"); // some(5)\n *\n * @param fn - A function that accepts a tuple of arguments\n * @returns A function that accepts the same arguments positionally\n */\n\n// 2-arity\nexport function untupled<A, B, R>(fn: (args: [A, B]) => R): (a: A, b: B) => R;\n\n// 3-arity\nexport function untupled<A, B, C, R>(fn: (args: [A, B, C]) => R): (a: A, b: B, c: C) => R;\n\n// 4-arity\nexport function untupled<A, B, C, D, R>(fn: (args: [A, B, C, D]) => R): (a: A, b: B, c: C, d: D) => R;\n\n// 5-arity\nexport function untupled<A, B, C, D, E, R>(fn: (args: [A, B, C, D, E]) => R): (a: A, b: B, c: C, d: D, e: E) => R;\n\n// Implementation\nexport function untupled<T extends UnknownFunction>(fn: T): UnknownFunction {\n  return function untupledFn(...args: unknown[]): unknown {\n    return fn(args);\n  };\n}\n"]}
+{"version":3,"sources":["../../src/composition/pipe.ts","../../src/composition/flow.ts","../../src/composition/pipe-async.ts","../../src/composition/flow-async.ts","../../src/composition/curry.ts","../../src/composition/uncurry.ts","../../src/composition/tupled.ts","../../src/composition/untupled.ts"],"names":[],"mappings":";;;AA8GO,SAAS,IAAA,CAAK,UAAmB,GAAA,EAAiC;AACvE,EAAA,IAAI,MAAA,GAAS,KAAA;AACb,EAAA,KAAA,MAAW,MAAM,GAAA,EAAK;AACpB,IAAA,MAAA,GAAS,GAAG,MAAM,CAAA;AAAA,EACpB;AACA,EAAA,OAAO,MAAA;AACT;;;ACkBO,SAAS,QAAQ,GAAA,EAA+D;AACrF,EAAA,IAAI,GAAA,CAAI,WAAW,CAAA,EAAG;AACpB,IAAA,OAAO,IAAI,CAAC,CAAA;AAAA,EACd;AAEA,EAAA,MAAM,CAAC,KAAA,EAAO,GAAG,IAAI,CAAA,GAAI,GAAA;AACzB,EAAA,OAAO,IAAI,IAAA,KAA6B;AACtC,IAAA,IAAI,MAAA,GAAS,KAAA,CAAM,GAAG,IAAI,CAAA;AAC1B,IAAA,KAAA,MAAW,MAAM,IAAA,EAAM;AACrB,MAAA,MAAA,GAAS,GAAG,MAAM,CAAA;AAAA,IACpB;AACA,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AACF;;;AC5CA,eAAsB,SAAA,CAAU,MAAe,GAAA,EAA0C;AACvF,EAAA,IAAI,SAAS,MAAM,CAAA;AACnB,EAAA,KAAA,MAAW,MAAM,GAAA,EAAK;AACpB,IAAA,MAAA,GAAS,MAAM,GAAG,MAAM,CAAA;AAAA,EAC1B;AACA,EAAA,OAAO,MAAA;AACT;;;ACHO,SAAS,SAAA,CACd,UACG,GAAA,EACuC;AAC1C,EAAA,OAAO,UAAU,IAAA,KAAoB;AACnC,IAAA,IAAI,MAAA,GAAS,MAAM,KAAA,CAAM,GAAG,IAAI,CAAA;AAChC,IAAA,KAAA,MAAW,MAAM,GAAA,EAAK;AACpB,MAAA,MAAA,GAAS,MAAM,GAAG,MAAM,CAAA;AAAA,IAC1B;AACA,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AACF;;;AChEO,SAAS,MAAiC,EAAA,EAAwB;AACvE,EAAA,MAAM,QAAQ,EAAA,CAAG,MAAA;AAEjB,EAAA,OAAO,SAAS,WAAW,IAAA,EAA0B;AACnD,IAAA,IAAI,IAAA,CAAK,UAAU,KAAA,EAAO;AACxB,MAAA,OAAQ,EAAA,CAAuB,GAAG,IAAI,CAAA;AAAA,IACxC;AAEA,IAAA,OAAO,YAAa,QAAA,EAA8B;AAChD,MAAA,OAAO,OAAA,CAAQ,GAAG,IAAA,EAAM,GAAG,QAAQ,CAAA;AAAA,IACrC,CAAA;AAAA,EACF,CAAA;AACF;;;ACPO,SAAS,QAAQ,EAAA,EAAsB;AAC5C,EAAA,OAAO,SAAS,aAAa,IAAA,EAA0B;AAErD,IAAA,IAAI,MAAA,GAAS,EAAA;AAEb,IAAA,KAAA,MAAW,OAAO,IAAA,EAAM;AACtB,MAAA,MAAA,GAAU,OAA2B,GAAG,CAAA;AAAA,IAC1C;AAEA,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AACF;;;ACbO,SAAS,OAAkC,EAAA,EAAqC;AACrF,EAAA,OAAO,SAAS,SAAS,IAAA,EAA0B;AACjD,IAAA,OAAO,EAAA,CAAG,GAAG,IAAI,CAAA;AAAA,EACnB,CAAA;AACF;;;ACPO,SAAS,SAAoC,EAAA,EAAwB;AAC1E,EAAA,OAAO,SAAS,cAAc,IAAA,EAA0B;AACtD,IAAA,OAAO,GAAG,IAAI,CAAA;AAAA,EAChB,CAAA;AACF","file":"index.cjs","sourcesContent":["import type { UnknownFunction } from './types';\n\n/**\n * Pipes a value through a series of functions, from left to right.\n * Each function receives the output of the previous function.\n * Unlike flow, pipe immediately executes the functions with the provided initial value.\n *\n * @example\n * // Basic usage\n * const result = pipe(\n *   5,\n *   (n) => n * 2,      // 10\n *   (n) => n + 1,      // 11\n *   (n) => n.toString() // \"11\"\n * );\n * // result: \"11\"\n *\n * @example\n * // With Option\n * import { some, mapOption } from \"@railway-ts/pipelines/option\";\n *\n * const optionResult = pipe(\n *   some(5),\n *   (o) => mapOption(o, (n) => n * 2),\n *   (o) => mapOption(o, (n) => n.toString())\n * );\n * // optionResult: Option<string> containing \"10\"\n *\n * @example\n * // With Result\n * import { ok, mapResult } from \"@railway-ts/pipelines/result\";\n *\n * const resultValue = pipe(\n *   ok(5),\n *   (r) => mapResult(r, (n) => n * 2),\n *   (r) => mapResult(r, (n) => n.toString())\n * );\n * // resultValue: Result<string, never> containing \"10\"\n *\n * @param a - The initial value to pipe through the functions\n * @param ab - The first function to apply to the initial value\n * @param functions - Additional functions to apply in sequence\n * @returns The final result after applying all functions\n */\n\nexport function pipe<A, B>(a: A, ab: (this: void, a: A) => B): B;\nexport function pipe<A, B, C>(a: A, ab: (this: void, a: A) => B, bc: (this: void, b: B) => C): C;\nexport function pipe<A, B, C, D>(\n  a: A,\n  ab: (this: void, a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n): D;\nexport function pipe<A, B, C, D, E>(\n  a: A,\n  ab: (this: void, a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n): E;\nexport function pipe<A, B, C, D, E, F>(\n  a: A,\n  ab: (this: void, a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n): F;\nexport function pipe<A, B, C, D, E, F, G>(\n  a: A,\n  ab: (this: void, a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  a: A,\n  ab: (this: void, a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n  gh: (this: void, g: G) => H,\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  a: A,\n  ab: (this: void, a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n  gh: (this: void, g: G) => H,\n  hi: (this: void, h: H) => I,\n): I;\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(\n  a: A,\n  ab: (this: void, a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n  gh: (this: void, g: G) => H,\n  hi: (this: void, h: H) => I,\n  ij: (this: void, i: I) => J,\n): J;\nexport function pipe(value: unknown, ...fns: UnknownFunction[]): unknown {\n  let result = value;\n  for (const fn of fns) {\n    result = fn(result);\n  }\n  return result;\n}\n","import type { UnknownFunction } from './types';\n\n/**\n * Creates a new function that is the composition of the provided functions, applied from left to right.\n * Unlike pipe, flow doesn't immediately execute the functions but returns a new function that,\n * when called, will run the composed functions in sequence.\n *\n * @example\n * // Basic usage\n * const processNumber = flow(\n *   (n: number) => n * 2,\n *   (n) => n + 1,\n *   (n) => n.toString()\n * );\n *\n * const result = processNumber(5); // \"11\"\n *\n * @example\n * // With multiple arguments\n * const formatName = flow(\n *   (first: string, last: string) => `${first} ${last}`,\n *   (name) => name.toUpperCase()\n * );\n *\n * const name = formatName(\"John\", \"Doe\"); // \"JOHN DOE\"\n *\n * @example\n * // With Option type\n * import { some, none, mapOption, flatMapOption, type Option } from \"@railway-ts/pipelines/option\";\n *\n * const safeParseInt = (radix: number) => (str: string): Option<number> => {\n *   const n = Number.parseInt(str, radix);\n *   return Number.isNaN(n) ? none() : some(n);\n * };\n *\n * const processString = flow(\n *   (s: string) => some(s),\n *   (o) => mapOption(o, (s) => s + \"0\"),\n *   (o) => flatMapOption(o, safeParseInt(10))\n * );\n *\n * const option = processString(\"42\"); // Option<number> containing 420\n *\n * @example\n * // With Result type\n * import { ok, err, flatMapResult } from \"@railway-ts/pipelines/result\";\n *\n * const validatePositive = (n: number) => (n > 0 ? ok(n) : err(\"Not positive\"));\n *\n * const validateNumber = flow(\n *   (n: number) => ok(n),\n *   (r) => flatMapResult(r, validatePositive),\n *   (r) => flatMapResult(r, (n) => ok(n * 2))\n * );\n *\n * const result = validateNumber(5); // Result<number, string> containing 10\n *\n * @param ab - The first function in the composition\n * @param functions - Additional functions to compose in sequence\n * @returns A new function that applies all the composed functions in sequence\n */\nexport function flow<A extends unknown[], B>(ab: (this: void, ...a: A) => B): (...a: A) => B;\nexport function flow<A extends unknown[], B, C>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n): (...a: A) => C;\nexport function flow<A extends unknown[], B, C, D>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n): (...a: A) => D;\nexport function flow<A extends unknown[], B, C, D, E>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n): (...a: A) => E;\nexport function flow<A extends unknown[], B, C, D, E, F>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n): (...a: A) => F;\nexport function flow<A extends unknown[], B, C, D, E, F, G>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n): (...a: A) => G;\nexport function flow<A extends unknown[], B, C, D, E, F, G, H>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n  gh: (this: void, g: G) => H,\n): (...a: A) => H;\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n  gh: (this: void, g: G) => H,\n  hi: (this: void, h: H) => I,\n): (...a: A) => I;\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n  gh: (this: void, g: G) => H,\n  hi: (this: void, h: H) => I,\n  ij: (this: void, i: I) => J,\n): (...a: A) => J;\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K>(\n  ab: (this: void, ...a: A) => B,\n  bc: (this: void, b: B) => C,\n  cd: (this: void, c: C) => D,\n  de: (this: void, d: D) => E,\n  ef: (this: void, e: E) => F,\n  fg: (this: void, f: F) => G,\n  gh: (this: void, g: G) => H,\n  hi: (this: void, h: H) => I,\n  ij: (this: void, i: I) => J,\n  jk: (this: void, j: J) => K,\n): (...a: A) => K;\nexport function flow(...fns: [UnknownFunction, ...UnknownFunction[]]): UnknownFunction {\n  if (fns.length === 1) {\n    return fns[0];\n  }\n\n  const [first, ...rest] = fns;\n  return (...args: unknown[]): unknown => {\n    let result = first(...args);\n    for (const fn of rest) {\n      result = fn(result);\n    }\n    return result;\n  };\n}\n","import type { MaybeAsync, UnknownFunction } from './types';\n\n/**\n * Pipes a value through a series of potentially async functions, from left to right.\n * Each function receives the awaited output of the previous function.\n * Unlike pipe, pipeAsync awaits between each step, enabling async composition.\n *\n * @example\n * // Basic async usage\n * const result = await pipeAsync(\n *   5,\n *   async (n) => n * 2,    // 10\n *   (n) => n + 1,           // 11\n *   async (n) => n.toString() // \"11\"\n * );\n * // result: \"11\"\n *\n * @example\n * // With Result and curried helpers\n * import { ok, flatMapWith, mapWith } from \"@railway-ts/pipelines/result\";\n *\n * const result = await pipeAsync(\n *   ok(5),\n *   flatMapWith(async (n) => ok(n * 2)),\n *   mapWith((n) => n.toString())\n * );\n * // result: Result<string, never> containing \"10\"\n *\n * @param a - The initial value (or Promise) to pipe through the functions\n * @param ab - The first function to apply to the initial value\n * @param functions - Additional functions to apply in sequence\n * @returns A Promise of the final result after applying all functions\n */\n\nexport function pipeAsync<A, B>(a: MaybeAsync<A>, ab: (this: void, a: A) => MaybeAsync<B>): Promise<B>;\nexport function pipeAsync<A, B, C>(\n  a: MaybeAsync<A>,\n  ab: (this: void, a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n): Promise<C>;\nexport function pipeAsync<A, B, C, D>(\n  a: MaybeAsync<A>,\n  ab: (this: void, a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n): Promise<D>;\nexport function pipeAsync<A, B, C, D, E>(\n  a: MaybeAsync<A>,\n  ab: (this: void, a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n  de: (this: void, d: D) => MaybeAsync<E>,\n): Promise<E>;\nexport function pipeAsync<A, B, C, D, E, F>(\n  a: MaybeAsync<A>,\n  ab: (this: void, a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n  de: (this: void, d: D) => MaybeAsync<E>,\n  ef: (this: void, e: E) => MaybeAsync<F>,\n): Promise<F>;\nexport function pipeAsync<A, B, C, D, E, F, G>(\n  a: MaybeAsync<A>,\n  ab: (this: void, a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n  de: (this: void, d: D) => MaybeAsync<E>,\n  ef: (this: void, e: E) => MaybeAsync<F>,\n  fg: (this: void, f: F) => MaybeAsync<G>,\n): Promise<G>;\nexport function pipeAsync<A, B, C, D, E, F, G, H>(\n  a: MaybeAsync<A>,\n  ab: (this: void, a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n  de: (this: void, d: D) => MaybeAsync<E>,\n  ef: (this: void, e: E) => MaybeAsync<F>,\n  fg: (this: void, f: F) => MaybeAsync<G>,\n  gh: (this: void, g: G) => MaybeAsync<H>,\n): Promise<H>;\nexport function pipeAsync<A, B, C, D, E, F, G, H, I>(\n  a: MaybeAsync<A>,\n  ab: (this: void, a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n  de: (this: void, d: D) => MaybeAsync<E>,\n  ef: (this: void, e: E) => MaybeAsync<F>,\n  fg: (this: void, f: F) => MaybeAsync<G>,\n  gh: (this: void, g: G) => MaybeAsync<H>,\n  hi: (this: void, h: H) => MaybeAsync<I>,\n): Promise<I>;\nexport function pipeAsync<A, B, C, D, E, F, G, H, I, J>(\n  a: MaybeAsync<A>,\n  ab: (this: void, a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n  de: (this: void, d: D) => MaybeAsync<E>,\n  ef: (this: void, e: E) => MaybeAsync<F>,\n  fg: (this: void, f: F) => MaybeAsync<G>,\n  gh: (this: void, g: G) => MaybeAsync<H>,\n  hi: (this: void, h: H) => MaybeAsync<I>,\n  ij: (this: void, i: I) => MaybeAsync<J>,\n): Promise<J>;\nexport async function pipeAsync(a: unknown, ...fns: UnknownFunction[]): Promise<unknown> {\n  let result = await a;\n  for (const fn of fns) {\n    result = await fn(result);\n  }\n  return result;\n}\n","import type { MaybeAsync, UnknownFunction } from './types';\n\n/**\n * Creates a new function that is the async composition of the provided functions, applied from left to right.\n * Unlike flow, flowAsync awaits between each step, enabling async composition.\n * The returned function always returns a Promise.\n *\n * @example\n * // Basic async usage\n * const processNumber = flowAsync(\n *   async (n: number) => n * 2,\n *   (n) => n + 1,\n *   async (n) => n.toString()\n * );\n *\n * const result = await processNumber(5); // \"11\"\n *\n * @example\n * // With Result and curried helpers\n * import { ok, flatMapWith, mapWith } from \"@railway-ts/pipelines/result\";\n *\n * const process = flowAsync(\n *   (n: number) => ok(n),\n *   flatMapWith(async (n) => ok(n * 2)),\n *   mapWith((n) => n.toString())\n * );\n *\n * const result = await process(5); // Result<string, never> containing \"10\"\n *\n * @param ab - The first function in the composition\n * @param functions - Additional functions to compose in sequence\n * @returns A new function that applies all the composed functions in sequence, returning a Promise\n */\nexport function flowAsync<A extends unknown[], B>(ab: (this: void, ...a: A) => MaybeAsync<B>): (...a: A) => Promise<B>;\nexport function flowAsync<A extends unknown[], B, C>(\n  ab: (this: void, ...a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n): (...a: A) => Promise<C>;\nexport function flowAsync<A extends unknown[], B, C, D>(\n  ab: (this: void, ...a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n): (...a: A) => Promise<D>;\nexport function flowAsync<A extends unknown[], B, C, D, E>(\n  ab: (this: void, ...a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n  de: (this: void, d: D) => MaybeAsync<E>,\n): (...a: A) => Promise<E>;\nexport function flowAsync<A extends unknown[], B, C, D, E, F>(\n  ab: (this: void, ...a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n  de: (this: void, d: D) => MaybeAsync<E>,\n  ef: (this: void, e: E) => MaybeAsync<F>,\n): (...a: A) => Promise<F>;\nexport function flowAsync<A extends unknown[], B, C, D, E, F, G>(\n  ab: (this: void, ...a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n  de: (this: void, d: D) => MaybeAsync<E>,\n  ef: (this: void, e: E) => MaybeAsync<F>,\n  fg: (this: void, f: F) => MaybeAsync<G>,\n): (...a: A) => Promise<G>;\nexport function flowAsync<A extends unknown[], B, C, D, E, F, G, H>(\n  ab: (this: void, ...a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n  de: (this: void, d: D) => MaybeAsync<E>,\n  ef: (this: void, e: E) => MaybeAsync<F>,\n  fg: (this: void, f: F) => MaybeAsync<G>,\n  gh: (this: void, g: G) => MaybeAsync<H>,\n): (...a: A) => Promise<H>;\nexport function flowAsync<A extends unknown[], B, C, D, E, F, G, H, I>(\n  ab: (this: void, ...a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n  de: (this: void, d: D) => MaybeAsync<E>,\n  ef: (this: void, e: E) => MaybeAsync<F>,\n  fg: (this: void, f: F) => MaybeAsync<G>,\n  gh: (this: void, g: G) => MaybeAsync<H>,\n  hi: (this: void, h: H) => MaybeAsync<I>,\n): (...a: A) => Promise<I>;\nexport function flowAsync<A extends unknown[], B, C, D, E, F, G, H, I, J>(\n  ab: (this: void, ...a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n  de: (this: void, d: D) => MaybeAsync<E>,\n  ef: (this: void, e: E) => MaybeAsync<F>,\n  fg: (this: void, f: F) => MaybeAsync<G>,\n  gh: (this: void, g: G) => MaybeAsync<H>,\n  hi: (this: void, h: H) => MaybeAsync<I>,\n  ij: (this: void, i: I) => MaybeAsync<J>,\n): (...a: A) => Promise<J>;\nexport function flowAsync<A extends unknown[], B, C, D, E, F, G, H, I, J, K>(\n  ab: (this: void, ...a: A) => MaybeAsync<B>,\n  bc: (this: void, b: B) => MaybeAsync<C>,\n  cd: (this: void, c: C) => MaybeAsync<D>,\n  de: (this: void, d: D) => MaybeAsync<E>,\n  ef: (this: void, e: E) => MaybeAsync<F>,\n  fg: (this: void, f: F) => MaybeAsync<G>,\n  gh: (this: void, g: G) => MaybeAsync<H>,\n  hi: (this: void, h: H) => MaybeAsync<I>,\n  ij: (this: void, i: I) => MaybeAsync<J>,\n  jk: (this: void, j: J) => MaybeAsync<K>,\n): (...a: A) => Promise<K>;\nexport function flowAsync(\n  first: (...args: unknown[]) => unknown,\n  ...fns: UnknownFunction[]\n): (...args: unknown[]) => Promise<unknown> {\n  return async (...args: unknown[]) => {\n    let result = await first(...args);\n    for (const fn of fns) {\n      result = await fn(result);\n    }\n    return result;\n  };\n}\n","import type { UnknownFunction } from './types';\n\n/**\n * Curries a multi-parameter function into a sequence of unary functions.\n * Enables partial application at any depth and composes cleanly with `pipe`.\n *\n * Note: This curry is unary-only at each step to ensure compatibility with `pipe` and `flow`.\n *\n * @example\n * // Basic (2-arity)\n * const add = (a: number, b: number) => a + b;\n * const add5 = curry(add)(5);\n * add5(3); // 8\n *\n * @example\n * // 3-arity and partial application\n * const multiply = (a: number, b: number, c: number) => a * b * c;\n * const curriedMultiply = curry(multiply);\n * curriedMultiply(2)(3)(4); // 24\n *\n * @example\n * // With pipe\n * import { pipe } from \"@/utils\";\n * const divide = (divisor: number, dividend: number) => dividend / divisor;\n * const result = pipe(100, curry(divide)(2), (n) => n + 1); // 51\n *\n * @example\n * // With Result validators\n * import { ok, err, flatMap, type Result } from \"@/result\";\n * const between = (min: number, max: number, n: number): Result<number, string> =>\n *   n >= min && n <= max ? ok(n) : err(`Value must be between ${min} and ${max}`);\n * const validateAge = curry(between)(0)(120);\n * pipe(ok(25), (r) => flatMap(r, validateAge)); // ok(25)\n *\n * @param fn - The multi-argument function to transform into a unary curried chain\n * @returns A curried function that takes one argument at each application step\n */\n\n// 2-arity\nexport function curry<A, B, R>(fn: (a: A, b: B) => R): (a: A) => (b: B) => R;\n\n// 3-arity\nexport function curry<A, B, C, R>(fn: (a: A, b: B, c: C) => R): (a: A) => (b: B) => (c: C) => R;\n\n// 4-arity\nexport function curry<A, B, C, D, R>(fn: (a: A, b: B, c: C, d: D) => R): (a: A) => (b: B) => (c: C) => (d: D) => R;\n\n// 5-arity\nexport function curry<A, B, C, D, E, R>(\n  fn: (a: A, b: B, c: C, d: D, e: E) => R,\n): (a: A) => (b: B) => (c: C) => (d: D) => (e: E) => R;\n\n// Implementation\nexport function curry<T extends UnknownFunction>(fn: T): UnknownFunction {\n  const arity = fn.length;\n\n  return function curried(...args: unknown[]): unknown {\n    if (args.length >= arity) {\n      return (fn as UnknownFunction)(...args);\n    }\n\n    return function (...nextArgs: unknown[]): unknown {\n      return curried(...args, ...nextArgs);\n    };\n  };\n}\n","import type { UnknownFunction } from './types';\n\n/**\n * Uncurries a curried unary function chain back into a multi-argument function.\n * Inverse of `curry`. Useful when calling curried APIs with positional arguments.\n *\n * Note: Expects strictly unary nesting (the shape produced by `curry`).\n *\n * @example\n * // 2-arity\n * const addCurried = (a: number) => (b: number) => a + b;\n * const add = uncurry(addCurried);\n * add(5, 3); // 8\n *\n * @example\n * // 3-arity\n * const multiplyCurried = (a: number) => (b: number) => (c: number) => a * b * c;\n * const multiply = uncurry(multiplyCurried);\n * multiply(2, 3, 4); // 24\n *\n * @example\n * // Round-trip with curry\n * import { curry } from \"@railway-ts/pipelines\";\n * const divide = (divisor: number, dividend: number) => dividend / divisor;\n * const divideCurried = curry(divide);\n * const divideUncurried = uncurry(divideCurried);\n * divideUncurried(2, 100); // 50\n *\n * @param fn - A curried unary function chain (e.g., a => b => c => r)\n * @returns A multi-argument function equivalent to applying the curried chain in sequence\n */\n\n// Overloads ordered from most specific (5-arity) to least specific (2-arity)\n// This ensures TypeScript matches the correct overload\n\n// 5-arity\nexport function uncurry<A, B, C, D, E, R>(\n  fn: (a: A) => (b: B) => (c: C) => (d: D) => (e: E) => R,\n): (a: A, b: B, c: C, d: D, e: E) => R;\n\n// 5-arity\nexport function uncurry<A, B, C, D, E, R>(\n  fn: (a: A) => (b: B) => (c: C) => (d: D) => (e: E) => R,\n): (a: A, b: B, c: C, d: D, e: E) => R;\n\n// 4-arity\nexport function uncurry<A, B, C, D, R>(fn: (a: A) => (b: B) => (c: C) => (d: D) => R): (a: A, b: B, c: C, d: D) => R;\n\n// 3-arity\nexport function uncurry<A, B, C, R>(fn: (a: A) => (b: B) => (c: C) => R): (a: A, b: B, c: C) => R;\n\n// 2-arity\nexport function uncurry<A, B, R>(fn: (a: A) => (b: B) => R): (a: A, b: B) => R;\n\n// 1-arity (identity - technically not curried, but allows for consistent API)\nexport function uncurry<A, R>(fn: (a: A) => R): (a: A) => R;\n\n// Implementation - looser types allow overloads to work correctly\nexport function uncurry(fn: unknown): unknown {\n  return function uncurried(...args: unknown[]): unknown {\n    // Apply arguments sequentially to the curried function chain\n    let result = fn;\n\n    for (const arg of args) {\n      result = (result as UnknownFunction)(arg);\n    }\n\n    return result;\n  };\n}\n","import type { UnknownFunction } from './types';\n\n/**\n * Transforms a multi-argument function into one that accepts a single tuple argument.\n * This makes multi-arg functions composable in `pipe`/`flow` when your data is a tuple.\n *\n * @example\n * // Basic\n * const add = (a: number, b: number) => a + b;\n * const tupledAdd = tupled(add);\n * tupledAdd([5, 3]); // 8\n *\n * @example\n * // With pipe (tuple input)\n * import { pipe } from \"@/utils\";\n * const distance = (x: number, y: number) => Math.hypot(x, y);\n * pipe([3, 4] as [number, number], tupled(distance)); // 5\n *\n * @example\n * // With Result\n * import { ok, err, flatMapResult, mapResult, type Result } from \"@railway-ts/pipelines/result\";\n * const divide = (dividend: number, divisor: number): Result<number, string> =>\n *   divisor === 0 ? err(\"Division by zero\") : ok(dividend / divisor);\n * const tupledDivide = tupled(divide);\n * pipe(ok<[number, number], string>([10, 2]),\n *   (r) => flatMapResult(r, tupledDivide),\n *   (r) => mapResult(r, (n) => n * 2)\n * ); // ok(10)\n *\n * @example\n * // With Option\n * import { some, none, flatMapOption, type Option } from \"@railway-ts/pipelines/option\";\n * const safeParse = (str: string, radix: number): Option<number> => {\n *   const n = Number.parseInt(str, radix);\n *   return Number.isNaN(n) ? none() : some(n);\n * };\n * const tupledParse = tupled(safeParse);\n * flatMapOption(some([\"FF\", 16] as [string, number]), tupledParse); // some(255)\n *\n * @param fn - A function taking positional arguments to be adapted to a single tuple argument\n * @returns A function that takes a tuple and applies it to `fn` as positional args\n */\n\n// 2-arity\nexport function tupled<A, B, R>(fn: (a: A, b: B) => R): (args: [A, B]) => R;\n\n// 3-arity\nexport function tupled<A, B, C, R>(fn: (a: A, b: B, c: C) => R): (args: [A, B, C]) => R;\n\n// 4-arity\nexport function tupled<A, B, C, D, R>(fn: (a: A, b: B, c: C, d: D) => R): (args: [A, B, C, D]) => R;\n\n// 5-arity\nexport function tupled<A, B, C, D, E, R>(fn: (a: A, b: B, c: C, d: D, e: E) => R): (args: [A, B, C, D, E]) => R;\n\n// Implementation\nexport function tupled<T extends UnknownFunction>(fn: T): (args: unknown[]) => unknown {\n  return function tupledFn(args: unknown[]): unknown {\n    return fn(...args);\n  };\n}\n","import type { UnknownFunction } from './types';\n\n/**\n * Transforms a function that accepts a tuple into a multi-argument function.\n * Inverse of `tupled`. Useful when callers have positional arguments but your core API uses tuples.\n *\n * @example\n * // Basic\n * const tupledAdd = ([a, b]: [number, number]) => a + b;\n * const add = untupled(tupledAdd);\n * add(5, 3); // 8\n *\n * @example\n * // 3-arity\n * const sum3Tupled = ([a, b, c]: [number, number, number]) => a + b + c;\n * const sum3 = untupled(sum3Tupled);\n * sum3(1, 2, 3); // 6\n *\n * @example\n * // With Result\n * import { ok, err, flatMapResult, type Result } from \"@railway-ts/pipelines/result\";\n * const validateRange = ([min, max, value]: [number, number, number]): Result<number, string> =>\n *   value >= min && value <= max ? ok(value) : err(`Value ${value} not between ${min} and ${max}`);\n * const validate = untupled(validateRange);\n * flatMapResult(ok(50), (n) => validate(0, 100, n)); // ok(50)\n *\n * @example\n * // With Option\n * import { some, none, type Option } from \"@railway-ts/pipelines/option\";\n * const parsePair = ([x, y]: [string, string]): Option<number> => {\n *   const a = Number(x), b = Number(y);\n *   return Number.isNaN(a) || Number.isNaN(b) ? none() : some(a + b);\n * };\n * const parse = untupled(parsePair);\n * parse(\"2\", \"3\"); // some(5)\n *\n * @param fn - A function that accepts a tuple of arguments\n * @returns A function that accepts the same arguments positionally\n */\n\n// 2-arity\nexport function untupled<A, B, R>(fn: (args: [A, B]) => R): (a: A, b: B) => R;\n\n// 3-arity\nexport function untupled<A, B, C, R>(fn: (args: [A, B, C]) => R): (a: A, b: B, c: C) => R;\n\n// 4-arity\nexport function untupled<A, B, C, D, R>(fn: (args: [A, B, C, D]) => R): (a: A, b: B, c: C, d: D) => R;\n\n// 5-arity\nexport function untupled<A, B, C, D, E, R>(fn: (args: [A, B, C, D, E]) => R): (a: A, b: B, c: C, d: D, e: E) => R;\n\n// Implementation\nexport function untupled<T extends UnknownFunction>(fn: T): UnknownFunction {\n  return function untupledFn(...args: unknown[]): unknown {\n    return fn(args);\n  };\n}\n"]}

package/dist/composition/index.d.cts

@@ -1,3 +1,6 @@
+type MaybeAsync<T> = T | Promise<T>;
+type UnknownFunction = (...params: unknown[]) => unknown;
+
 /**
  * Pipes a value through a series of functions, from left to right.
  * Each function receives the output of the previous function.
@@ -120,6 +123,89 @@ declare function flow<A extends unknown[], B, C, D, E, F, G, H, I>(ab: (this: vo
 declare function flow<A extends unknown[], B, C, D, E, F, G, H, I, J>(ab: (this: void, ...a: A) => B, bc: (this: void, b: B) => C, cd: (this: void, c: C) => D, de: (this: void, d: D) => E, ef: (this: void, e: E) => F, fg: (this: void, f: F) => G, gh: (this: void, g: G) => H, hi: (this: void, h: H) => I, ij: (this: void, i: I) => J): (...a: A) => J;
 declare function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K>(ab: (this: void, ...a: A) => B, bc: (this: void, b: B) => C, cd: (this: void, c: C) => D, de: (this: void, d: D) => E, ef: (this: void, e: E) => F, fg: (this: void, f: F) => G, gh: (this: void, g: G) => H, hi: (this: void, h: H) => I, ij: (this: void, i: I) => J, jk: (this: void, j: J) => K): (...a: A) => K;
 
+/**
+ * Pipes a value through a series of potentially async functions, from left to right.
+ * Each function receives the awaited output of the previous function.
+ * Unlike pipe, pipeAsync awaits between each step, enabling async composition.
+ *
+ * @example
+ * // Basic async usage
+ * const result = await pipeAsync(
+ *   5,
+ *   async (n) => n * 2,    // 10
+ *   (n) => n + 1,           // 11
+ *   async (n) => n.toString() // "11"
+ * );
+ * // result: "11"
+ *
+ * @example
+ * // With Result and curried helpers
+ * import { ok, flatMapWith, mapWith } from "@railway-ts/pipelines/result";
+ *
+ * const result = await pipeAsync(
+ *   ok(5),
+ *   flatMapWith(async (n) => ok(n * 2)),
+ *   mapWith((n) => n.toString())
+ * );
+ * // result: Result<string, never> containing "10"
+ *
+ * @param a - The initial value (or Promise) to pipe through the functions
+ * @param ab - The first function to apply to the initial value
+ * @param functions - Additional functions to apply in sequence
+ * @returns A Promise of the final result after applying all functions
+ */
+declare function pipeAsync<A, B>(a: MaybeAsync<A>, ab: (this: void, a: A) => MaybeAsync<B>): Promise<B>;
+declare function pipeAsync<A, B, C>(a: MaybeAsync<A>, ab: (this: void, a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>): Promise<C>;
+declare function pipeAsync<A, B, C, D>(a: MaybeAsync<A>, ab: (this: void, a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>): Promise<D>;
+declare function pipeAsync<A, B, C, D, E>(a: MaybeAsync<A>, ab: (this: void, a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>, de: (this: void, d: D) => MaybeAsync<E>): Promise<E>;
+declare function pipeAsync<A, B, C, D, E, F>(a: MaybeAsync<A>, ab: (this: void, a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>, de: (this: void, d: D) => MaybeAsync<E>, ef: (this: void, e: E) => MaybeAsync<F>): Promise<F>;
+declare function pipeAsync<A, B, C, D, E, F, G>(a: MaybeAsync<A>, ab: (this: void, a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>, de: (this: void, d: D) => MaybeAsync<E>, ef: (this: void, e: E) => MaybeAsync<F>, fg: (this: void, f: F) => MaybeAsync<G>): Promise<G>;
+declare function pipeAsync<A, B, C, D, E, F, G, H>(a: MaybeAsync<A>, ab: (this: void, a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>, de: (this: void, d: D) => MaybeAsync<E>, ef: (this: void, e: E) => MaybeAsync<F>, fg: (this: void, f: F) => MaybeAsync<G>, gh: (this: void, g: G) => MaybeAsync<H>): Promise<H>;
+declare function pipeAsync<A, B, C, D, E, F, G, H, I>(a: MaybeAsync<A>, ab: (this: void, a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>, de: (this: void, d: D) => MaybeAsync<E>, ef: (this: void, e: E) => MaybeAsync<F>, fg: (this: void, f: F) => MaybeAsync<G>, gh: (this: void, g: G) => MaybeAsync<H>, hi: (this: void, h: H) => MaybeAsync<I>): Promise<I>;
+declare function pipeAsync<A, B, C, D, E, F, G, H, I, J>(a: MaybeAsync<A>, ab: (this: void, a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>, de: (this: void, d: D) => MaybeAsync<E>, ef: (this: void, e: E) => MaybeAsync<F>, fg: (this: void, f: F) => MaybeAsync<G>, gh: (this: void, g: G) => MaybeAsync<H>, hi: (this: void, h: H) => MaybeAsync<I>, ij: (this: void, i: I) => MaybeAsync<J>): Promise<J>;
+
+/**
+ * Creates a new function that is the async composition of the provided functions, applied from left to right.
+ * Unlike flow, flowAsync awaits between each step, enabling async composition.
+ * The returned function always returns a Promise.
+ *
+ * @example
+ * // Basic async usage
+ * const processNumber = flowAsync(
+ *   async (n: number) => n * 2,
+ *   (n) => n + 1,
+ *   async (n) => n.toString()
+ * );
+ *
+ * const result = await processNumber(5); // "11"
+ *
+ * @example
+ * // With Result and curried helpers
+ * import { ok, flatMapWith, mapWith } from "@railway-ts/pipelines/result";
+ *
+ * const process = flowAsync(
+ *   (n: number) => ok(n),
+ *   flatMapWith(async (n) => ok(n * 2)),
+ *   mapWith((n) => n.toString())
+ * );
+ *
+ * const result = await process(5); // Result<string, never> containing "10"
+ *
+ * @param ab - The first function in the composition
+ * @param functions - Additional functions to compose in sequence
+ * @returns A new function that applies all the composed functions in sequence, returning a Promise
+ */
+declare function flowAsync<A extends unknown[], B>(ab: (this: void, ...a: A) => MaybeAsync<B>): (...a: A) => Promise<B>;
+declare function flowAsync<A extends unknown[], B, C>(ab: (this: void, ...a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>): (...a: A) => Promise<C>;
+declare function flowAsync<A extends unknown[], B, C, D>(ab: (this: void, ...a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>): (...a: A) => Promise<D>;
+declare function flowAsync<A extends unknown[], B, C, D, E>(ab: (this: void, ...a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>, de: (this: void, d: D) => MaybeAsync<E>): (...a: A) => Promise<E>;
+declare function flowAsync<A extends unknown[], B, C, D, E, F>(ab: (this: void, ...a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>, de: (this: void, d: D) => MaybeAsync<E>, ef: (this: void, e: E) => MaybeAsync<F>): (...a: A) => Promise<F>;
+declare function flowAsync<A extends unknown[], B, C, D, E, F, G>(ab: (this: void, ...a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>, de: (this: void, d: D) => MaybeAsync<E>, ef: (this: void, e: E) => MaybeAsync<F>, fg: (this: void, f: F) => MaybeAsync<G>): (...a: A) => Promise<G>;
+declare function flowAsync<A extends unknown[], B, C, D, E, F, G, H>(ab: (this: void, ...a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>, de: (this: void, d: D) => MaybeAsync<E>, ef: (this: void, e: E) => MaybeAsync<F>, fg: (this: void, f: F) => MaybeAsync<G>, gh: (this: void, g: G) => MaybeAsync<H>): (...a: A) => Promise<H>;
+declare function flowAsync<A extends unknown[], B, C, D, E, F, G, H, I>(ab: (this: void, ...a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>, de: (this: void, d: D) => MaybeAsync<E>, ef: (this: void, e: E) => MaybeAsync<F>, fg: (this: void, f: F) => MaybeAsync<G>, gh: (this: void, g: G) => MaybeAsync<H>, hi: (this: void, h: H) => MaybeAsync<I>): (...a: A) => Promise<I>;
+declare function flowAsync<A extends unknown[], B, C, D, E, F, G, H, I, J>(ab: (this: void, ...a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>, de: (this: void, d: D) => MaybeAsync<E>, ef: (this: void, e: E) => MaybeAsync<F>, fg: (this: void, f: F) => MaybeAsync<G>, gh: (this: void, g: G) => MaybeAsync<H>, hi: (this: void, h: H) => MaybeAsync<I>, ij: (this: void, i: I) => MaybeAsync<J>): (...a: A) => Promise<J>;
+declare function flowAsync<A extends unknown[], B, C, D, E, F, G, H, I, J, K>(ab: (this: void, ...a: A) => MaybeAsync<B>, bc: (this: void, b: B) => MaybeAsync<C>, cd: (this: void, c: C) => MaybeAsync<D>, de: (this: void, d: D) => MaybeAsync<E>, ef: (this: void, e: E) => MaybeAsync<F>, fg: (this: void, f: F) => MaybeAsync<G>, gh: (this: void, g: G) => MaybeAsync<H>, hi: (this: void, h: H) => MaybeAsync<I>, ij: (this: void, i: I) => MaybeAsync<J>, jk: (this: void, j: J) => MaybeAsync<K>): (...a: A) => Promise<K>;
+
 /**
  * Curries a multi-parameter function into a sequence of unary functions.
  * Enables partial application at any depth and composes cleanly with `pipe`.
@@ -146,11 +232,11 @@ declare function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K>(ab: (th
  *
  * @example
  * // With Result validators
- * import { ok, err, flatMapResult, type Result } from "@/index";
+ * import { ok, err, flatMap, type Result } from "@/result";
  * const between = (min: number, max: number, n: number): Result<number, string> =>
  *   n >= min && n <= max ? ok(n) : err(`Value must be between ${min} and ${max}`);
  * const validateAge = curry(between)(0)(120);
- * pipe(ok(25), (r) => flatMapResult(r, validateAge)); // ok(25)
+ * pipe(ok(25), (r) => flatMap(r, validateAge)); // ok(25)
  *
  * @param fn - The multi-argument function to transform into a unary curried chain
  * @returns A curried function that takes one argument at each application step
@@ -283,4 +369,4 @@ declare function untupled<A, B, C, R>(fn: (args: [A, B, C]) => R): (a: A, b: B,
 declare function untupled<A, B, C, D, R>(fn: (args: [A, B, C, D]) => R): (a: A, b: B, c: C, d: D) => R;
 declare function untupled<A, B, C, D, E, R>(fn: (args: [A, B, C, D, E]) => R): (a: A, b: B, c: C, d: D, e: E) => R;
 
-export { curry, flow, pipe, tupled, uncurry, untupled };
+export { type MaybeAsync, type UnknownFunction, curry, flow, flowAsync, pipe, pipeAsync, tupled, uncurry, untupled };