@shirudo/result 0.0.6 → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 shirudo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,369 +1,209 @@
 # @shirudo/result
 
-**Robust, type-safe error handling for TypeScript.**
+Robust, type-safe error handling for TypeScript.
 
-> ⚠️ **Beta Notice**: This library is currently in beta. The API may change before the stable release. Use with caution in production environments.
+`@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.
 
-`@shirudo/result` brings the power of the Result pattern (Monad) to TypeScript. It helps you write safer, more predictable code by treating errors as values rather than exceptions. Stop guessing if a function will throw—let the type system guide you.
+[![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)
 
-![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)
-![Runtime](https://img.shields.io/badge/Runtime-Node%20%7C%20Browser-green)
-![License](https://img.shields.io/badge/License-MIT-yellow.svg)
-![Beta](https://img.shields.io/badge/Status-Beta-orange.svg)
+## Installation
 
-## 🌟 Key Features
-
-- **Type-Safe:** generic `Result<T, E>` type discriminates between Success (`Ok`) and Failure (`Err`).
-- **Pipeable Architecture:** Functional, tree-shakeable operators via `.pipe()` and `.pipeAsync()`.
-- **Async Support:** First-class support for Promises and async transformations.
-- **Do-Notation:** A `task` generator utility to write sequential code without callback hell (similar to Rust's `?` operator).
-- **Rich Pattern Matching:** Fluent builders for exhaustive matching and error handling.
-- **Comprehensive Utilities:** Helpers for collections, conversion from/to Promises, Nullables, and try/catch blocks.
-
----
-
-## 📦 Installation
-
-```bash
+```sh
 npm install @shirudo/result
-# or
 pnpm add @shirudo/result
-# or
 yarn add @shirudo/result
 ```
 
----
-
-## 🚀 Quick Start
-
-### Basic Usage
-
-Instead of throwing errors, return a `Result`.
+## Quick Start
 
 ```ts
-import { ok, err, Result } from "@shirudo/result";
-
-function divide(a: number, b: number): Result<number, string> {
-  if (b === 0) {
-    return err("Division by zero");
-  }
-  return ok(a / b);
+import { Result } from '@shirudo/result';
+
+type User = { id: string; email: string; active: boolean };
+type UserError =
+    | { type: 'not-found'; id: string }
+    | { type: 'inactive'; id: string };
+
+const users = new Map<string, User>([
+    ['1', { id: '1', email: 'ada@example.com', active: true }],
+]);
+
+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);
 }
 
-const result = divide(10, 2);
+const result = loadUser('1');
 
 if (result.isOk()) {
-  // TypeScript narrows 'result' to Ok<number>
-  console.log("Success:", result.value); // 5
+    console.log(result.value.email);
 } else {
-  // TypeScript narrows 'result' to Err<string>
-  console.error("Error:", result.error);
+    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;
+    }
 }
 ```
 
-### Functional Pipelines
-
-Use `.pipe()` to chain operations. If an error occurs at any step, the chain short-circuits and returns the `Err`.
-
-```ts
-import { ok, map, filter, mapErr } from "@shirudo/result";
-
-const processed = ok(10).pipe(
-  map((n) => n * 2), // 20
-  filter(
-    (n) => n > 50,
-    () => "Too small"
-  ), // Returns Err('Too small')
-  mapErr((e) => `Error: ${e}`) // Transforms the error message
-);
-
-console.log(processed.isErr()); // true
-console.log(processed.unwrapOr(0)); // 0 (fallback)
-```
-
----
+## Why This Library
 
-## 💡 Core Concepts
+- `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.
 
-### Creating Results
+## Common Workflows
 
-There are several static factories to help you wrap existing code or values.
+### Catch throwing APIs
 
 ```ts
-import { Result } from "@shirudo/result";
-
-// Standard
-const a = Result.ok(42);
-const b = Result.err("Something went wrong");
-
-// From a function that might throw
-const json = Result.try(() => JSON.parse('{"valid": true}'));
-
-// From a potentially null/undefined value
-const user = Result.fromNullable(maybeUser, "User not found");
+import { Result } from '@shirudo/result';
 
