@shirudo/result 1.1.1 → 1.2.0

package/dist/operators.mjs

@@ -1,4 +1,385 @@
-import { m as zip, p as combine } from "./result-q9Na2bGa.mjs";
-import { C as tap, D as mapErr, E as mapBoth, O as map, S as filter, T as bimap, _ as recoverWith, a as or, b as match, c as tryCatchAsync, d as filterAsync, f as tapAsync, g as recover, h as mapAsync, i as orElse, l as matchAsync, m as mapErrAsync, n as mapOrElse, o as and, p as flatMapAsync, r as mapOr, s as tryMapAsync, t as swap, u as foldAsync, v as tryMap, w as flatMap, x as fold, y as tryCatch } from "./swap-CFD2g1cB.mjs";
+import { c as ok, i as err, m as zip, p as combine } from "./result-DQCpkuOJ.mjs";
+import { p as InvalidResultStateError } from "./errors-MuakEcnM.mjs";
 
-export { and, bimap, combine, filter, filterAsync, flatMap, flatMapAsync, fold, foldAsync, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, or, orElse, recover, recoverWith, swap, tap, tapAsync, tryCatch, tryCatchAsync, tryMap, tryMapAsync, zip };
+//#region src/core/map.ts
+/**
+* Transforms the value (Ok case).
+* Corresponds to Rust `map`.
+*/
+function map(project) {
+	return (source) => {
+		if (source.isOk()) return ok(project(source.value));
+		if (source.isErr()) return source;
+		throw new InvalidResultStateError("map");
+	};
+}
+
+//#endregion
+//#region src/core/mapErr.ts
+/**
+* Transforms the error (Err case).
+* Corresponds to Rust `map_err`.
+*/
+function mapErr(project) {
+	return (source) => {
+		if (source.isErr()) return err(project(source.error));
+		if (source.isOk()) return source;
+		throw new InvalidResultStateError("mapErr");
+	};
+}
+
+//#endregion
+//#region src/core/mapBoth.ts
+/**
+* Transforms both the Ok value and the Err error.
+* Corresponds to FP `bimap` / `mapBoth`.
+*/
+function mapBoth(mapOk, mapErr) {
+	return (source) => {
+		if (source.isOk()) return ok(mapOk(source.value));
+		if (source.isErr()) return err(mapErr(source.error));
+		throw new InvalidResultStateError("mapBoth");
+	};
+}
+/**
+* Alias for `mapBoth`.
+*/
+const bimap = mapBoth;
+
+//#endregion
+//#region src/core/flatMap.ts
+/**
+* Chains another operation that returns a Result.
+* Corresponds to Rust `and_then` or JS `flatMap`.
+*/
+function flatMap(project) {
+	return (source) => {
+		if (source.isOk()) return project(source.value);
+		if (source.isErr()) return source;
+		throw new InvalidResultStateError("flatMap");
+	};
+}
+
+//#endregion
+//#region src/core/tap.ts
+/**
+* Executes a side effect (logging, debugging) without changing the Result.
+* Corresponds to Rust `inspect` / `inspect_err`.
+*/
+function tap(observer) {
+	return (source) => {
+		if (source.isOk()) {
+			if (observer.ok) observer.ok(source.value);
+			return source;
+		}
+		if (source.isErr()) {
+			if (observer.err) observer.err(source.error);
+			return source;
+		}
+		throw new InvalidResultStateError("tap");
+	};
+}
+
+//#endregion
+//#region src/core/filter.ts
+/**
+* Checks a condition. If false, the Result becomes Err.
+* Corresponds to Rust `filter` (partially).
+*/
+function filter(predicate, errorFn) {
+	return (source) => {
+		if (source.isOk()) {
+			if (predicate(source.value)) return source;
+			return err(errorFn());
+		}
+		if (source.isErr()) return source;
+		throw new InvalidResultStateError("filter");
+	};
+}
+
+//#endregion
+//#region src/core/fold.ts
+/**
+* Folds the Result into a single value by applying one of two functions.
+* The end of the pipe.
+*
+* This is the pipe operator equivalent of the `.fold()` instance method.
+*/
+function fold(handlers) {
+	return (source) => {
+		if (source.isOk()) return handlers.ok(source.value);
+		if (source.isErr()) return handlers.err(source.error);
+		throw new InvalidResultStateError("fold");
+	};
+}
+
+//#endregion
+//#region src/core/tryCatch.ts
+function tryCatch(fn, errorMapper) {
+	return (source) => {
+		if (source.isErr()) return source;
+		try {
+			return ok(fn());
+		} catch (error) {
+			return err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/tryMap.ts
+function tryMap(project, errorMapper) {
+	return (source) => {
+		if (source.isErr()) return source;
+		if (!source.isOk()) throw new InvalidResultStateError("tryMap");
+		try {
+			return ok(project(source.value));
+		} catch (error) {
+			return err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/recover.ts
+/**
+* Recover: converts Err to Ok(defaultValue).
+* Result is guaranteed to be Ok → Error type becomes `never`.
+*/
+function recover(defaultValue) {
+	return (source) => {
+		if (source.isOk()) return source;
+		if (source.isErr()) return ok(defaultValue);
+		throw new InvalidResultStateError("recover");
+	};
+}
+/**
+* Like `recover`, but calculates the default value based on the error.
+*/
+function recoverWith(fn) {
+	return (source) => {
+		if (source.isOk()) return source;
+		if (source.isErr()) return ok(fn(source.error));
+		throw new InvalidResultStateError("recoverWith");
+	};
+}
+
+//#endregion
+//#region src/core/match.ts
+/**
+* Resolves the Result. The end of the pipe.
+* Corresponds to Rust `match`.
+*/
+function match(handlers) {
+	return (source) => {
+		if (source.isOk()) return handlers.ok(source.value);
+		if (source.isErr()) return handlers.err(source.error);
+		throw new InvalidResultStateError("match");
+	};
+}
+
+//#endregion
+//#region src/core/mapAsync.ts
+/**
+* Async version of map.
+*/
+function mapAsync(project) {
+	return async (source) => {
+		if (source.isOk()) return ok(await project(source.value));
+		if (source.isErr()) return source;
+		throw new InvalidResultStateError("mapAsync");
+	};
+}
+
+//#endregion
+//#region src/core/mapErrAsync.ts
+/**
+* Async version of mapErr.
+*/
+function mapErrAsync(project) {
+	return async (source) => {
+		if (source.isErr()) return err(await project(source.error));
+		if (source.isOk()) return source;
+		throw new InvalidResultStateError("mapErrAsync");
+	};
+}
+
+//#endregion
+//#region src/core/flatMapAsync.ts
+/**
+* Async version of flatMap.
+*/
+function flatMapAsync(project) {
+	return async (source) => {
+		if (source.isOk()) return await project(source.value);
+		if (source.isErr()) return source;
+		throw new InvalidResultStateError("flatMapAsync");
+	};
+}
+
+//#endregion
+//#region src/core/tapAsync.ts
+/**
+* Async version of tap.
+*/
+function tapAsync(observer) {
+	return async (source) => {
+		if (source.isOk()) {
+			if (observer.ok) await observer.ok(source.value);
+			return source;
+		}
+		if (source.isErr()) {
+			if (observer.err) await observer.err(source.error);
+			return source;
+		}
+		throw new InvalidResultStateError("tapAsync");
+	};
+}
+
+//#endregion
+//#region src/core/filterAsync.ts
+/**
+* Async version of filter.
+*/
+function filterAsync(predicate, errorFn) {
+	return async (source) => {
+		if (source.isOk()) {
+			if (await predicate(source.value)) return source;
+			return err(await errorFn());
+		}
+		if (source.isErr()) return source;
+		throw new InvalidResultStateError("filterAsync");
+	};
+}
+
+//#endregion
+//#region src/core/foldAsync.ts
+/**
+* Async version of `fold`. Folds the Result into a single value asynchronously.
+* The end of the pipe.
+*
+* This is the async pipe operator equivalent of the `.fold()` instance method.
+*/
+function foldAsync(handlers) {
+	return async (source) => {
+		if (source.isOk()) return await handlers.ok(source.value);
+		if (source.isErr()) return await handlers.err(source.error);
+		throw new InvalidResultStateError("foldAsync");
+	};
+}
+
+//#endregion
+//#region src/core/tryCatchAsync.ts
+function tryCatchAsync(fn, errorMapper) {
+	return async (source) => {
+		if (source.isErr()) return source;
+		try {
+			return ok(await fn());
+		} catch (error) {
+			return err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/tryMapAsync.ts
+function tryMapAsync(project, errorMapper) {
+	return async (source) => {
+		if (source.isErr()) return source;
+		if (!source.isOk()) throw new InvalidResultStateError("tryMapAsync");
+		try {
+			return ok(await project(source.value));
+		} catch (error) {
+			return err(errorMapper ? errorMapper(error) : error);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/matchAsync.ts
+/**
+* Async version of match.
+*/
+function matchAsync(handlers) {
+	return async (source) => {
+		if (source.isOk()) return await handlers.ok(source.value);
+		if (source.isErr()) return await handlers.err(source.error);
+		throw new InvalidResultStateError("matchAsync");
+	};
+}
+
+//#endregion
+//#region src/core/and.ts
+/**
+* Combines two Results. Returns the second one only if the first is Ok.
+* Corresponds to Rust `and`.
+*/
+function and(result, other) {
+	if (result.isOk()) return other;
+	if (result.isErr()) return result;
+	throw new InvalidResultStateError("and");
+}
+
+//#endregion
+//#region src/core/or.ts
+/**
+* Fallback to another Result if the first is Err.
+* Corresponds to Rust `or`.
+*/
+function or(result, other) {
+	if (result.isOk()) return result;
+	if (result.isErr()) return other;
+	throw new InvalidResultStateError("or");
+}
+
+//#endregion
+//#region src/core/orElse.ts
+/**
+* Fallback with a function that returns a Result.
+* Corresponds to Rust `or_else`.
+*/
+function orElse(result, fn) {
+	if (result.isOk()) return result;
+	if (result.isErr()) return fn(result.error);
+	throw new InvalidResultStateError("orElse");
+}
+
+//#endregion
+//#region src/core/mapOr.ts
+/**
+* Transforms the value or returns a default value.
+* Corresponds to Rust `map_or`.
+*/
+function mapOr(result, defaultValue, fn) {
+	if (result.isOk()) return fn(result.value);
+	if (result.isErr()) return defaultValue;
+	throw new InvalidResultStateError("mapOr");
+}
+
+//#endregion
+//#region src/core/mapOrElse.ts
+/**
+* Transforms the value or calculates a default value using a function.
+* Corresponds to Rust `map_or_else`.
+*/
+function mapOrElse(result, defaultFn, fn) {
+	if (result.isOk()) return fn(result.value);
+	if (result.isErr()) return defaultFn(result.error);
+	throw new InvalidResultStateError("mapOrElse");
+}
+
+//#endregion
+//#region src/core/swap.ts
+/**
+* Swaps Ok and Err.
+* Result<T, E> → Result<E, T>
+*/
+function swap(result) {
+	if (result.isOk()) return err(result.value);
+	if (result.isErr()) return ok(result.error);
+	throw new InvalidResultStateError("swap");
+}
+
+//#endregion
+export { and, bimap, combine, filter, filterAsync, flatMap, flatMapAsync, fold, foldAsync, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, or, orElse, recover, recoverWith, swap, tap, tapAsync, tryCatch, tryCatchAsync, tryMap, tryMapAsync, zip };
+//# sourceMappingURL=operators.mjs.map

package/dist/operators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.mjs","names":[],"sources":["../src/core/map.ts","../src/core/mapErr.ts","../src/core/mapBoth.ts","../src/core/flatMap.ts","../src/core/tap.ts","../src/core/filter.ts","../src/core/fold.ts","../src/core/tryCatch.ts","../src/core/tryMap.ts","../src/core/recover.ts","../src/core/match.ts","../src/core/mapAsync.ts","../src/core/mapErrAsync.ts","../src/core/flatMapAsync.ts","../src/core/tapAsync.ts","../src/core/filterAsync.ts","../src/core/foldAsync.ts","../src/core/tryCatchAsync.ts","../src/core/tryMapAsync.ts","../src/core/matchAsync.ts","../src/core/and.ts","../src/core/or.ts","../src/core/orElse.ts","../src/core/mapOr.ts","../src/core/mapOrElse.ts","../src/core/swap.ts"],"sourcesContent":["import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms the value (Ok case).\n * Corresponds to Rust `map`.\n */\nexport function map<T, E, U>(project: (value: T) => U) {\n    return (source: Result<T, E>): Result<U, E> => {\n        if (source.isOk()) {\n            return ok(project(source.value));\n        }\n        if (source.isErr()) return source as unknown as Result<U, E>;\n        throw new InvalidResultStateError('map');\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms the error (Err case).\n * Corresponds to Rust `map_err`.\n */\nexport function mapErr<T, E, F>(project: (error: E) => F) {\n    return (source: Result<T, E>): Result<T, F> => {\n        if (source.isErr()) {\n            return err(project(source.error));\n        }\n        if (source.isOk()) return source as unknown as Result<T, F>;\n        throw new InvalidResultStateError('mapErr');\n    };\n}\n","import type { Result } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms both the Ok value and the Err error.\n * Corresponds to FP `bimap` / `mapBoth`.\n */\nexport function mapBoth<T, E, U, F>(mapOk: (value: T) => U, mapErr: (error: E) => F) {\n    return (source: Result<T, E>): Result<U, F> => {\n        if (source.isOk()) {\n            return ok<U, F>(mapOk(source.value));\n        }\n        if (source.isErr()) {\n            return err<F, U>(mapErr(source.error));\n        }\n        throw new InvalidResultStateError('mapBoth');\n    };\n}\n\n/**\n * Alias for `mapBoth`.\n */\nexport const bimap: typeof mapBoth = mapBoth;\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Chains another operation that returns a Result.\n * Corresponds to Rust `and_then` or JS `flatMap`.\n */\nexport function flatMap<T, E, U, F>(project: (value: T) => Result<U, F>) {\n    return (source: Result<T, E>): Result<U, E | F> => {\n        if (source.isOk()) {\n            return project(source.value);\n        }\n        if (source.isErr()) return source as unknown as Result<U, E | F>;\n        throw new InvalidResultStateError('flatMap');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Executes a side effect (logging, debugging) without changing the Result.\n * Corresponds to Rust `inspect` / `inspect_err`.\n */\nexport function tap<T, E>(observer: { ok?: (val: T) => void; err?: (e: E) => void }) {\n    return (source: Result<T, E>): Result<T, E> => {\n        if (source.isOk()) {\n            if (observer.ok) observer.ok(source.value);\n            return source;\n        }\n        if (source.isErr()) {\n            if (observer.err) observer.err(source.error);\n            return source;\n        }\n        throw new InvalidResultStateError('tap');\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Checks a condition. If false, the Result becomes Err.\n * Corresponds to Rust `filter` (partially).\n */\nexport function filter<T, E>(predicate: (val: T) => boolean, errorFn: () => E) {\n    return (source: Result<T, E>): Result<T, E> => {\n        if (source.isOk()) {\n            if (predicate(source.value)) {\n                return source;\n            }\n            return err(errorFn());\n        }\n        if (source.isErr()) return source;\n        throw new InvalidResultStateError('filter');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Folds the Result into a single value by applying one of two functions.\n * The end of the pipe.\n *\n * This is the pipe operator equivalent of the `.fold()` instance method.\n */\nexport function fold<T, E, R>(handlers: { ok: (val: T) => R; err: (e: E) => R }) {\n    return (source: Result<T, E>): R => {\n        if (source.isOk()) {\n            return handlers.ok(source.value);\n        }\n        if (source.isErr()) return handlers.err(source.error);\n        throw new InvalidResultStateError('fold');\n    };\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\n\n/**\n * Executes a function and catches exceptions.\n * Converts exceptions into Result<E>.\n * Corresponds to Rust `Result::from` for fallible operations.\n */\nexport function tryCatch<T>(fn: () => T): <SE>(source: Result<unknown, SE>) => Result<T, unknown>;\nexport function tryCatch<T, E>(\n    fn: () => T,\n    errorMapper: (error: unknown) => E\n): <SE>(source: Result<unknown, SE>) => Result<T, SE | E>;\nexport function tryCatch<T, E>(\n    fn: () => T,\n    errorMapper?: (error: unknown) => E\n): <SE>(source: Result<unknown, SE>) => Result<T, SE | E> {\n    return <SE>(source: Result<unknown, SE>): Result<T, SE | E> => {\n        if (source.isErr()) return source as unknown as Result<T, SE | E>;\n\n        try {\n            return ok<T, SE | E>(fn());\n        } catch (error) {\n            return err<SE | E, T>(errorMapper ? errorMapper(error) : error as E);\n        }\n    };\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Like `map`, but catches exceptions and converts them to Err.\n */\nexport function tryMap<T, E, U>(project: (value: T) => U): (source: Result<T, E>) => Result<U, unknown>;\nexport function tryMap<T, E, U, F>(\n    project: (value: T) => U,\n    errorMapper: (error: unknown) => F\n): (source: Result<T, E>) => Result<U, E | F>;\nexport function tryMap<T, E, U, F>(\n    project: (value: T) => U,\n    errorMapper?: (error: unknown) => F\n): (source: Result<T, E>) => Result<U, E | F> {\n    return (source: Result<T, E>): Result<U, E | F> => {\n        if (source.isErr()) {\n            return source as unknown as Result<U, E | F>;\n        }\n        if (!source.isOk()) throw new InvalidResultStateError('tryMap');\n\n        try {\n            return ok<U, E | F>(project(source.value));\n        } catch (error) {\n            return err<E | F, U>(errorMapper ? errorMapper(error) : error as F);\n        }\n    };\n}\n","import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Recover: converts Err to Ok(defaultValue).\n * Result is guaranteed to be Ok → Error type becomes `never`.\n */\nexport function recover<T, E, F>(defaultValue: F) {\n    return (source: Result<T, E>): Result<T | F, never> => {\n        if (source.isOk()) return source as unknown as Result<T | F, never>;\n        if (source.isErr()) return ok(defaultValue);\n        throw new InvalidResultStateError('recover');\n    };\n}\n\n/**\n * Like `recover`, but calculates the default value based on the error.\n */\nexport function recoverWith<T, E, F>(fn: (error: E) => F) {\n    return (source: Result<T, E>): Result<T | F, never> => {\n        if (source.isOk()) return source as unknown as Result<T | F, never>;\n        if (source.isErr()) return ok(fn(source.error));\n        throw new InvalidResultStateError('recoverWith');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Resolves the Result. The end of the pipe.\n * Corresponds to Rust `match`.\n */\nexport function match<T, E, R>(handlers: { ok: (val: T) => R; err: (e: E) => R }) {\n    return (source: Result<T, E>): R => {\n        if (source.isOk()) {\n            return handlers.ok(source.value);\n        }\n        if (source.isErr()) return handlers.err(source.error);\n        throw new InvalidResultStateError('match');\n    };\n}\n","import type { Result } from './result';\nimport { ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of map.\n */\nexport function mapAsync<T, E, U>(project: (value: T) => Promise<U>) {\n    return async (source: Result<T, E>): Promise<Result<U, E>> => {\n        if (source.isOk()) {\n            return ok(await project(source.value));\n        }\n        if (source.isErr()) return source as unknown as Result<U, E>;\n        throw new InvalidResultStateError('mapAsync');\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of mapErr.\n */\nexport function mapErrAsync<T, E, F>(project: (error: E) => Promise<F>) {\n    return async (source: Result<T, E>): Promise<Result<T, F>> => {\n        if (source.isErr()) {\n            return err(await project(source.error));\n        }\n        if (source.isOk()) return source as unknown as Result<T, F>;\n        throw new InvalidResultStateError('mapErrAsync');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of flatMap.\n */\nexport function flatMapAsync<T, E, U, F>(project: (value: T) => Promise<Result<U, F>>) {\n    return async (source: Result<T, E>): Promise<Result<U, E | F>> => {\n        if (source.isOk()) {\n            return await project(source.value);\n        }\n        if (source.isErr()) return source as unknown as Result<U, E | F>;\n        throw new InvalidResultStateError('flatMapAsync');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of tap.\n */\nexport function tapAsync<T, E>(observer: { ok?: (val: T) => Promise<void>; err?: (e: E) => Promise<void> }) {\n    return async (source: Result<T, E>): Promise<Result<T, E>> => {\n        if (source.isOk()) {\n            if (observer.ok) await observer.ok(source.value);\n            return source;\n        }\n        if (source.isErr()) {\n            if (observer.err) await observer.err(source.error);\n            return source;\n        }\n        throw new InvalidResultStateError('tapAsync');\n    };\n}\n","import type { Result } from './result';\nimport { err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of filter.\n */\nexport function filterAsync<T, E>(predicate: (val: T) => Promise<boolean>, errorFn: () => Promise<E>) {\n    return async (source: Result<T, E>): Promise<Result<T, E>> => {\n        if (source.isOk()) {\n            if (await predicate(source.value)) {\n                return source;\n            }\n            return err(await errorFn());\n        }\n        if (source.isErr()) return source;\n        throw new InvalidResultStateError('filterAsync');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of `fold`. Folds the Result into a single value asynchronously.\n * The end of the pipe.\n *\n * This is the async pipe operator equivalent of the `.fold()` instance method.\n */\nexport function foldAsync<T, E, R>(handlers: { ok: (val: T) => Promise<R>; err: (e: E) => Promise<R> }) {\n    return async (source: Result<T, E>): Promise<R> => {\n        if (source.isOk()) {\n            return await handlers.ok(source.value);\n        }\n        if (source.isErr()) return await handlers.err(source.error);\n        throw new InvalidResultStateError('foldAsync');\n    };\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\n\n/**\n * Async version of tryCatch.\n */\nexport function tryCatchAsync<T>(fn: () => Promise<T>): <SE>(source: Result<unknown, SE>) => Promise<Result<T, unknown>>;\nexport function tryCatchAsync<T, E>(\n    fn: () => Promise<T>,\n    errorMapper: (error: unknown) => E\n): <SE>(source: Result<unknown, SE>) => Promise<Result<T, SE | E>>;\nexport function tryCatchAsync<T, E>(\n    fn: () => Promise<T>,\n    errorMapper?: (error: unknown) => E\n): <SE>(source: Result<unknown, SE>) => Promise<Result<T, SE | E>> {\n    return async <SE>(source: Result<unknown, SE>): Promise<Result<T, SE | E>> => {\n        if (source.isErr()) return source as unknown as Result<T, SE | E>;\n\n        try {\n            return ok<T, SE | E>(await fn());\n        } catch (error) {\n            return err<SE | E, T>(errorMapper ? errorMapper(error) : error as E);\n        }\n    };\n}\n","import type { Result } from './result';\nimport { ok, err } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of tryMap.\n */\nexport function tryMapAsync<T, E, U>(project: (value: T) => Promise<U>): (source: Result<T, E>) => Promise<Result<U, unknown>>;\nexport function tryMapAsync<T, E, U, F>(\n    project: (value: T) => Promise<U>,\n    errorMapper: (error: unknown) => F\n): (source: Result<T, E>) => Promise<Result<U, E | F>>;\nexport function tryMapAsync<T, E, U, F>(\n    project: (value: T) => Promise<U>,\n    errorMapper?: (error: unknown) => F\n): (source: Result<T, E>) => Promise<Result<U, E | F>> {\n    return async (source: Result<T, E>): Promise<Result<U, E | F>> => {\n        if (source.isErr()) {\n            return source as unknown as Result<U, E | F>;\n        }\n        if (!source.isOk()) throw new InvalidResultStateError('tryMapAsync');\n\n        try {\n            return ok<U, E | F>(await project(source.value));\n        } catch (error) {\n            return err<E | F, U>(errorMapper ? errorMapper(error) : error as F);\n        }\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of match.\n */\nexport function matchAsync<T, E, R>(handlers: { ok: (val: T) => Promise<R>; err: (e: E) => Promise<R> }) {\n    return async (source: Result<T, E>): Promise<R> => {\n        if (source.isOk()) {\n            return await handlers.ok(source.value);\n        }\n        if (source.isErr()) return await handlers.err(source.error);\n        throw new InvalidResultStateError('matchAsync');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Combines two Results. Returns the second one only if the first is Ok.\n * Corresponds to Rust `and`.\n */\nexport function and<T, E, U>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n    if (result.isOk()) return other;\n    if (result.isErr()) return result as unknown as Result<U, E>;\n    throw new InvalidResultStateError('and');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Fallback to another Result if the first is Err.\n * Corresponds to Rust `or`.\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n    if (result.isOk()) return result as unknown as Result<T, F>;\n    if (result.isErr()) return other;\n    throw new InvalidResultStateError('or');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Fallback with a function that returns a Result.\n * Corresponds to Rust `or_else`.\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n    if (result.isOk()) return result as unknown as Result<T, F>;\n    if (result.isErr()) return fn(result.error);\n    throw new InvalidResultStateError('orElse');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms the value or returns a default value.\n * Corresponds to Rust `map_or`.\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n    if (result.isOk()) return fn(result.value);\n    if (result.isErr()) return defaultValue;\n    throw new InvalidResultStateError('mapOr');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms the value or calculates a default value using a function.\n * Corresponds to Rust `map_or_else`.\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: (error: E) => U, fn: (value: T) => U): U {\n    if (result.isOk()) return fn(result.value);\n    if (result.isErr()) return defaultFn(result.error);\n    throw new InvalidResultStateError('mapOrElse');\n}\n","import type { Result } from './result';\nimport { err, ok } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Swaps Ok and Err.\n * Result<T, E> → Result<E, T>\n */\nexport function swap<T, E>(result: Result<T, E>): Result<E, T> {\n    if (result.isOk()) {\n        return err<T, E>(result.value);\n    }\n    if (result.isErr()) {\n        return ok<E, T>(result.error);\n    }\n    throw new InvalidResultStateError('swap');\n}\n"],"mappings":"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"}

package/dist/{result-q9Na2bGa.mjs → result-DQCpkuOJ.mjs}

@@ -1,4 +1,4 @@
-import { ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, MatchTagMissingHandlerError, UnwrapErrOnOkError, UnwrapOnErrError } from "./errors.mjs";
+import { S as describeErrorMessage, b as UnwrapErrOnOkError, d as ExpectErrError, f as ExpectOkError, g as MatchTagMissingHandlerError, h as MatchOnOkError, m as MatchErrHandlerNotResultError, p as InvalidResultStateError, x as UnwrapOnErrError } from "./errors-MuakEcnM.mjs";
 
 //#region src/core/pipeable.ts
 var Pipeable = class {
@@ -60,7 +60,9 @@ function matchTag(result, key, handlers) {
 *
 * - `.when(Ctor, handler)` matches via `instanceof`
 * - `.whenGuard(guard, handler)` matches via Type-Guard
-* - `.run()` is only allowed if all error cases have been handled (`E` has been reduced to `never`)
+* - `.run()` is only allowed if all error cases have been handled (`E` has been reduced to `never`).
+*   The reduction is structural: two error classes of the same shape count as one case, so each
+*   class needs a distinguishing member, for example a literal `readonly code`.
 */
 var ErrorMatchBuilder = class ErrorMatchBuilder {
 	#error;
@@ -172,7 +174,8 @@ var ErrMatchBuilder = class ErrMatchBuilder {
 	when(ctor, handler) {
 		if (this.#resolved) return this;
 		if (this.#error instanceof ctor) {
-			const resolved = expectResultReturn(handler(this.#error), "when");
+			const out = handler(this.#error);
+			const resolved = expectResultReturn(out, "when");
 			return new ErrMatchBuilder(this.#error, resolved);
 		}
 		return this;
@@ -181,7 +184,8 @@ var ErrMatchBuilder = class ErrMatchBuilder {
 		if (this.#resolved) return this;
 		const error = this.#error;
 		if (guard(error)) {
-			const resolved = expectResultReturn(handler(error), "whenGuard");
+			const out = handler(error);
+			const resolved = expectResultReturn(out, "whenGuard");
 			return new ErrMatchBuilder(this.#error, resolved);
 		}
 		return this;
@@ -189,14 +193,16 @@ var ErrMatchBuilder = class ErrMatchBuilder {
 	whenTag(key, tag, handler) {
 		if (this.#resolved) return this;
 		if (matchesTag(this.#error, key, tag)) {
-			const resolved = expectResultReturn(handler(this.#error), "whenTag");
+			const out = handler(this.#error);
+			const resolved = expectResultReturn(out, "whenTag");
 			return new ErrMatchBuilder(this.#error, resolved);
 		}
 		return this;
 	}
 	otherwise(handler) {
 		if (this.#resolved) return this.#resolved;
-		return expectResultReturn(handler(this.#error), "otherwise");
+		const out = handler(this.#error);
+		return expectResultReturn(out, "otherwise");
 	}
 	run() {
 		if (this.#resolved) return this.#resolved;
@@ -244,7 +250,8 @@ var AsyncErrMatchBuilder = class AsyncErrMatchBuilder {
 	}
 	async otherwise(handler) {
 		if (this.#resolve) return await this.#invoke();
-		return expectResultReturn(await handler(this.#error), "otherwise");
+		const out = await handler(this.#error);
+		return expectResultReturn(out, "otherwise");
 	}
 	async run() {
 		if (this.#resolve) return await this.#invoke();
@@ -432,12 +439,24 @@ var ResultBase = class extends Pipeable {
 		return AsyncErrMatchBuilder.fromResult(this);
 	}
 	/**
-	* Serializes the Result into the discriminated shape
-	* `{ _tag: 'Ok', value }` / `{ _tag: 'Err', error }`.
+	* Converts the Result into its plain discriminated shape
+	* `{ _tag: 'Ok', value }` / `{ _tag: 'Err', error }` (`ResultType<T, E>`),
+	* with no prototype, methods, or brand attached.
 	*
-	* Unlike {@link serialize}, `Ok(undefined)` stays unambiguous, and the
-	* shape round-trips through `fromSerialized(...)`. It also matches what
-	* `JSON.stringify(result)` produces for a Result instance.
+	* Unlike {@link serialize}, `Ok(undefined)` stays unambiguous, because the
+	* `_tag` discriminant carries the state. The returned `Ok` object holds
+	* the `value` key, and `JSON.stringify` encodes it exactly as it encodes
+	* the Result instance, so the shape is safe for JSON, `structuredClone`,
+	* and `postMessage`. JSON is the lossy step: `JSON.stringify` drops a key
+	* whose value is `undefined`, so `Ok(undefined)` crosses the wire as
+	* `{"_tag":"Ok"}`, and `ok(parsed.value)` rebuilds it.
+	*
+	* To rebuild a Result on the other side, validate the payload with your
+	* schema tool and then call `ok`/`err` on the discriminant:
+	*
+	* ```ts
+	* const restored = parsed._tag === 'Ok' ? ok(parsed.value) : err(parsed.error);
+	* ```
 	*/
 	toSerialized() {
 		if (this._tag === "Ok") return {
@@ -456,8 +475,9 @@ var ResultBase = class extends Pipeable {
 	*
 	* @deprecated Use {@link toSerialized} instead: with this format,
 	* `Ok(undefined)` is indistinguishable from a missing `data` field, and
-	* there is no way to rebuild a Result from it. `toSerialized()`
-	* round-trips via `fromSerialized(...)`.
+	* the shape does not match what `JSON.stringify(result)` produces.
+	* `toSerialized()` returns the discriminated `ResultType<T, E>`, which
+	* rebuilds unambiguously via `ok`/`err`.
 	*/
 	serialize() {
 		if (this._tag === "Ok") return {
@@ -480,10 +500,9 @@ var ResultBase = class extends Pipeable {
 			data: this.value
 		};
 		if (this._tag !== "Err") throw new InvalidResultStateError("Result.toUserFriendly");
-		const error = this.error;
 		return {
 			isSuccess: false,
-			error: error && typeof error === "object" && "message" in error ? String(error.message) : String(error)
+			error: describeErrorMessage(this.error)
 		};
 	}
 };
@@ -573,4 +592,4 @@ const Result = {
 
 //#endregion
 export { matchTag as _, fromNullable as a, ok as c, tryAsync as d, tryFn as f, sequence as g, all as h, err as i, okIf as l, zip as m, Ok as n, fromPromise as o, combine as p, Result as r, fromThrowable as s, Err as t, okIfLazy as u, isResult as v };
-//# sourceMappingURL=result-q9Na2bGa.mjs.map
+//# sourceMappingURL=result-DQCpkuOJ.mjs.map