@shirudo/result 1.1.0 → 1.2.0

package/README.md

@@ -1,15 +1,18 @@
 # @shirudo/result
 
-Robust, type-safe error handling for TypeScript.
+A `Result<T, E>` type for TypeScript. Functions return their failures instead of throwing them.
 
-`@shirudo/result` models expected failures as values instead of hidden exceptions. Functions return `Result<T, E>`, callers must handle both states, and TypeScript narrows access to `value` and `error` only when the state is known.
+```ts docs-check:skip
+function loadUser(id: string): Result<User, UserError>
+```
+
+The failure is part of the signature: callers see exactly what can go wrong, the compiler insists both cases are handled, and `value`/`error` are only accessible after narrowing. What used to be a forgotten `catch` is now a type error.
+
+The rest of the package is tooling around that one type: pipe operators, async variants, generator-based do-notation, exhaustive error matching, and collection helpers. The library has zero dependencies, ships as ESM and CJS, and runs on Node 20+ and edge runtimes.
 
 [![CI](https://github.com/shi-rudo/result-ts/actions/workflows/ci.yml/badge.svg)](https://github.com/shi-rudo/result-ts/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/@shirudo/result.svg)](https://www.npmjs.com/package/@shirudo/result)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.7%2B-blue.svg)](https://www.typescriptlang.org/)
-[![Node](https://img.shields.io/badge/Node-%3E%3D20-green.svg)](https://nodejs.org/)
-![Edge Runtime](https://img.shields.io/badge/Edge_Runtime-compatible-brightgreen.svg)
 
 ## Installation
 
@@ -22,12 +25,13 @@ yarn add @shirudo/result
 ## Quick Start
 
 ```ts
-import { Result } from '@shirudo/result';
+import { err, ok, type Result } from '@shirudo/result';
+import { map, match } from '@shirudo/result/operators';
 
 type User = { id: string; email: string; active: boolean };
 type UserError =
-    | { type: 'not-found'; id: string }
-    | { type: 'inactive'; id: string };
+    | { code: 'not-found'; id: string }
+    | { code: 'inactive'; id: string };
 
 const users = new Map<string, User>([
     ['1', { id: '1', email: 'ada@example.com', active: true }],
@@ -35,35 +39,53 @@ const users = new Map<string, User>([
 
 function loadUser(id: string): Result<User, UserError> {
     const user = users.get(id);
-    if (!user) return Result.err({ type: 'not-found', id });
-    if (!user.active) return Result.err({ type: 'inactive', id });
-    return Result.ok(user);
+    if (!user) return err({ code: 'not-found', id });
+    if (!user.active) return err({ code: 'inactive', id });
+    return ok(user);
 }
 
+// Narrow explicitly:
 const result = loadUser('1');
-
 if (result.isOk()) {
-    console.log(result.value.email);
-} else {
-    switch (result.error.type) {
-        case 'not-found':
-            console.error(`Missing user ${result.error.id}`);
-            break;
-        case 'inactive':
-            console.error(`Inactive user ${result.error.id}`);
-            break;
-    }
+    console.log(result.value.email); // `value` is only accessible in this branch
 }
+
+// Or compose and resolve in one expression. `map` only runs on Ok,
+// and the error keeps its type all the way to `match`:
+const message = loadUser('1').pipe(
+    map(user => `Welcome back, ${user.email}`),
+    match({
+        ok: greeting => greeting,
+        err: error =>
+            error.code === 'not-found'
+                ? `No user with id ${error.id}`
+                : `User ${error.id} is deactivated`,
+    }),
+);
 ```
 
-## Why This Library
+## Why Result Instead of try/catch?
+
+TypeScript cannot type a `catch` block: every thrown value arrives as `unknown`, and nothing in a function's signature reveals that it throws at all. Callers either remember to catch, or they find out in production.
+
+A `Result<User, UserError>` puts the failure into the signature. The compiler forces both states to be handled, narrows `value` and `error` access to the matching state (as in the Quick Start above), and keeps the error type intact across every transformation.
+
+## Why This Library?
+
+There are several Result implementations for TypeScript. This one is built around a few hard guarantees:
+
+- **Error types that cannot lie.** Declaring an explicit error type requires an error mapper: `fromPromise<User, ApiError>(promise)` without one is a compile error, so `E` never silently holds an unmapped `unknown`. And bugs inside the mapper itself are rethrown instead of being disguised as `Err` values.
+- **Exhaustive matching, checked at compile time.** `matchError().when(NotFoundError, ...).run()` only compiles once every error case is handled, and `matchTag` does the same for discriminated unions. Add a new error variant, and every unhandled match site turns red. For class-based matching the check is structural: give each error class a distinguishing member, for example a literal `readonly code`, because TypeScript cannot tell two classes of the same shape apart.
+- **Four interchangeable styles, one type.** Explicit `isOk()`/`isErr()` checks, `pipe`/`pipeAsync` operator chains, generator-based do-notation (`task`), and builder-based error matching all work on the same immutable, frozen `Result`. Use whichever style fits each call site.
+- **Safe at runtime boundaries.** `isResult()` validates an internal brand plus payload shape instead of accepting lookalike objects, and `toSerialized()` emits the discriminated `{ _tag, value | error }` shape, which `JSON.stringify` encodes exactly as it encodes the Result itself. `Ok(undefined)` survives the wire on its `_tag` alone, because `JSON.stringify` drops the `undefined` `value` key, and a validated payload rebuilds with plain `ok`/`err`.
+- **Zero dependencies, runs anywhere.** The package ships ESM and CJS builds with tree-shakeable subpath exports, and it runs on Node 20+ and in edge runtimes.
+- **Verified, not promised.** Every TypeScript snippet in this README and the docs is compile-checked in CI, the API is covered by 400+ runtime tests plus compile-time type tests, and the package exports are verified for ESM, CJS, and TypeScript consumers.
+
+## When Not to Use It
 
-- `Ok` does not expose `error`, and `Err` does not expose `value`; accidental reads require proper narrowing.
-- `isResult` uses a stable internal brand plus payload validation instead of accepting random lookalike objects.
-- `Result.fromPromise()` maps promise rejections but rethrows bugs inside the error mapper.
-- Sync, async, generator, collection, and matching workflows are first-class.
-- README and docs TypeScript snippets are compile-checked.
-- Package exports are tested for ESM, CJS, and TypeScript consumers.
+- If your codebase is already built on [Effect](https://effect.website/), you do not need this package. Its `Either`/`Exit` types come with the surrounding ecosystem.
+- For short scripts and prototypes, plain `try`/`catch` is often the simpler tool. The value of typed errors grows with the number of call sites that must handle them.
+- Keep throwing for programmer errors. Broken invariants and failed assertions should crash loudly; `Result` is for failures the caller is expected to handle.
 
 ## Common Workflows
 
@@ -74,14 +96,14 @@ import { Result } from '@shirudo/result';
 
 const parseJson = Result.fromThrowable(
     JSON.parse,
-    error => ({ type: 'parse' as const, cause: error }),
+    error => ({ code: 'parse' as const, cause: error }),
 );
 
 const parsed = parseJson('{"valid": true}');
 
 const response = await Result.fromPromise(
     Promise.resolve({ ok: true }),
-    error => ({ type: 'network' as const, cause: error }),
+    error => ({ code: 'network' as const, cause: error }),
 );
 ```
 
@@ -131,27 +153,53 @@ function findUser(id: string) {
 function ensureEmail(user: { id: string; email?: string }) {
     return user.email
         ? Result.ok(user.email)
-        : Result.err({ type: 'missing-email' as const, id: user.id });
+        : Result.err({ code: 'missing-email' as const, id: user.id });
 }
 
-const email = task(function* () {
+const emailResult = await task(function* () {
     const user = yield* findUser('1');
     return yield* ensureEmail(user);
 });
 ```
 
+### Handle error classes exhaustively
+
+```ts
+import { Result } from '@shirudo/result';
+
+class NotFoundError extends Error {
+    readonly code = 'not-found';
+}
+class RateLimitError extends Error {
+    readonly code = 'rate-limited';
+    constructor(readonly retryAfter: number) {
+        super(`rate limited, retry in ${retryAfter}s`);
+    }
+}
+
+const result: Result<string, NotFoundError | RateLimitError> = Result.err(new RateLimitError(30));
+
+if (result.isErr()) {
+    const message = result
+        .matchError()
+        .when(NotFoundError, () => 'No such record')
+        .when(RateLimitError, error => `Retry in ${error.retryAfter}s`)
+        .run(); // run() only compiles because every error class is handled
+}
+```
+
 ### Match discriminated-union errors
 
 ```ts
 import { Result, matchTag } from '@shirudo/result';
 
 type DomainError =
-    | { type: 'network'; retryAfter: number }
-    | { type: 'validation'; field: string };
+    | { code: 'network'; retryAfter: number }
+    | { code: 'validation'; field: string };
 
-const failed = Result.err<DomainError>({ type: 'network', retryAfter: 30 });
+const failed = Result.err<DomainError>({ code: 'network', retryAfter: 30 });
 
-const message = matchTag(failed, 'type', {
+const message = matchTag(failed, 'code', {
     network: error => `Retry in ${error.retryAfter}s`,
     validation: error => `Invalid field: ${error.field}`,
 });
@@ -186,7 +234,11 @@ The full documentation lives in `docs/` and is built with VitePress.
 - [Collections](docs/api/collections.md)
 - [Error Classes](docs/api/errors.md)
 - [Version 1 Migration](docs/migration/v1.md)
-- [Design Decisions](docs/decisions/lazy-async-abstraction.md)
+- [Design Decisions](docs/decisions/lazy-async-abstraction.md) ([Defensive State Checks](docs/decisions/defensive-state-checks.md))
+
+## Agent Skill
+
+The repository ships an agent skill for AI coding assistants in [`skills/result-ts/`](skills/result-ts/). Copy the folder into your project's skill directory (for example `.claude/skills/` for Claude Code or `.agents/skills/` for other agents). It gives your assistant the API cheatsheet, refactoring patterns, and best practices for `@shirudo/result`; every snippet in it is compile-checked in this repository's CI.
 
 ## Development
 

package/dist/collections.cjs

@@ -1,13 +1,185 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_result = require('./result-BBOGxvSH.cjs');
-const require_flatten = require('./flatten-B_XIkaOK.cjs');
+const require_result = require('./result-DoqQufvR.cjs');
+const require_errors = require('./errors-CVgC7NII.cjs');
 
+//#region src/core/sequenceRecord.ts
+/**
+* Like `sequence`, but for Records/Objects.
+* Short-circuits on the first Err.
+*
+* A non-enumerable own property is an input only when it holds a `Result`, so a
+* hidden helper field of another type is ignored. An array throws, because its
+* indices would sequence into an object; use `sequence` for a list.
+*/
+function sequenceRecord(record) {
+	if (Array.isArray(record)) throw new require_errors.InvalidResultStateError("sequenceRecord");
+	const out = {};
+	for (const key of Reflect.ownKeys(record)) {
+		const result = record[key];
+		if (!require_result.isResult(result)) {
+			if (!Object.getOwnPropertyDescriptor(record, key)?.enumerable) continue;
+			throw new require_errors.InvalidResultStateError("sequenceRecord");
+		}
+		if (result.isOk()) {
+			out[key] = result.value;
+			continue;
+		}
+		if (result.isErr()) return result;
+		throw new require_errors.InvalidResultStateError("sequenceRecord");
+	}
+	return require_result.ok(out);
+}
+
+//#endregion
+//#region src/core/collectFirstOk.ts
+/**
+* Parse a set of `Result`s, short-circuits when an input value is `Ok`.
+* If no `Ok` is found, returns an `Err` containing the collected error values.
+* Useful for "try multiple approaches until one works" patterns.
+*/
+function collectFirstOk(results) {
+	const errors = [];
+	for (const result of results) {
+		if (result.isOk()) return require_result.ok(result.value);
+		if (result.isErr()) {
+			errors.push(result.error);
+			continue;
+		}
+		throw new require_errors.InvalidResultStateError("collectFirstOk");
+	}
+	return require_result.err(errors);
+}
+
+//#endregion
+//#region src/core/collectFirstOkAsync.ts
+async function collectFirstOkAsync(inputs, errorMapper) {
+	const errors = [];
+	for (const input of inputs) {
+		const pendingResult = typeof input === "function" ? input() : input;
+		let result;
+		try {
+			result = await pendingResult;
+		} catch (error) {
+			errors.push(errorMapper ? errorMapper(error) : error);
+			continue;
+		}
+		if (require_result.isResult(result)) {
+			if (result.isOk()) return require_result.ok(result.value);
+			if (result.isErr()) {
+				errors.push(result.error);
+				continue;
+			}
+		}
+		throw new require_errors.InvalidResultStateError("collectFirstOkAsync");
+	}
+	return require_result.err(errors);
+}
+
+//#endregion
+//#region src/core/collectFirstOkParallelAsync.ts
+async function collectFirstOkParallelAsync(inputs, errorMapper) {
+	if (inputs.length === 0) return require_result.err([]);
+	const started = [];
+	try {
+		for (const input of inputs) started.push(typeof input === "function" ? Promise.resolve(input()) : input);
+	} catch (bug) {
+		for (const promise of started) promise.catch(() => {});
+		throw bug;
+	}
+	const firstOk = new Promise((resolve, reject) => {
+		for (const promise of started) promise.then((value) => {
+			if (!require_result.isResult(value)) reject(new require_errors.InvalidResultStateError("collectFirstOkParallelAsync"));
+			else if (value.isOk()) resolve(require_result.ok(value.value));
+		}, () => {});
+	});
+	const allErrors = Promise.allSettled(started).then((settled) => {
+		const errors = [];
+		for (const entry of settled) {
+			if (entry.status === "rejected") {
+				errors.push(errorMapper ? errorMapper(entry.reason) : entry.reason);
+				continue;
+			}
+			const result = entry.value;
+			if (require_result.isResult(result)) {
+				if (result.isErr()) {
+					errors.push(result.error);
+					continue;
+				}
+				if (result.isOk()) continue;
+			}
+			throw new require_errors.InvalidResultStateError("collectFirstOkParallelAsync");
+		}
+		return require_result.err(errors);
+	});
+	return Promise.race([firstOk, allErrors]);
+}
+
+//#endregion
+//#region src/core/collectAllErrors.ts
+/**
+* Combines a list of Results.
+* Return Ok(values) only if all are Ok, otherwise Err([errors]).
+*/
+function collectAllErrors(results) {
+	const values = [];
+	const errors = [];
+	for (const result of results) {
+		if (result.isOk()) {
+			values.push(result.value);
+			continue;
+		}
+		if (result.isErr()) {
+			errors.push(result.error);
+			continue;
+		}
+		throw new require_errors.InvalidResultStateError("collectAllErrors");
+	}
+	return errors.length === 0 ? require_result.ok(values) : require_result.err(errors);
+}
+
+//#endregion
+//#region src/core/partition.ts
+/**
+* Partitions Results into Ok values and Err errors.
+*/
+function partition(results) {
+	const oks = [];
+	const errs = [];
+	for (const result of results) {
+		if (result.isOk()) {
+			oks.push(result.value);
+			continue;
+		}
+		if (result.isErr()) {
+			errs.push(result.error);
+			continue;
+		}
+		throw new require_errors.InvalidResultStateError("partition");
+	}
+	return [oks, errs];
+}
+
+//#endregion
+//#region src/core/flatten.ts
+/**
+* Flattens a nested Result.
+* Result<Result<T, E>, E> → Result<T, E>
+* Corresponds to Rust `flatten`.
+*/
+function flatten(result) {
+	if (result.isOk()) return result.value;
+	if (result.isErr()) return result;
+	throw new require_errors.InvalidResultStateError("flatten");
+}
+
+//#endregion
 exports.all = require_result.all;
-exports.collectAllErrors = require_flatten.collectAllErrors;
-exports.collectFirstOk = require_flatten.collectFirstOk;
-exports.collectFirstOkAsync = require_flatten.collectFirstOkAsync;
-exports.collectFirstOkParallelAsync = require_flatten.collectFirstOkParallelAsync;
-exports.flatten = require_flatten.flatten;
-exports.partition = require_flatten.partition;
+exports.collectAllErrors = collectAllErrors;
+exports.collectFirstOk = collectFirstOk;
+exports.collectFirstOkAsync = collectFirstOkAsync;
+exports.collectFirstOkParallelAsync = collectFirstOkParallelAsync;
+exports.flatten = flatten;
+exports.partition = partition;
 exports.sequence = require_result.sequence;
-exports.sequenceRecord = require_flatten.sequenceRecord;
+exports.sequenceRecord = sequenceRecord;
+//# sourceMappingURL=collections.cjs.map

package/dist/collections.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.cjs","names":["InvalidResultStateError","isResult","ok","ok","InvalidResultStateError","err","isResult","ok","InvalidResultStateError","err","err","isResult","InvalidResultStateError","ok","InvalidResultStateError","ok","err","InvalidResultStateError","InvalidResultStateError"],"sources":["../src/core/sequenceRecord.ts","../src/core/collectFirstOk.ts","../src/core/collectFirstOkAsync.ts","../src/core/collectFirstOkParallelAsync.ts","../src/core/collectAllErrors.ts","../src/core/partition.ts","../src/core/flatten.ts"],"sourcesContent":["import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\nimport { isResult } from './isResult';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Like `sequence`, but for Records/Objects.\n * Short-circuits on the first Err.\n *\n * A non-enumerable own property is an input only when it holds a `Result`, so a\n * hidden helper field of another type is ignored. An array throws, because its\n * indices would sequence into an object; use `sequence` for a list.\n */\nexport function sequenceRecord<const R extends { readonly [K in keyof R]: Result<any, any> }>(\n    record: R\n): Result<{ [K in keyof R]: OkValueOf<R[K]> }, ErrValueOf<R[keyof R]>> {\n    type Out = { [K in keyof R]: OkValueOf<R[K]> };\n    type E = ErrValueOf<R[keyof R]>;\n\n    // An array reaches this point only from JavaScript, and it would sequence\n    // into an object keyed by its indices: `length` is a non-enumerable\n    // non-Result and the rule below would skip it. A list of Results belongs to\n    // `sequence()`, so the mistake fails here instead of returning a wrong shape.\n    if (Array.isArray(record)) throw new InvalidResultStateError('sequenceRecord');\n\n    const out: Partial<Out> = {};\n\n    // `Reflect.ownKeys` keeps the symbol keys, which the signature supports, and\n    // it also visits the non-enumerable properties. `keyof R` sees those too, so\n    // a hidden Result stays an input. A hidden value of another type is a helper\n    // field that the caller attached, and it is skipped instead of rejected.\n    for (const key of Reflect.ownKeys(record) as Array<keyof R>) {\n        const result = record[key];\n\n        if (!isResult(result)) {\n            if (!Object.getOwnPropertyDescriptor(record, key)?.enumerable) continue;\n            throw new InvalidResultStateError('sequenceRecord');\n        }\n\n        if (result.isOk()) {\n            out[key] = result.value as Out[typeof key];\n            continue;\n        }\n        if (result.isErr()) return result as unknown as Result<Out, E>;\n        throw new InvalidResultStateError('sequenceRecord');\n    }\n\n    return ok<Out, E>(out as Out);\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Parse a set of `Result`s, short-circuits when an input value is `Ok`.\n * If no `Ok` is found, returns an `Err` containing the collected error values.\n * Useful for \"try multiple approaches until one works\" patterns.\n */\nexport function collectFirstOk<const Results extends readonly Result<any, any>[]>(\n    results: Results\n): Result<OkValueOf<Results[number]>, ErrValueOf<Results[number]>[]> {\n    const errors: Array<ErrValueOf<Results[number]>> = [];\n\n    for (const result of results) {\n        if (result.isOk()) {\n            return ok<OkValueOf<Results[number]>, ErrValueOf<Results[number]>[]>(\n                result.value as OkValueOf<Results[number]>\n            );\n        }\n        if (result.isErr()) {\n            errors.push(result.error as ErrValueOf<Results[number]>);\n            continue;\n        }\n        throw new InvalidResultStateError('collectFirstOk');\n    }\n\n    return err<ErrValueOf<Results[number]>[], OkValueOf<Results[number]>>(errors);\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport type { Awaitable } from './pipeable';\nimport { isResult } from './isResult';\nimport { InvalidResultStateError } from '../errors';\n\ntype CollectFirstOkAsyncInput =\n    | Promise<Result<any, any>>\n    | (() => Awaitable<Result<any, any>>);\n\ntype ResolvedResult<I> = I extends () => infer R ? Awaited<R> : I extends Promise<infer R> ? R : never;\ntype OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;\ntype ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;\n\n/**\n * Async version of collectFirstOk.\n *\n * - Takes either already started Promises or \"Thunks\" (`() => Awaitable<Result<...>>`).\n *   A thunk that throws synchronously is a programmer error: the call rejects\n *   with that exception.\n * - Processes inputs strictly sequentially (like `for ... of` + `await`).\n * - Returns the first `Ok` and collects all errors if no `Ok` is found.\n * - A fulfilled value that is not a `Result` is a programmer error: the call\n *   rejects with `InvalidResultStateError`.\n * - A rejected input counts as a failed attempt. Without `errorMapper` the\n *   collected errors are `unknown[]`, because a rejection reason can be\n *   anything. `errorMapper` turns each rejection reason into a typed error;\n *   `Err` values pass through untouched, and bugs inside the mapper are rethrown.\n */\nexport function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(\n    inputs: Inputs\n): Promise<Result<OkValueOfInput<Inputs[number]>, unknown[]>>;\nexport function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput[], F>(\n    inputs: Inputs,\n    errorMapper: (error: unknown) => F\n): Promise<Result<OkValueOfInput<Inputs[number]>, Array<ErrValueOfInput<Inputs[number]> | F>>>;\nexport async function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput[], F>(\n    inputs: Inputs,\n    errorMapper?: (error: unknown) => F\n): Promise<Result<OkValueOfInput<Inputs[number]>, Array<ErrValueOfInput<Inputs[number]> | F>>> {\n    type OkValue = OkValueOfInput<Inputs[number]>;\n    type ErrValue = ErrValueOfInput<Inputs[number]> | F;\n\n    const errors: ErrValue[] = [];\n\n    for (const input of inputs) {\n        const pendingResult = typeof input === 'function' ? input() : input;\n        let result: unknown;\n        try {\n            result = await pendingResult;\n        } catch (error) {\n            errors.push(errorMapper ? errorMapper(error) : (error as F));\n            continue;\n        }\n\n        if (isResult(result)) {\n            if (result.isOk()) {\n                return ok<OkValue, ErrValue[]>(result.value as OkValue);\n            }\n            if (result.isErr()) {\n                errors.push(result.error as ErrValue);\n                continue;\n            }\n        }\n        throw new InvalidResultStateError('collectFirstOkAsync');\n    }\n\n    return err<ErrValue[], OkValue>(errors);\n}\n","import type { Awaitable } from './pipeable';\nimport type { Result } from './result';\nimport { err, ok } from './result';\nimport { isResult } from './isResult';\nimport { InvalidResultStateError } from '../errors';\n\ntype CollectFirstOkAsyncInput = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);\n\ntype ResolvedResult<I> = I extends () => infer R ? Awaited<R> : I extends Promise<infer R> ? R : never;\ntype OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;\ntype ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;\n\n/**\n * Parallel version of `collectFirstOkAsync`.\n *\n * - Starts all inputs immediately (Promises or Thunks). A thunk that throws\n *   synchronously is a programmer error: the call rejects with that exception,\n *   as `collectFirstOkAsync` does.\n * - Returns the first `Ok` as soon as it is available.\n * - If no `Ok` is found, returns an `Err` with all error values (in input order).\n * - A fulfilled value that is not a `Result` is a programmer error: the call\n *   rejects with `InvalidResultStateError`, unless an `Ok` already won the race.\n * - A rejected input counts as a failed attempt. Without `errorMapper` the\n *   collected errors are `unknown[]`, because a rejection reason can be\n *   anything. `errorMapper` turns each rejection reason into a typed error;\n *   `Err` values pass through untouched, and bugs inside the mapper are rethrown.\n * - If multiple inputs provide an `Ok`, the one that completes first wins.\n *   In case of simultaneous completion, the first observed result wins.\n * - If no `Ok` arrives and at least one input never settles, the Promise remains pending.\n */\nexport function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(\n    inputs: Inputs\n): Promise<Result<OkValueOfInput<Inputs[number]>, unknown[]>>;\nexport function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[], F>(\n    inputs: Inputs,\n    errorMapper: (error: unknown) => F\n): Promise<Result<OkValueOfInput<Inputs[number]>, Array<ErrValueOfInput<Inputs[number]> | F>>>;\nexport async function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[], F>(\n    inputs: Inputs,\n    errorMapper?: (error: unknown) => F\n): Promise<Result<OkValueOfInput<Inputs[number]>, Array<ErrValueOfInput<Inputs[number]> | F>>> {\n    type OkValue = OkValueOfInput<Inputs[number]>;\n    type ErrValue = ErrValueOfInput<Inputs[number]> | F;\n\n    if (inputs.length === 0) {\n        return err<ErrValue[], OkValue>([]);\n    }\n\n    // Discarding the outcomes of the attempts that already started keeps an\n    // abandoned rejection from surfacing as an unhandled rejection.\n    const started: Promise<unknown>[] = [];\n    try {\n        for (const input of inputs) {\n            started.push(typeof input === 'function' ? Promise.resolve(input()) : input);\n        }\n    } catch (bug) {\n        for (const promise of started) promise.catch(() => {});\n        throw bug;\n    }\n\n    const firstOk = new Promise<Result<OkValue, ErrValue[]>>((resolve, reject) => {\n        for (const promise of started) {\n            promise.then(\n                (value) => {\n                    if (!isResult(value)) {\n                        reject(new InvalidResultStateError('collectFirstOkParallelAsync'));\n                    } else if (value.isOk()) {\n                        resolve(ok<OkValue, ErrValue[]>(value.value as OkValue));\n                    }\n                },\n                () => {\n                    // A rejection is a failed attempt; allSettled below collects it.\n                }\n            );\n        }\n    });\n\n    const allErrors = Promise.allSettled(started).then((settled) => {\n        const errors: ErrValue[] = [];\n        for (const entry of settled) {\n            if (entry.status === 'rejected') {\n                errors.push(errorMapper ? errorMapper(entry.reason) : (entry.reason as F));\n                continue;\n            }\n            const result = entry.value;\n            if (isResult(result)) {\n                if (result.isErr()) {\n                    errors.push(result.error as ErrValue);\n                    continue;\n                }\n                if (result.isOk()) continue;\n            }\n            throw new InvalidResultStateError('collectFirstOkParallelAsync');\n        }\n        return err<ErrValue[], OkValue>(errors);\n    });\n\n    return Promise.race([firstOk, allErrors]);\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\ntype CollectionValues<Results extends readonly Result<any, any>[]> = {\n    -readonly [K in keyof Results]: OkValueOf<Results[K]>;\n};\n\n/**\n * Combines a list of Results.\n * Return Ok(values) only if all are Ok, otherwise Err([errors]).\n */\nexport function collectAllErrors<const Results extends readonly Result<any, any>[]>(\n    results: Results\n): Result<CollectionValues<Results>, Array<ErrValueOf<Results[number]>>> {\n    const values: Array<OkValueOf<Results[number]>> = [];\n    const errors: Array<ErrValueOf<Results[number]>> = [];\n\n    for (const result of results) {\n        if (result.isOk()) {\n            values.push(result.value as OkValueOf<Results[number]>);\n            continue;\n        }\n        if (result.isErr()) {\n            errors.push(result.error as ErrValueOf<Results[number]>);\n            continue;\n        }\n        throw new InvalidResultStateError('collectAllErrors');\n    }\n\n    return errors.length === 0\n        ? ok<CollectionValues<Results>, Array<ErrValueOf<Results[number]>>>(values as CollectionValues<Results>)\n        : err<Array<ErrValueOf<Results[number]>>, CollectionValues<Results>>(errors);\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\ntype OkValueOf<R> = R extends Result<infer T, any> ? T : never;\ntype ErrValueOf<R> = R extends Result<any, infer E> ? E : never;\n\n/**\n * Partitions Results into Ok values and Err errors.\n */\nexport function partition<const Results extends readonly Result<any, any>[]>(\n    results: Results\n): [oks: Array<OkValueOf<Results[number]>>, errs: Array<ErrValueOf<Results[number]>>] {\n    const oks: Array<OkValueOf<Results[number]>> = [];\n    const errs: Array<ErrValueOf<Results[number]>> = [];\n\n    for (const result of results) {\n        if (result.isOk()) {\n            oks.push(result.value as OkValueOf<Results[number]>);\n            continue;\n        }\n        if (result.isErr()) {\n            errs.push(result.error as ErrValueOf<Results[number]>);\n            continue;\n        }\n        throw new InvalidResultStateError('partition');\n    }\n\n    return [oks, errs];\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Flattens a nested Result.\n * Result<Result<T, E>, E> → Result<T, E>\n * Corresponds to Rust `flatten`.\n */\nexport function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {\n    if (result.isOk()) {\n        return result.value;\n    }\n    if (result.isErr()) return result as unknown as Result<T, E>;\n    throw new InvalidResultStateError('flatten');\n}\n"],"mappings":"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"}

package/dist/collections.d.cts

@@ -1,3 +1,101 @@
-import { n as sequence, t as all } from "./sequence-DDwePRLd.cjs";
-import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as collectFirstOk, r as collectAllErrors, s as sequenceRecord, t as flatten } from "./flatten-D0K8UcQH.cjs";
-export { all, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, flatten, partition, sequence, sequenceRecord };
+import { E as Awaitable, n as sequence, s as Result, t as all } from "./sequence-CmugKPbu.cjs";
+//#region src/core/sequenceRecord.d.ts
+type OkValueOf$3<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf$3<R> = R extends Result<any, infer E> ? E : never;
+/**
+ * Like `sequence`, but for Records/Objects.
+ * Short-circuits on the first Err.
+ *
+ * A non-enumerable own property is an input only when it holds a `Result`, so a
+ * hidden helper field of another type is ignored. An array throws, because its
+ * indices would sequence into an object; use `sequence` for a list.
+ */
+declare function sequenceRecord<const R extends { readonly [K in keyof R]: Result<any, any>; }>(record: R): Result<{ [K in keyof R]: OkValueOf$3<R[K]>; }, ErrValueOf$3<R[keyof R]>>;
+//#endregion
+//#region src/core/collectFirstOk.d.ts
+type OkValueOf$2<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf$2<R> = R extends Result<any, infer E> ? E : never;
+/**
+ * Parse a set of `Result`s, short-circuits when an input value is `Ok`.
+ * If no `Ok` is found, returns an `Err` containing the collected error values.
+ * Useful for "try multiple approaches until one works" patterns.
+ */
+declare function collectFirstOk<const Results extends readonly Result<any, any>[]>(results: Results): Result<OkValueOf$2<Results[number]>, ErrValueOf$2<Results[number]>[]>;
+//#endregion
+//#region src/core/collectFirstOkAsync.d.ts
+type CollectFirstOkAsyncInput$1 = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);
+type ResolvedResult$1<I> = I extends (() => infer R) ? Awaited<R> : I extends Promise<infer R> ? R : never;
+type OkValueOfInput$1<I> = ResolvedResult$1<I> extends Result<infer T, any> ? T : never;
+type ErrValueOfInput$1<I> = ResolvedResult$1<I> extends Result<any, infer E> ? E : never;
+/**
+ * Async version of collectFirstOk.
+ *
+ * - Takes either already started Promises or "Thunks" (`() => Awaitable<Result<...>>`).
+ *   A thunk that throws synchronously is a programmer error: the call rejects
+ *   with that exception.
+ * - Processes inputs strictly sequentially (like `for ... of` + `await`).
+ * - Returns the first `Ok` and collects all errors if no `Ok` is found.
+ * - A fulfilled value that is not a `Result` is a programmer error: the call
+ *   rejects with `InvalidResultStateError`.
+ * - A rejected input counts as a failed attempt. Without `errorMapper` the
+ *   collected errors are `unknown[]`, because a rejection reason can be
+ *   anything. `errorMapper` turns each rejection reason into a typed error;
+ *   `Err` values pass through untouched, and bugs inside the mapper are rethrown.
+ */
+declare function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput$1[]>(inputs: Inputs): Promise<Result<OkValueOfInput$1<Inputs[number]>, unknown[]>>;
+declare function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput$1[], F>(inputs: Inputs, errorMapper: (error: unknown) => F): Promise<Result<OkValueOfInput$1<Inputs[number]>, Array<ErrValueOfInput$1<Inputs[number]> | F>>>;
+//#endregion
+//#region src/core/collectFirstOkParallelAsync.d.ts
+type CollectFirstOkAsyncInput = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);
+type ResolvedResult<I> = I extends (() => infer R) ? Awaited<R> : I extends Promise<infer R> ? R : never;
+type OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;
+type ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;
+/**
+ * Parallel version of `collectFirstOkAsync`.
+ *
+ * - Starts all inputs immediately (Promises or Thunks). A thunk that throws
+ *   synchronously is a programmer error: the call rejects with that exception,
+ *   as `collectFirstOkAsync` does.
+ * - Returns the first `Ok` as soon as it is available.
+ * - If no `Ok` is found, returns an `Err` with all error values (in input order).
+ * - A fulfilled value that is not a `Result` is a programmer error: the call
+ *   rejects with `InvalidResultStateError`, unless an `Ok` already won the race.
+ * - A rejected input counts as a failed attempt. Without `errorMapper` the
+ *   collected errors are `unknown[]`, because a rejection reason can be
+ *   anything. `errorMapper` turns each rejection reason into a typed error;
+ *   `Err` values pass through untouched, and bugs inside the mapper are rethrown.
+ * - If multiple inputs provide an `Ok`, the one that completes first wins.
+ *   In case of simultaneous completion, the first observed result wins.
+ * - If no `Ok` arrives and at least one input never settles, the Promise remains pending.
+ */
+declare function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(inputs: Inputs): Promise<Result<OkValueOfInput<Inputs[number]>, unknown[]>>;
+declare function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[], F>(inputs: Inputs, errorMapper: (error: unknown) => F): Promise<Result<OkValueOfInput<Inputs[number]>, Array<ErrValueOfInput<Inputs[number]> | F>>>;
+//#endregion
+//#region src/core/collectAllErrors.d.ts
+type OkValueOf$1<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf$1<R> = R extends Result<any, infer E> ? E : never;
+type CollectionValues<Results extends readonly Result<any, any>[]> = { -readonly [K in keyof Results]: OkValueOf$1<Results[K]>; };
+/**
+ * Combines a list of Results.
+ * Return Ok(values) only if all are Ok, otherwise Err([errors]).
+ */
+declare function collectAllErrors<const Results extends readonly Result<any, any>[]>(results: Results): Result<CollectionValues<Results>, Array<ErrValueOf$1<Results[number]>>>;
+//#endregion
+//#region src/core/partition.d.ts
+type OkValueOf<R> = R extends Result<infer T, any> ? T : never;
+type ErrValueOf<R> = R extends Result<any, infer E> ? E : never;
+/**
+ * Partitions Results into Ok values and Err errors.
+ */
+declare function partition<const Results extends readonly Result<any, any>[]>(results: Results): [oks: Array<OkValueOf<Results[number]>>, errs: Array<ErrValueOf<Results[number]>>];
+//#endregion
+//#region src/core/flatten.d.ts
+/**
+ * Flattens a nested Result.
+ * Result<Result<T, E>, E> → Result<T, E>
+ * Corresponds to Rust `flatten`.
+ */
+declare function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E>;
+//#endregion
+export { all, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, flatten, partition, sequence, sequenceRecord };
+//# sourceMappingURL=collections.d.cts.map

package/dist/collections.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.d.cts","names":[],"sources":["../src/core/sequenceRecord.ts","../src/core/collectFirstOk.ts","../src/core/collectFirstOkAsync.ts","../src/core/collectFirstOkParallelAsync.ts","../src/core/collectAllErrors.ts","../src/core/partition.ts","../src/core/flatten.ts"],"mappings":";;KAKK,YAAU,KAAK,UAAU,aAAa,UAAU;KAChD,aAAW,KAAK,UAAU,kBAAkB,KAAK;;;;;;;;;iBAUtC,qBAAqB,sBAAsB,WAAW,IAAI,qBACtE,QAAQ,IACT,UAAU,WAAW,IAAI,YAAU,EAAE,QAAO,aAAW,QAAQ;;;KCd7D,YAAU,KAAK,UAAU,aAAa,UAAU;KAChD,aAAW,KAAK,UAAU,kBAAkB,KAAK;;;;;;iBAOtC,qBAAqB,yBAAyB,oBAC1D,SAAS,UACV,OAAO,YAAU,kBAAkB,aAAW;;;KCR5C,6BACC,QAAQ,2BACD,UAAU;KAElB,iBAAe,KAAK,uBAAsB,KAAI,QAAQ,KAAK,UAAU,cAAc,KAAK;KACxF,iBAAe,KAAK,iBAAe,WAAW,aAAa,UAAU;KACrE,kBAAgB,KAAK,iBAAe,WAAW,kBAAkB,KAAK;;;;;;;;;;;;;;;;iBAiB3D,0BAA0B,wBAAwB,8BAC9D,QAAQ,SACT,QAAQ,OAAO,iBAAe;iBACjB,0BAA0B,wBAAwB,8BAA4B,GAC1F,QAAQ,QACR,cAAc,mBAAmB,IAClC,QAAQ,OAAO,iBAAe,iBAAiB,MAAM,kBAAgB,kBAAkB;;;KC7BrF,2BAA2B,QAAQ,2BAA2B,UAAU;KAExE,eAAe,KAAK,uBAAsB,KAAI,QAAQ,KAAK,UAAU,cAAc,KAAK;KACxF,eAAe,KAAK,eAAe,WAAW,aAAa,UAAU;KACrE,gBAAgB,KAAK,eAAe,WAAW,kBAAkB,KAAK;;;;;;;;;;;;;;;;;;;iBAoB3D,kCAAkC,wBAAwB,4BACtE,QAAQ,SACT,QAAQ,OAAO,eAAe;iBACjB,kCAAkC,wBAAwB,4BAA4B,GAClG,QAAQ,QACR,cAAc,mBAAmB,IAClC,QAAQ,OAAO,eAAe,iBAAiB,MAAM,gBAAgB,kBAAkB;;;KChCrF,YAAU,KAAK,UAAU,aAAa,UAAU;KAChD,aAAW,KAAK,UAAU,kBAAkB,KAAK;KACjD,iBAAiB,yBAAyB,mCAChC,WAAW,UAAU,YAAU,QAAQ;;;;;iBAOtC,uBAAuB,yBAAyB,oBAC5D,SAAS,UACV,OAAO,iBAAiB,UAAU,MAAM,aAAW;;;KCbjD,UAAU,KAAK,UAAU,aAAa,UAAU;KAChD,WAAW,KAAK,UAAU,kBAAkB,KAAK;;;;iBAKtC,gBAAgB,yBAAyB,oBACrD,SAAS,WACT,KAAK,MAAM,UAAU,mBAAmB,MAAM,MAAM,WAAW;;;;;;;;iBCHnD,QAAQ,GAAG,GAAG,QAAQ,OAAO,OAAO,GAAG,IAAI,KAAK,OAAO,GAAG"}