-// From a Promise (catches rejections)
-const asyncRes = await Result.fromPromise(fetch("/api/data"));
-```
-
-### Async Pipelines
+const parseJson = Result.fromThrowable(
+    JSON.parse,
+    error => ({ type: 'parse' as const, cause: error }),
+);
 
-Transforming async results is seamless with `.pipeAsync()`.
+const parsed = parseJson('{"valid": true}');
 
-```ts
-import { ok, mapAsync, tryCatchAsync } from "@shirudo/result";
-
-const result = await ok(1).pipeAsync(
-  mapAsync(async (id) => {
-    const user = await db.getUser(id);
-    return user.name;
-  }),
-  tryCatchAsync(async (name) => {
-    // If this throws, it becomes an Err
-    return await externalService.validate(name);
-  })
+const response = await Result.fromPromise(
+    Promise.resolve({ ok: true }),
+    error => ({ type: 'network' as const, cause: error }),
 );
 ```
 
-### Generator "Do-Notation" (`task`)
-
-The `task` (or `gen`) utility allows you to write code that looks imperative but handles `Result` flow control automatically. Use `yield*` to unwrap `Ok` values; if an `Err` is yielded, the function returns early with that error.
+### Compose with pipe operators
 
 ```ts
-import { task, ok, err } from "@shirudo/result";
-
-const calculate = task(function* () {
-  // yield* automatically unwraps the value if Ok
-  const x = yield* ok(10);
-  const y = yield* ok(20);
-
-  // If this were err(), execution would stop here and return that err
-  const z = yield* validate(x + y);
-
-  return z; // Returns Ok(z)
-});
-
-// calculate is a Promise<Result<number, Error>>
+import { Result } from '@shirudo/result';
+import { filter, map, mapErr } from '@shirudo/result/operators';
+
+const processed = Result.ok<number, string>(10).pipe(
+    map(value => value * 2),
+    filter(
+        value => value > 25,
+        () => 'too small',
+    ),
+    mapErr(error => `Validation failed: ${error}`),
+);
 ```
 
-#### Error Handling with `onThrow`
-
-The `task()` function accepts an optional `onThrow` callback for custom error mapping:
+### Compose async work
 
 ```ts
-const result = await task(
-  function* () {
-    const data = yield* fetchData();
-    return process(data);
-  },
-  (error) => new CustomError(`Failed: ${error}`)  // custom error mapping
+import { Result } from '@shirudo/result';
+import { mapAsync, tryMapAsync } from '@shirudo/result/operators';
+
+const db = {
+    async getUser(id: number) {
+        return { id, email: 'ada@example.com' };
+    },
+};
+
+const normalizedEmail = await Result.ok<number, string>(1).pipeAsync(
+    mapAsync(async id => db.getUser(id)),
+    tryMapAsync(async user => user.email.toLowerCase()),
 );
-// Returns Result<ProcessedData, CustomError>
 ```
 
-### Folding Results
-
-The simplest way to handle both `Ok` and `Err` cases and return a single value:
+### Use task notation for sequential flows
 
 ```ts
-import { ok, err } from "@shirudo/result";
+import { Result, task } from '@shirudo/result';
 
-const result = ok(42);
-
-const message = result.fold(
-  (val) => `Success: ${val}`,
-  (err) => `Error: ${err}`
-);
-// message = "Success: 42"
+function findUser(id: string) {
+    return Result.ok({ id, email: 'ada@example.com' });
+}
 
-// Useful for side effects
-result.fold(
-  (val) => console.log("Yay:", val),
-  (err) => console.error("Nay:", err)
-);
+function ensureEmail(user: { id: string; email?: string }) {
+    return user.email
+        ? Result.ok(user.email)
+        : Result.err({ type: 'missing-email' as const, id: user.id });
+}
 
-// Convert to HTTP response
-const response = result.fold(
-  (data) => ({ status: 200, body: data }),
-  (error) => ({ status: 500, body: { error } })
-);
+const email = task(function* () {
+    const user = yield* findUser('1');
+    return yield* ensureEmail(user);
+});
 ```
 
-### Pattern Matching
-
-Handle errors exhaustively using the fluent matching API for complex error types. You can match by Error class (`.err`) or by primitive value (`.errVal`).
+### Match discriminated-union errors
 
 ```ts
-import { Result } from "@shirudo/result";
+import { Result, matchTag } from '@shirudo/result';
 
-class NetworkError extends Error {}
-class ValidationError extends Error {}
+type DomainError =
+    | { type: 'network'; retryAfter: number }
+    | { type: 'validation'; field: string };
 
-const result = Result.err(new NetworkError("Timeout"));
+const failed = Result.err<DomainError>({ type: 'network', retryAfter: 30 });
 
-const message = result
-  .match()
-  .err(NetworkError, (e) => `Retry later: ${e.message}`)
-  .err(ValidationError, (e) => `Invalid input: ${e.message}`)
-  .errVal("TIMEOUT_CODE", () => "Operation timed out") // Match primitive values
-  .ok((val) => `Success: ${val}`)
-  .run();
+const message = matchTag(failed, 'type', {
+    network: error => `Retry in ${error.retryAfter}s`,
+    validation: error => `Invalid field: ${error.field}`,
+});
 ```
 
-#### Async Pattern Matching
+## Imports
 
-For async handlers, use `matchAsync`:
+Everything is available from the package root:
 
 ```ts
-import { matchAsync } from "@shirudo/result";
-
-const result = await matchAsync({
-  ok: async (val) => `Success: ${val}`,
-  err: async (e) => `Error: ${e}`
-})(someResult);
+import { Result, err, ok, task } from '@shirudo/result';
 ```
 
-**When to use what:**
-
-- Use `.fold()` for simple cases where you handle both Ok and Err
-- Use `.match()` for complex pattern matching on multiple error types
-- Use `fold()` pipe operator for functional composition in pipelines
-
----
-
-## 📚 API Reference
-
-### Creation & Conversions
-
-- `ok(value)` / `err(error)`: Create basic instances.
-- `okIf(condition, okValue, errValue)`: Conditionally create `Ok` or `Err`.
-- `okIfLazy(condition, okFn, errFn)`: Lazy conditional creation.
-- `Result.try(fn)`: Execute a sync function; catches exceptions as `Err`.
-- `Result.fromNullable(val, fallback)`: Convert `null | undefined` to `Err`.
-- `Result.fromPromise(promise)`: Convert a Promise to `Promise<Result>`.
-- `.toPromise()`: Convert `Ok` to resolved Promise, `Err` to rejected.
-- `.toNullable()`: Convert `Ok` to value, `Err` to `null`.
-
-### Instance Methods
-
-- `.isOk()`: Type guard for success.
-- `.isErr()`: Type guard for failure.
-- `.unwrap()`: Get value or throw (use carefully).
-- `.unwrapErr()`: Get error or throw (use carefully).
-- `.unwrapOr(default)`: Get value or return default.
-- `.unwrapOrElse(fn)`: Get value or generate default from error.
-- `.unwrapOrThrow()`: Get value or throw original error (preserves stack trace).
-- `.expect(msg)`: Get value or throw with specific message.
-- `.expectErr(msg)`: Get error or throw with specific message.
-- `.fold(onOk, onErr)`: Handle both cases and return a single value.
-- `.pipe(...)`: Chain operators synchronously.
-- `.pipeAsync(...)`: Chain operators asynchronously.
-- `.match()`: Start a fluent pattern matching builder (Err only).
-- `.matchErr()`: Pattern matching builder for Err cases.
-- `.serialize()`: Convert to `{ isSuccess, data?, error? }`.
-- `.toUserFriendly()`: User-friendly serialization with error messages.
-
-**Error types:** Methods that throw (e.g., `.unwrap()`, `.unwrapErr()`, `.expect()`, `.expectErr()`, and invalid-state checks) now use custom error classes with stable `code` values like `ERR_UNWRAP_ON_ERR` and `ERR_INVALID_STATE`. These classes and constants are exported from the package for programmatic handling.
-
-### Utilities
-
-Type guards and helper functions:
-
-- `isResult(value)`: Type guard to check if a value is a `Result`.
-- `contains(result, value)`: Check if `Ok` contains a specific value.
-- `containsErr(result, error)`: Check if `Err` contains a specific error.
-- `fromResult(fn)`: Execute a function, catching exceptions (Rust `Result::from`).
+Focused subpath exports are available for clearer imports and package-level checks:
 
 ```ts
-import { isResult, contains, containsErr, fromResult, ok, err } from "@shirudo/result";
-
-isResult(ok(5)); // true
-isResult("not a result"); // false
-
-const result = ok(42);
-contains(result, 42); // true
-contains(result, 100); // false
-
-const errResult = err("not found");
-containsErr(errResult, "not found"); // true
-
-const wrapped = fromResult(() => JSON.parse('{"valid": true}'));
+import { UnwrapOnErrError } from '@shirudo/result/errors';
+import { flatMapAsync, map } from '@shirudo/result/operators';
+import { sequence, sequenceRecord } from '@shirudo/result/collections';
 ```
 
-### Pipeable Operators
-
-Import these from the root package to use inside `.pipe()`.
-
-| Operator               | Description                                              |
-| :--------------------- | :------------------------------------------------------- |
-| `map(fn)`              | Transform the `Ok` value.                                |
-| `mapErr(fn)`           | Transform the `Err` value.                               |
-| `mapBoth(fnOk, fnErr)` | Transform both sides.                                    |
-| `flatMap(fn)`          | Chain a function that returns a `Result` (monadic bind). |
-| `filter(pred, errFn)`  | Turn `Ok` into `Err` if predicate fails.                 |
-| `tap(observer)`        | Run side effects (logging) without changing the result.  |
-| `recover(val)`         | Convert `Err` to `Ok` with a default value.              |
-| `tryCatch(fn)`         | Run a function, catching exceptions into `Err`.          |
-| `tryMap(fn)`           | Like `map`, but catches exceptions.                      |
-| `fold({ ok, err })`    | Terminate the pipe and return a value based on state.    |
+## Documentation
 
-**Async Variants:** `mapAsync`, `mapErrAsync`, `flatMapAsync`, `filterAsync`, `tapAsync`, `tryCatchAsync`, `tryMapAsync`, `foldAsync`.
+The full documentation lives in `docs/` and is built with VitePress.
 
-### Combinators
-
-Combinators (inspired by Rust) for composing and transforming Results:
-
-| Combinator | Description |
-| :--------- | :---------- |
-| `and(r1, r2)` | Short-circuit AND: returns `r2` only if `r1` is `Ok` |
-| `or(r1, r2)` | Returns `r1` if `Ok`, otherwise `r2` |
-| `orElse(r, fn)` | Returns `r` if `Ok`, otherwise calls `fn(error)` |
-| `mapOr(r, default, fn)` | Maps `Ok` value or returns `default` |
-| `mapOrElse(r, defaultFn, fn)` | Maps `Ok` value or computes `default` from error |
-| `swap(r)` | Swaps Ok and Err: `Result<T, E>` → `Result<E, T>` |
-
-```ts
-import { and, or, orElse, mapOr, mapOrElse, swap, ok, err } from "@shirudo/result";
+- [Getting Started](docs/guide/getting-started.md)
+- [Pipelines](docs/guide/pipelines.md)
+- [Task Notation](docs/guide/task.md)
+- [Pattern Matching](docs/guide/matching.md)
+- [Result API](docs/api/result.md)
+- [Operators](docs/api/operators.md)
+- [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)
 
-const a = ok(5);
-const b = ok(10);
+## Development
 
-// and: returns b only if a is Ok
-and(a, b); // Ok(10)
-
-// or: returns first Ok, otherwise fallback
-or(err("fallback"), ok("success")); // Ok("success")
-
-// orElse: lazy fallback with error context
-orElse(err("error"), (e) => ok(`recovered: ${e}`)); // Ok("recovered: error")
-
-// mapOr: map or use default
-mapOr(ok(5), 0, (n) => n * 2); // 10
-mapOr(err("x"), 0, (n) => n * 2); // 0
-
-// swap: interchange Ok and Err
-swap(ok("value")); // Err("value")
-swap(err("error")); // Ok("error")
+```sh
+pnpm install
+pnpm check
+pnpm check:clean
 ```
 
-### Collections
+Useful focused commands:
 
-- `sequence(results)`: Turn `Result[]` into `Result<T[]>`. First error stops the process.
-- `sequenceRecord(record)`: Like `sequence`, but for objects (`{ a: Result, b: Result }` → `Result<{ a, b }>`).
-- `collectFirstOk(results)`: Find the first success, or return all errors.
-- `collectFirstOkAsync(results)`: Async version - find the first success.
-- `collectFirstOkParallelAsync(results)`: Parallel variant - first success wins, all rejections continue.
-- `collectAllErrors(results)`: Returns `Ok(values)` only if all are Ok, otherwise collects _all_ errors.
-- `partition(results)`: Separate a list into arrays of `[oks, errs]`.
-- `flatten(result)`: Flattens a nested `Result<Result<T, E>, E>` into `Result<T, E>`.
-- `zip(r1, r2)`: Combine two results into a tuple.
-
----
-
-## 🤝 Contributing
-
-We welcome contributions! Please follow the standard pull request process. Ensure usage of TypeScript and Vitest for testing.
+```sh
+pnpm docs:dev
+pnpm docs:check
+pnpm test:exports
+```
 
-## 📄 License
+## License
 
-This project is licensed under the MIT License.
+MIT

package/dist/collections.cjs

@@ -0,0 +1,12 @@
+const require_result = require('./result-CY-KIivk.cjs');
+const require_flatten = require('./flatten-Df9U40nO.cjs');
+
+exports.all = require_result.all;
+exports.collectAllErrors = require_flatten.collectAllErrors;
+exports.collectFirstOk = require_result.collectFirstOk;
+exports.collectFirstOkAsync = require_flatten.collectFirstOkAsync;
+exports.collectFirstOkParallelAsync = require_flatten.collectFirstOkParallelAsync;
+exports.flatten = require_flatten.flatten;
+exports.partition = require_flatten.partition;
+exports.sequence = require_result.sequence;
+exports.sequenceRecord = require_flatten.sequenceRecord;

package/dist/collections.d.cts

@@ -0,0 +1,3 @@
+import { E as collectFirstOk, n as sequence, t as all } from "./sequence-Br6tAIIu.cjs";
+import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as sequenceRecord, r as collectAllErrors, t as flatten } from "./flatten-DK7eJKPx.cjs";
+export { all, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, flatten, partition, sequence, sequenceRecord };

package/dist/collections.d.mts

@@ -0,0 +1,3 @@
+import { E as collectFirstOk, n as sequence, t as all } from "./sequence-C0jlR3AY.mjs";
+import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as sequenceRecord, r as collectAllErrors, t as flatten } from "./flatten-B8bN6fiI.mjs";
+export { all, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, flatten, partition, sequence, sequenceRecord };

package/dist/collections.mjs

@@ -0,0 +1,4 @@
+import { L as all, R as sequence, x as collectFirstOk } from "./result-DKKaNdOx.mjs";
+import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as sequenceRecord, r as collectAllErrors, t as flatten } from "./flatten-C6Y9hx79.mjs";
+
+export { all, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, flatten, partition, sequence, sequenceRecord };

package/dist/errors-2WOswg7r.mjs

@@ -0,0 +1,95 @@
+//#region src/errors.ts
+const ERR_INVALID_RESULT_STATE = "ERR_INVALID_RESULT_STATE";
+const ERR_INVALID_STATE = ERR_INVALID_RESULT_STATE;
+const ERR_TASK_YIELD_NOT_RESULT = "ERR_TASK_YIELD_NOT_RESULT";
+const ERR_MATCH_ON_OK = "ERR_MATCH_ON_OK";
+const ERR_MATCH_ERR_HANDLER_NOT_RESULT = "ERR_MATCH_ERR_HANDLER_NOT_RESULT";
+const ERR_UNWRAP_ON_ERR = "ERR_UNWRAP_ON_ERR";
+const ERR_UNWRAP_ERR_ON_OK = "ERR_UNWRAP_ERR_ON_OK";
+const ERR_EXPECT_OK = "ERR_EXPECT_OK";
+const ERR_EXPECT_ERR = "ERR_EXPECT_ERR";
+const formatResultErrorMessage = (code, message, context) => {
+	if (context) return `${code}: ${message} (context: ${context})`;
+	return `${code}: ${message}`;
+};
+var ResultError = class extends Error {
+	code;
+	context;
+	constructor(message, code, context) {
+		super(formatResultErrorMessage(code, message, context));
+		this.code = code;
+		this.context = context;
+		this.name = new.target.name;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+var ResultTypeError = class extends TypeError {
+	code;
+	context;
+	constructor(message, code, context) {
+		super(formatResultErrorMessage(code, message, context));
+		this.code = code;
+		this.context = context;
+		this.name = new.target.name;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+const INVALID_RESULT_STATE_MESSAGE = "Unreachable: Result is neither Ok nor Err";
+var InvalidResultStateError = class extends ResultError {
+	constructor(context) {
+		super(INVALID_RESULT_STATE_MESSAGE, ERR_INVALID_RESULT_STATE, context);
+	}
+};
+var TaskYieldNotResultError = class extends ResultTypeError {
+	yieldedValue;
+	constructor(yieldedValue) {
+		super("task() expected yielded values to be Result. Use `yield*` on a Result.", ERR_TASK_YIELD_NOT_RESULT);
+		this.yieldedValue = yieldedValue;
+	}
+};
+var MatchOnOkError = class extends ResultTypeError {
+	constructor(methodName = "match") {
+		super(`${methodName}() can only be called on Err results. Use \`if (result.isErr()) { ... }\` first.`, ERR_MATCH_ON_OK);
+	}
+};
+var MatchErrHandlerNotResultError = class extends ResultTypeError {
+	handlerName;
+	returnedValue;
+	constructor(handlerName, returnedValue) {
+		super(`matchErr().${handlerName}() handlers must return a Result. Wrap values with ok(...) or err(...).`, ERR_MATCH_ERR_HANDLER_NOT_RESULT);
+		this.handlerName = handlerName;
+		this.returnedValue = returnedValue;
+	}
+};
+var UnwrapOnErrError = class extends ResultTypeError {
+	errorValue;
+	constructor(errorValue) {
+		super(`Called unwrap() on Err: ${String(errorValue)}`, ERR_UNWRAP_ON_ERR);
+		this.errorValue = errorValue;
+	}
+};
+var UnwrapErrOnOkError = class extends ResultTypeError {
+	okValue;
+	constructor(okValue) {
+		super(`Called unwrapErr() on Ok: ${String(okValue)}`, ERR_UNWRAP_ERR_ON_OK);
+		this.okValue = okValue;
+	}
+};
+var ExpectOkError = class extends ResultError {
+	expectedMessage;
+	constructor(expectedMessage) {
+		super(expectedMessage, ERR_EXPECT_OK);
+		this.expectedMessage = expectedMessage;
+	}
+};
+var ExpectErrError = class extends ResultError {
+	expectedMessage;
+	constructor(expectedMessage) {
+		super(expectedMessage, ERR_EXPECT_ERR);
+		this.expectedMessage = expectedMessage;
+	}
+};
+
+//#endregion
+export { TaskYieldNotResultError as _, ERR_MATCH_ERR_HANDLER_NOT_RESULT as a, ERR_UNWRAP_ERR_ON_OK as c, ExpectOkError as d, InvalidResultStateError as f, ResultTypeError as g, ResultError as h, ERR_INVALID_STATE as i, ERR_UNWRAP_ON_ERR as l, MatchOnOkError as m, ERR_EXPECT_OK as n, ERR_MATCH_ON_OK as o, MatchErrHandlerNotResultError as p, ERR_INVALID_RESULT_STATE as r, ERR_TASK_YIELD_NOT_RESULT as s, ERR_EXPECT_ERR as t, ExpectErrError as u, UnwrapErrOnOkError as v, UnwrapOnErrError as y };
+//# sourceMappingURL=errors-2WOswg7r.mjs.map