@shirudo/result 1.0.0 → 1.1.0

package/README.md

@@ -5,7 +5,6 @@ Robust, type-safe error handling for TypeScript.
 `@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.
 
 [![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)
-[![codecov](https://codecov.io/gh/shi-rudo/result-ts/graph/badge.svg)](https://codecov.io/gh/shi-rudo/result-ts)
 [![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/)

package/dist/collections.cjs

@@ -1,9 +1,10 @@
-const require_result = require('./result-CY-KIivk.cjs');
-const require_flatten = require('./flatten-Df9U40nO.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_result = require('./result-BBOGxvSH.cjs');
+const require_flatten = require('./flatten-B_XIkaOK.cjs');
 
 exports.all = require_result.all;
 exports.collectAllErrors = require_flatten.collectAllErrors;
-exports.collectFirstOk = require_result.collectFirstOk;
+exports.collectFirstOk = require_flatten.collectFirstOk;
 exports.collectFirstOkAsync = require_flatten.collectFirstOkAsync;
 exports.collectFirstOkParallelAsync = require_flatten.collectFirstOkParallelAsync;
 exports.flatten = require_flatten.flatten;

package/dist/collections.d.cts

@@ -1,3 +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";
+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 };

package/dist/collections.d.mts

@@ -1,3 +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";
+import { n as sequence, t as all } from "./sequence-DDwePRLd.mjs";
+import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as collectFirstOk, r as collectAllErrors, s as sequenceRecord, t as flatten } from "./flatten-C7D6Kttf.mjs";
 export { all, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, flatten, partition, sequence, sequenceRecord };

package/dist/collections.mjs

@@ -1,4 +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";
+import { g as sequence, h as all } from "./result-q9Na2bGa.mjs";
+import { a as collectFirstOkAsync, i as collectFirstOkParallelAsync, n as partition, o as collectFirstOk, r as collectAllErrors, s as sequenceRecord, t as flatten } from "./flatten-ChTL5BfA.mjs";
 
 export { all, collectAllErrors, collectFirstOk, collectFirstOkAsync, collectFirstOkParallelAsync, flatten, partition, sequence, sequenceRecord };

package/dist/errors.cjs

@@ -1,21 +1,132 @@
-const require_errors = require('./errors-D2EMzJQl.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-exports.ERR_EXPECT_ERR = require_errors.ERR_EXPECT_ERR;
-exports.ERR_EXPECT_OK = require_errors.ERR_EXPECT_OK;
-exports.ERR_INVALID_RESULT_STATE = require_errors.ERR_INVALID_RESULT_STATE;
-exports.ERR_INVALID_STATE = require_errors.ERR_INVALID_STATE;
-exports.ERR_MATCH_ERR_HANDLER_NOT_RESULT = require_errors.ERR_MATCH_ERR_HANDLER_NOT_RESULT;
-exports.ERR_MATCH_ON_OK = require_errors.ERR_MATCH_ON_OK;
-exports.ERR_TASK_YIELD_NOT_RESULT = require_errors.ERR_TASK_YIELD_NOT_RESULT;
-exports.ERR_UNWRAP_ERR_ON_OK = require_errors.ERR_UNWRAP_ERR_ON_OK;
-exports.ERR_UNWRAP_ON_ERR = require_errors.ERR_UNWRAP_ON_ERR;
-exports.ExpectErrError = require_errors.ExpectErrError;
-exports.ExpectOkError = require_errors.ExpectOkError;
-exports.InvalidResultStateError = require_errors.InvalidResultStateError;
-exports.MatchErrHandlerNotResultError = require_errors.MatchErrHandlerNotResultError;
-exports.MatchOnOkError = require_errors.MatchOnOkError;
-exports.ResultError = require_errors.ResultError;
-exports.ResultTypeError = require_errors.ResultTypeError;
-exports.TaskYieldNotResultError = require_errors.TaskYieldNotResultError;
-exports.UnwrapErrOnOkError = require_errors.UnwrapErrOnOkError;
-exports.UnwrapOnErrError = require_errors.UnwrapOnErrError;
+//#region src/errors.ts
+const ERR_INVALID_RESULT_STATE = "ERR_INVALID_RESULT_STATE";
+/** @deprecated Use {@link ERR_INVALID_RESULT_STATE} instead. */
+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_MATCH_TAG_MISSING_HANDLER = "ERR_MATCH_TAG_MISSING_HANDLER";
+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 MatchTagMissingHandlerError = class extends ResultTypeError {
+	tagValue;
+	constructor(tagValue) {
+		super(`matchTag() has no handler for tag "${String(tagValue)}".`, ERR_MATCH_TAG_MISSING_HANDLER);
+		this.tagValue = tagValue;
+	}
+};
+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;
+	errorValue;
+	constructor(expectedMessage, errorValue) {
+		super(errorValue === void 0 ? expectedMessage : `${expectedMessage}: ${String(errorValue)}`, ERR_EXPECT_OK);
+		this.expectedMessage = expectedMessage;
+		this.errorValue = errorValue;
+		if (errorValue !== void 0) this.cause = errorValue;
+	}
+};
+var ExpectErrError = class extends ResultError {
+	expectedMessage;
+	okValue;
+	constructor(expectedMessage, okValue) {
+		super(okValue === void 0 ? expectedMessage : `${expectedMessage}: ${String(okValue)}`, ERR_EXPECT_ERR);
+		this.expectedMessage = expectedMessage;
+		this.okValue = okValue;
+		if (okValue !== void 0) this.cause = okValue;
+	}
+};
+
+//#endregion
+exports.ERR_EXPECT_ERR = ERR_EXPECT_ERR;
+exports.ERR_EXPECT_OK = ERR_EXPECT_OK;
+exports.ERR_INVALID_RESULT_STATE = ERR_INVALID_RESULT_STATE;
+exports.ERR_INVALID_STATE = ERR_INVALID_STATE;
+exports.ERR_MATCH_ERR_HANDLER_NOT_RESULT = ERR_MATCH_ERR_HANDLER_NOT_RESULT;
+exports.ERR_MATCH_ON_OK = ERR_MATCH_ON_OK;
+exports.ERR_MATCH_TAG_MISSING_HANDLER = ERR_MATCH_TAG_MISSING_HANDLER;
+exports.ERR_TASK_YIELD_NOT_RESULT = ERR_TASK_YIELD_NOT_RESULT;
+exports.ERR_UNWRAP_ERR_ON_OK = ERR_UNWRAP_ERR_ON_OK;
+exports.ERR_UNWRAP_ON_ERR = ERR_UNWRAP_ON_ERR;
+exports.ExpectErrError = ExpectErrError;
+exports.ExpectOkError = ExpectOkError;
+exports.InvalidResultStateError = InvalidResultStateError;
+exports.MatchErrHandlerNotResultError = MatchErrHandlerNotResultError;
+exports.MatchOnOkError = MatchOnOkError;
+exports.MatchTagMissingHandlerError = MatchTagMissingHandlerError;
+exports.ResultError = ResultError;
+exports.ResultTypeError = ResultTypeError;
+exports.TaskYieldNotResultError = TaskYieldNotResultError;
+exports.UnwrapErrOnOkError = UnwrapErrOnOkError;
+exports.UnwrapOnErrError = UnwrapOnErrError;
+//# sourceMappingURL=errors.cjs.map

package/dist/errors.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.cjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["export const ERR_INVALID_RESULT_STATE = 'ERR_INVALID_RESULT_STATE' as const;\n/** @deprecated Use {@link ERR_INVALID_RESULT_STATE} instead. */\nexport const ERR_INVALID_STATE: typeof ERR_INVALID_RESULT_STATE = ERR_INVALID_RESULT_STATE;\nexport const ERR_TASK_YIELD_NOT_RESULT = 'ERR_TASK_YIELD_NOT_RESULT' as const;\nexport const ERR_MATCH_ON_OK = 'ERR_MATCH_ON_OK' as const;\nexport const ERR_MATCH_ERR_HANDLER_NOT_RESULT = 'ERR_MATCH_ERR_HANDLER_NOT_RESULT' as const;\nexport const ERR_MATCH_TAG_MISSING_HANDLER = 'ERR_MATCH_TAG_MISSING_HANDLER' as const;\nexport const ERR_UNWRAP_ON_ERR = 'ERR_UNWRAP_ON_ERR' as const;\nexport const ERR_UNWRAP_ERR_ON_OK = 'ERR_UNWRAP_ERR_ON_OK' as const;\nexport const ERR_EXPECT_OK = 'ERR_EXPECT_OK' as const;\nexport const ERR_EXPECT_ERR = 'ERR_EXPECT_ERR' as const;\n\nexport type ResultErrorCode =\n    | typeof ERR_INVALID_RESULT_STATE\n    | typeof ERR_TASK_YIELD_NOT_RESULT\n    | typeof ERR_MATCH_ON_OK\n    | typeof ERR_MATCH_ERR_HANDLER_NOT_RESULT\n    | typeof ERR_MATCH_TAG_MISSING_HANDLER\n    | typeof ERR_UNWRAP_ON_ERR\n    | typeof ERR_UNWRAP_ERR_ON_OK\n    | typeof ERR_EXPECT_OK\n    | typeof ERR_EXPECT_ERR;\n\nconst formatResultErrorMessage = (code: ResultErrorCode, message: string, context?: string): string => {\n    if (context) {\n        return `${code}: ${message} (context: ${context})`;\n    }\n    return `${code}: ${message}`;\n};\n\nexport class ResultError extends Error {\n    readonly code: ResultErrorCode;\n    readonly context?: string;\n\n    constructor(message: string, code: ResultErrorCode, context?: string) {\n        super(formatResultErrorMessage(code, message, context));\n        this.code = code;\n        this.context = context;\n        this.name = new.target.name;\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\nexport class ResultTypeError extends TypeError {\n    readonly code: ResultErrorCode;\n    readonly context?: string;\n\n    constructor(message: string, code: ResultErrorCode, context?: string) {\n        super(formatResultErrorMessage(code, message, context));\n        this.code = code;\n        this.context = context;\n        this.name = new.target.name;\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\nconst INVALID_RESULT_STATE_MESSAGE = 'Unreachable: Result is neither Ok nor Err';\n\nexport class InvalidResultStateError extends ResultError {\n    constructor(context?: string) {\n        super(INVALID_RESULT_STATE_MESSAGE, ERR_INVALID_RESULT_STATE, context);\n    }\n}\n\nexport class TaskYieldNotResultError extends ResultTypeError {\n    readonly yieldedValue: unknown;\n\n    constructor(yieldedValue: unknown) {\n        super('task() expected yielded values to be Result. Use `yield*` on a Result.', ERR_TASK_YIELD_NOT_RESULT);\n        this.yieldedValue = yieldedValue;\n    }\n}\n\nexport class MatchOnOkError extends ResultTypeError {\n    constructor(methodName = 'match') {\n        super(`${methodName}() can only be called on Err results. Use \\`if (result.isErr()) { ... }\\` first.`, ERR_MATCH_ON_OK);\n    }\n}\n\nexport class MatchErrHandlerNotResultError extends ResultTypeError {\n    readonly handlerName: string;\n    readonly returnedValue: unknown;\n\n    constructor(handlerName: string, returnedValue: unknown) {\n        super(`matchErr().${handlerName}() handlers must return a Result. Wrap values with ok(...) or err(...).`, ERR_MATCH_ERR_HANDLER_NOT_RESULT);\n        this.handlerName = handlerName;\n        this.returnedValue = returnedValue;\n    }\n}\n\nexport class MatchTagMissingHandlerError extends ResultTypeError {\n    readonly tagValue: unknown;\n\n    constructor(tagValue: unknown) {\n        super(`matchTag() has no handler for tag \"${String(tagValue)}\".`, ERR_MATCH_TAG_MISSING_HANDLER);\n        this.tagValue = tagValue;\n    }\n}\n\nexport class UnwrapOnErrError extends ResultTypeError {\n    readonly errorValue: unknown;\n\n    constructor(errorValue: unknown) {\n        super(`Called unwrap() on Err: ${String(errorValue)}`, ERR_UNWRAP_ON_ERR);\n        this.errorValue = errorValue;\n    }\n}\n\nexport class UnwrapErrOnOkError extends ResultTypeError {\n    readonly okValue: unknown;\n\n    constructor(okValue: unknown) {\n        super(`Called unwrapErr() on Ok: ${String(okValue)}`, ERR_UNWRAP_ERR_ON_OK);\n        this.okValue = okValue;\n    }\n}\n\nexport class ExpectOkError extends ResultError {\n    readonly expectedMessage: string;\n    readonly errorValue: unknown;\n\n    constructor(expectedMessage: string, errorValue?: unknown) {\n        super(errorValue === undefined ? expectedMessage : `${expectedMessage}: ${String(errorValue)}`, ERR_EXPECT_OK);\n        this.expectedMessage = expectedMessage;\n        this.errorValue = errorValue;\n        if (errorValue !== undefined) this.cause = errorValue;\n    }\n}\n\nexport class ExpectErrError extends ResultError {\n    readonly expectedMessage: string;\n    readonly okValue: unknown;\n\n    constructor(expectedMessage: string, okValue?: unknown) {\n        super(okValue === undefined ? expectedMessage : `${expectedMessage}: ${String(okValue)}`, ERR_EXPECT_ERR);\n        this.expectedMessage = expectedMessage;\n        this.okValue = okValue;\n        if (okValue !== undefined) this.cause = okValue;\n    }\n}\n"],"mappings":";;;AAAA,MAAa,2BAA2B;;AAExC,MAAa,oBAAqD;AAClE,MAAa,4BAA4B;AACzC,MAAa,kBAAkB;AAC/B,MAAa,mCAAmC;AAChD,MAAa,gCAAgC;AAC7C,MAAa,oBAAoB;AACjC,MAAa,uBAAuB;AACpC,MAAa,gBAAgB;AAC7B,MAAa,iBAAiB;AAa9B,MAAM,4BAA4B,MAAuB,SAAiB,YAA6B;CACnG,IAAI,SACA,OAAO,GAAG,KAAK,IAAI,QAAQ,aAAa,QAAQ;CAEpD,OAAO,GAAG,KAAK,IAAI;AACvB;AAEA,IAAa,cAAb,cAAiC,MAAM;CACnC,AAAS;CACT,AAAS;CAET,YAAY,SAAiB,MAAuB,SAAkB;EAClE,MAAM,yBAAyB,MAAM,SAAS,OAAO,CAAC;EACtD,KAAK,OAAO;EACZ,KAAK,UAAU;EACf,KAAK,OAAO,IAAI,OAAO;EACvB,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;CACpD;AACJ;AAEA,IAAa,kBAAb,cAAqC,UAAU;CAC3C,AAAS;CACT,AAAS;CAET,YAAY,SAAiB,MAAuB,SAAkB;EAClE,MAAM,yBAAyB,MAAM,SAAS,OAAO,CAAC;EACtD,KAAK,OAAO;EACZ,KAAK,UAAU;EACf,KAAK,OAAO,IAAI,OAAO;EACvB,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;CACpD;AACJ;AAEA,MAAM,+BAA+B;AAErC,IAAa,0BAAb,cAA6C,YAAY;CACrD,YAAY,SAAkB;EAC1B,MAAM,8BAA8B,0BAA0B,OAAO;CACzE;AACJ;AAEA,IAAa,0BAAb,cAA6C,gBAAgB;CACzD,AAAS;CAET,YAAY,cAAuB;EAC/B,MAAM,0EAA0E,yBAAyB;EACzG,KAAK,eAAe;CACxB;AACJ;AAEA,IAAa,iBAAb,cAAoC,gBAAgB;CAChD,YAAY,aAAa,SAAS;EAC9B,MAAM,GAAG,WAAW,mFAAmF,eAAe;CAC1H;AACJ;AAEA,IAAa,gCAAb,cAAmD,gBAAgB;CAC/D,AAAS;CACT,AAAS;CAET,YAAY,aAAqB,eAAwB;EACrD,MAAM,cAAc,YAAY,0EAA0E,gCAAgC;EAC1I,KAAK,cAAc;EACnB,KAAK,gBAAgB;CACzB;AACJ;AAEA,IAAa,8BAAb,cAAiD,gBAAgB;CAC7D,AAAS;CAET,YAAY,UAAmB;EAC3B,MAAM,sCAAsC,OAAO,QAAQ,EAAE,KAAK,6BAA6B;EAC/F,KAAK,WAAW;CACpB;AACJ;AAEA,IAAa,mBAAb,cAAsC,gBAAgB;CAClD,AAAS;CAET,YAAY,YAAqB;EAC7B,MAAM,2BAA2B,OAAO,UAAU,KAAK,iBAAiB;EACxE,KAAK,aAAa;CACtB;AACJ;AAEA,IAAa,qBAAb,cAAwC,gBAAgB;CACpD,AAAS;CAET,YAAY,SAAkB;EAC1B,MAAM,6BAA6B,OAAO,OAAO,KAAK,oBAAoB;EAC1E,KAAK,UAAU;CACnB;AACJ;AAEA,IAAa,gBAAb,cAAmC,YAAY;CAC3C,AAAS;CACT,AAAS;CAET,YAAY,iBAAyB,YAAsB;EACvD,MAAM,eAAe,SAAY,kBAAkB,GAAG,gBAAgB,IAAI,OAAO,UAAU,KAAK,aAAa;EAC7G,KAAK,kBAAkB;EACvB,KAAK,aAAa;EAClB,IAAI,eAAe,QAAW,KAAK,QAAQ;CAC/C;AACJ;AAEA,IAAa,iBAAb,cAAoC,YAAY;CAC5C,AAAS;CACT,AAAS;CAET,YAAY,iBAAyB,SAAmB;EACpD,MAAM,YAAY,SAAY,kBAAkB,GAAG,gBAAgB,IAAI,OAAO,OAAO,KAAK,cAAc;EACxG,KAAK,kBAAkB;EACvB,KAAK,UAAU;EACf,IAAI,YAAY,QAAW,KAAK,QAAQ;CAC5C;AACJ"}

package/dist/errors.d.cts

@@ -1,2 +1,63 @@
-import { _ as ResultTypeError, a as ERR_MATCH_ERR_HANDLER_NOT_RESULT, b as UnwrapOnErrError, c as ERR_UNWRAP_ERR_ON_OK, d as ExpectOkError, f as InvalidResultStateError, g as ResultErrorCode, h as ResultError, i as ERR_INVALID_STATE, l as ERR_UNWRAP_ON_ERR, m as MatchOnOkError, n as ERR_EXPECT_OK, o as ERR_MATCH_ON_OK, p as MatchErrHandlerNotResultError, r as ERR_INVALID_RESULT_STATE, s as ERR_TASK_YIELD_NOT_RESULT, t as ERR_EXPECT_ERR, u as ExpectErrError, v as TaskYieldNotResultError, y as UnwrapErrOnOkError } from "./errors-BFjY06EV.cjs";
-export { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, ResultError, ResultErrorCode, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError };
+//#region src/errors.d.ts
+declare const ERR_INVALID_RESULT_STATE: "ERR_INVALID_RESULT_STATE";
+/** @deprecated Use {@link ERR_INVALID_RESULT_STATE} instead. */
+declare const ERR_INVALID_STATE: typeof ERR_INVALID_RESULT_STATE;
+declare const ERR_TASK_YIELD_NOT_RESULT: "ERR_TASK_YIELD_NOT_RESULT";
+declare const ERR_MATCH_ON_OK: "ERR_MATCH_ON_OK";
+declare const ERR_MATCH_ERR_HANDLER_NOT_RESULT: "ERR_MATCH_ERR_HANDLER_NOT_RESULT";
+declare const ERR_MATCH_TAG_MISSING_HANDLER: "ERR_MATCH_TAG_MISSING_HANDLER";
+declare const ERR_UNWRAP_ON_ERR: "ERR_UNWRAP_ON_ERR";
+declare const ERR_UNWRAP_ERR_ON_OK: "ERR_UNWRAP_ERR_ON_OK";
+declare const ERR_EXPECT_OK: "ERR_EXPECT_OK";
+declare const ERR_EXPECT_ERR: "ERR_EXPECT_ERR";
+type ResultErrorCode = typeof ERR_INVALID_RESULT_STATE | typeof ERR_TASK_YIELD_NOT_RESULT | typeof ERR_MATCH_ON_OK | typeof ERR_MATCH_ERR_HANDLER_NOT_RESULT | typeof ERR_MATCH_TAG_MISSING_HANDLER | typeof ERR_UNWRAP_ON_ERR | typeof ERR_UNWRAP_ERR_ON_OK | typeof ERR_EXPECT_OK | typeof ERR_EXPECT_ERR;
+declare class ResultError extends Error {
+  readonly code: ResultErrorCode;
+  readonly context?: string;
+  constructor(message: string, code: ResultErrorCode, context?: string);
+}
+declare class ResultTypeError extends TypeError {
+  readonly code: ResultErrorCode;
+  readonly context?: string;
+  constructor(message: string, code: ResultErrorCode, context?: string);
+}
+declare class InvalidResultStateError extends ResultError {
+  constructor(context?: string);
+}
+declare class TaskYieldNotResultError extends ResultTypeError {
+  readonly yieldedValue: unknown;
+  constructor(yieldedValue: unknown);
+}
+declare class MatchOnOkError extends ResultTypeError {
+  constructor(methodName?: string);
+}
+declare class MatchErrHandlerNotResultError extends ResultTypeError {
+  readonly handlerName: string;
+  readonly returnedValue: unknown;
+  constructor(handlerName: string, returnedValue: unknown);
+}
+declare class MatchTagMissingHandlerError extends ResultTypeError {
+  readonly tagValue: unknown;
+  constructor(tagValue: unknown);
+}
+declare class UnwrapOnErrError extends ResultTypeError {
+  readonly errorValue: unknown;
+  constructor(errorValue: unknown);
+}
+declare class UnwrapErrOnOkError extends ResultTypeError {
+  readonly okValue: unknown;
+  constructor(okValue: unknown);
+}
+declare class ExpectOkError extends ResultError {
+  readonly expectedMessage: string;
+  readonly errorValue: unknown;
+  constructor(expectedMessage: string, errorValue?: unknown);
+}
+declare class ExpectErrError extends ResultError {
+  readonly expectedMessage: string;
+  readonly okValue: unknown;
+  constructor(expectedMessage: string, okValue?: unknown);
+}
+//#endregion
+export { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_MATCH_TAG_MISSING_HANDLER, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, MatchTagMissingHandlerError, ResultError, ResultErrorCode, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError };
+//# sourceMappingURL=errors.d.cts.map

package/dist/errors.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.cts","names":[],"sources":["../src/errors.ts"],"mappings":";cAAa,wBAAA;AAAb;AAAA,cAEa,iBAAA,SAA0B,wBAAA;AAAA,cAC1B,yBAAA;AAAA,cACA,eAAA;AAAA,cACA,gCAAA;AAAA,cACA,6BAAA;AAAA,cACA,iBAAA;AAAA,cACA,oBAAA;AAAA,cACA,aAAA;AAAA,cACA,cAAA;AAAA,KAED,eAAA,UACC,wBAAA,UACA,yBAAA,UACA,eAAA,UACA,gCAAA,UACA,6BAAA,UACA,iBAAA,UACA,oBAAA,UACA,aAAA,UACA,cAAA;AAAA,cASA,WAAA,SAAoB,KAAA;EAAA,SACpB,IAAA,EAAM,eAAA;EAAA,SACN,OAAA;EAET,WAAA,CAAY,OAAA,UAAiB,IAAA,EAAM,eAAA,EAAiB,OAAA;AAAA;AAAA,cAS3C,eAAA,SAAwB,SAAA;EAAA,SACxB,IAAA,EAAM,eAAA;EAAA,SACN,OAAA;EAET,WAAA,CAAY,OAAA,UAAiB,IAAA,EAAM,eAAA,EAAiB,OAAA;AAAA;AAAA,cAW3C,uBAAA,SAAgC,WAAA;EACzC,WAAA,CAAY,OAAA;AAAA;AAAA,cAKH,uBAAA,SAAgC,eAAA;EAAA,SAChC,YAAA;EAET,WAAA,CAAY,YAAA;AAAA;AAAA,cAMH,cAAA,SAAuB,eAAA;EAChC,WAAA,CAAY,UAAA;AAAA;AAAA,cAKH,6BAAA,SAAsC,eAAA;EAAA,SACtC,WAAA;EAAA,SACA,aAAA;EAET,WAAA,CAAY,WAAA,UAAqB,aAAA;AAAA;AAAA,cAOxB,2BAAA,SAAoC,eAAA;EAAA,SACpC,QAAA;EAET,WAAA,CAAY,QAAA;AAAA;AAAA,cAMH,gBAAA,SAAyB,eAAA;EAAA,SACzB,UAAA;EAET,WAAA,CAAY,UAAA;AAAA;AAAA,cAMH,kBAAA,SAA2B,eAAA;EAAA,SAC3B,OAAA;EAET,WAAA,CAAY,OAAA;AAAA;AAAA,cAMH,aAAA,SAAsB,WAAA;EAAA,SACtB,eAAA;EAAA,SACA,UAAA;EAET,WAAA,CAAY,eAAA,UAAyB,UAAA;AAAA;AAAA,cAQ5B,cAAA,SAAuB,WAAA;EAAA,SACvB,eAAA;EAAA,SACA,OAAA;EAET,WAAA,CAAY,eAAA,UAAyB,OAAA;AAAA"}

package/dist/errors.d.mts

@@ -1,2 +1,63 @@
-import { _ as ResultTypeError, a as ERR_MATCH_ERR_HANDLER_NOT_RESULT, b as UnwrapOnErrError, c as ERR_UNWRAP_ERR_ON_OK, d as ExpectOkError, f as InvalidResultStateError, g as ResultErrorCode, h as ResultError, i as ERR_INVALID_STATE, l as ERR_UNWRAP_ON_ERR, m as MatchOnOkError, n as ERR_EXPECT_OK, o as ERR_MATCH_ON_OK, p as MatchErrHandlerNotResultError, r as ERR_INVALID_RESULT_STATE, s as ERR_TASK_YIELD_NOT_RESULT, t as ERR_EXPECT_ERR, u as ExpectErrError, v as TaskYieldNotResultError, y as UnwrapErrOnOkError } from "./errors-C5qGMRiU.mjs";
-export { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, ResultError, ResultErrorCode, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError };
+//#region src/errors.d.ts
+declare const ERR_INVALID_RESULT_STATE: "ERR_INVALID_RESULT_STATE";
+/** @deprecated Use {@link ERR_INVALID_RESULT_STATE} instead. */
+declare const ERR_INVALID_STATE: typeof ERR_INVALID_RESULT_STATE;
+declare const ERR_TASK_YIELD_NOT_RESULT: "ERR_TASK_YIELD_NOT_RESULT";
+declare const ERR_MATCH_ON_OK: "ERR_MATCH_ON_OK";
+declare const ERR_MATCH_ERR_HANDLER_NOT_RESULT: "ERR_MATCH_ERR_HANDLER_NOT_RESULT";
+declare const ERR_MATCH_TAG_MISSING_HANDLER: "ERR_MATCH_TAG_MISSING_HANDLER";
+declare const ERR_UNWRAP_ON_ERR: "ERR_UNWRAP_ON_ERR";
+declare const ERR_UNWRAP_ERR_ON_OK: "ERR_UNWRAP_ERR_ON_OK";
+declare const ERR_EXPECT_OK: "ERR_EXPECT_OK";
+declare const ERR_EXPECT_ERR: "ERR_EXPECT_ERR";
+type ResultErrorCode = typeof ERR_INVALID_RESULT_STATE | typeof ERR_TASK_YIELD_NOT_RESULT | typeof ERR_MATCH_ON_OK | typeof ERR_MATCH_ERR_HANDLER_NOT_RESULT | typeof ERR_MATCH_TAG_MISSING_HANDLER | typeof ERR_UNWRAP_ON_ERR | typeof ERR_UNWRAP_ERR_ON_OK | typeof ERR_EXPECT_OK | typeof ERR_EXPECT_ERR;
+declare class ResultError extends Error {
+  readonly code: ResultErrorCode;
+  readonly context?: string;
+  constructor(message: string, code: ResultErrorCode, context?: string);
+}
+declare class ResultTypeError extends TypeError {
+  readonly code: ResultErrorCode;
+  readonly context?: string;
+  constructor(message: string, code: ResultErrorCode, context?: string);
+}
+declare class InvalidResultStateError extends ResultError {
+  constructor(context?: string);
+}
+declare class TaskYieldNotResultError extends ResultTypeError {
+  readonly yieldedValue: unknown;
+  constructor(yieldedValue: unknown);
+}
+declare class MatchOnOkError extends ResultTypeError {
+  constructor(methodName?: string);
+}
+declare class MatchErrHandlerNotResultError extends ResultTypeError {
+  readonly handlerName: string;
+  readonly returnedValue: unknown;
+  constructor(handlerName: string, returnedValue: unknown);
+}
+declare class MatchTagMissingHandlerError extends ResultTypeError {
+  readonly tagValue: unknown;
+  constructor(tagValue: unknown);
+}
+declare class UnwrapOnErrError extends ResultTypeError {
+  readonly errorValue: unknown;
+  constructor(errorValue: unknown);
+}
+declare class UnwrapErrOnOkError extends ResultTypeError {
+  readonly okValue: unknown;
+  constructor(okValue: unknown);
+}
+declare class ExpectOkError extends ResultError {
+  readonly expectedMessage: string;
+  readonly errorValue: unknown;
+  constructor(expectedMessage: string, errorValue?: unknown);
+}
+declare class ExpectErrError extends ResultError {
+  readonly expectedMessage: string;
+  readonly okValue: unknown;
+  constructor(expectedMessage: string, okValue?: unknown);
+}
+//#endregion
+export { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_MATCH_TAG_MISSING_HANDLER, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, MatchTagMissingHandlerError, ResultError, ResultErrorCode, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError };
+//# sourceMappingURL=errors.d.mts.map

package/dist/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";cAAa,wBAAA;AAAb;AAAA,cAEa,iBAAA,SAA0B,wBAAA;AAAA,cAC1B,yBAAA;AAAA,cACA,eAAA;AAAA,cACA,gCAAA;AAAA,cACA,6BAAA;AAAA,cACA,iBAAA;AAAA,cACA,oBAAA;AAAA,cACA,aAAA;AAAA,cACA,cAAA;AAAA,KAED,eAAA,UACC,wBAAA,UACA,yBAAA,UACA,eAAA,UACA,gCAAA,UACA,6BAAA,UACA,iBAAA,UACA,oBAAA,UACA,aAAA,UACA,cAAA;AAAA,cASA,WAAA,SAAoB,KAAA;EAAA,SACpB,IAAA,EAAM,eAAA;EAAA,SACN,OAAA;EAET,WAAA,CAAY,OAAA,UAAiB,IAAA,EAAM,eAAA,EAAiB,OAAA;AAAA;AAAA,cAS3C,eAAA,SAAwB,SAAA;EAAA,SACxB,IAAA,EAAM,eAAA;EAAA,SACN,OAAA;EAET,WAAA,CAAY,OAAA,UAAiB,IAAA,EAAM,eAAA,EAAiB,OAAA;AAAA;AAAA,cAW3C,uBAAA,SAAgC,WAAA;EACzC,WAAA,CAAY,OAAA;AAAA;AAAA,cAKH,uBAAA,SAAgC,eAAA;EAAA,SAChC,YAAA;EAET,WAAA,CAAY,YAAA;AAAA;AAAA,cAMH,cAAA,SAAuB,eAAA;EAChC,WAAA,CAAY,UAAA;AAAA;AAAA,cAKH,6BAAA,SAAsC,eAAA;EAAA,SACtC,WAAA;EAAA,SACA,aAAA;EAET,WAAA,CAAY,WAAA,UAAqB,aAAA;AAAA;AAAA,cAOxB,2BAAA,SAAoC,eAAA;EAAA,SACpC,QAAA;EAET,WAAA,CAAY,QAAA;AAAA;AAAA,cAMH,gBAAA,SAAyB,eAAA;EAAA,SACzB,UAAA;EAET,WAAA,CAAY,UAAA;AAAA;AAAA,cAMH,kBAAA,SAA2B,eAAA;EAAA,SAC3B,OAAA;EAET,WAAA,CAAY,OAAA;AAAA;AAAA,cAMH,aAAA,SAAsB,WAAA;EAAA,SACtB,eAAA;EAAA,SACA,UAAA;EAET,WAAA,CAAY,eAAA,UAAyB,UAAA;AAAA;AAAA,cAQ5B,cAAA,SAAuB,WAAA;EAAA,SACvB,eAAA;EAAA,SACA,OAAA;EAET,WAAA,CAAY,eAAA,UAAyB,OAAA;AAAA"}

package/dist/errors.mjs

@@ -1,3 +1,110 @@
-import { _ as TaskYieldNotResultError, a as ERR_MATCH_ERR_HANDLER_NOT_RESULT, c as ERR_UNWRAP_ERR_ON_OK, d as ExpectOkError, f as InvalidResultStateError, g as ResultTypeError, h as ResultError, i as ERR_INVALID_STATE, l as ERR_UNWRAP_ON_ERR, m as MatchOnOkError, n as ERR_EXPECT_OK, o as ERR_MATCH_ON_OK, p as MatchErrHandlerNotResultError, r as ERR_INVALID_RESULT_STATE, s as ERR_TASK_YIELD_NOT_RESULT, t as ERR_EXPECT_ERR, u as ExpectErrError, v as UnwrapErrOnOkError, y as UnwrapOnErrError } from "./errors-2WOswg7r.mjs";
+//#region src/errors.ts
+const ERR_INVALID_RESULT_STATE = "ERR_INVALID_RESULT_STATE";
+/** @deprecated Use {@link ERR_INVALID_RESULT_STATE} instead. */
+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_MATCH_TAG_MISSING_HANDLER = "ERR_MATCH_TAG_MISSING_HANDLER";
+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 MatchTagMissingHandlerError = class extends ResultTypeError {
+	tagValue;
+	constructor(tagValue) {
+		super(`matchTag() has no handler for tag "${String(tagValue)}".`, ERR_MATCH_TAG_MISSING_HANDLER);
+		this.tagValue = tagValue;
+	}
+};
+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;
+	errorValue;
+	constructor(expectedMessage, errorValue) {
+		super(errorValue === void 0 ? expectedMessage : `${expectedMessage}: ${String(errorValue)}`, ERR_EXPECT_OK);
+		this.expectedMessage = expectedMessage;
+		this.errorValue = errorValue;
+		if (errorValue !== void 0) this.cause = errorValue;
+	}
+};
+var ExpectErrError = class extends ResultError {
+	expectedMessage;
+	okValue;
+	constructor(expectedMessage, okValue) {
+		super(okValue === void 0 ? expectedMessage : `${expectedMessage}: ${String(okValue)}`, ERR_EXPECT_ERR);
+		this.expectedMessage = expectedMessage;
+		this.okValue = okValue;
+		if (okValue !== void 0) this.cause = okValue;
+	}
+};
 
-export { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, ResultError, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError };
+//#endregion
+export { ERR_EXPECT_ERR, ERR_EXPECT_OK, ERR_INVALID_RESULT_STATE, ERR_INVALID_STATE, ERR_MATCH_ERR_HANDLER_NOT_RESULT, ERR_MATCH_ON_OK, ERR_MATCH_TAG_MISSING_HANDLER, ERR_TASK_YIELD_NOT_RESULT, ERR_UNWRAP_ERR_ON_OK, ERR_UNWRAP_ON_ERR, ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, MatchTagMissingHandlerError, ResultError, ResultTypeError, TaskYieldNotResultError, UnwrapErrOnOkError, UnwrapOnErrError };
+//# sourceMappingURL=errors.mjs.map

package/dist/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["export const ERR_INVALID_RESULT_STATE = 'ERR_INVALID_RESULT_STATE' as const;\n/** @deprecated Use {@link ERR_INVALID_RESULT_STATE} instead. */\nexport const ERR_INVALID_STATE: typeof ERR_INVALID_RESULT_STATE = ERR_INVALID_RESULT_STATE;\nexport const ERR_TASK_YIELD_NOT_RESULT = 'ERR_TASK_YIELD_NOT_RESULT' as const;\nexport const ERR_MATCH_ON_OK = 'ERR_MATCH_ON_OK' as const;\nexport const ERR_MATCH_ERR_HANDLER_NOT_RESULT = 'ERR_MATCH_ERR_HANDLER_NOT_RESULT' as const;\nexport const ERR_MATCH_TAG_MISSING_HANDLER = 'ERR_MATCH_TAG_MISSING_HANDLER' as const;\nexport const ERR_UNWRAP_ON_ERR = 'ERR_UNWRAP_ON_ERR' as const;\nexport const ERR_UNWRAP_ERR_ON_OK = 'ERR_UNWRAP_ERR_ON_OK' as const;\nexport const ERR_EXPECT_OK = 'ERR_EXPECT_OK' as const;\nexport const ERR_EXPECT_ERR = 'ERR_EXPECT_ERR' as const;\n\nexport type ResultErrorCode =\n    | typeof ERR_INVALID_RESULT_STATE\n    | typeof ERR_TASK_YIELD_NOT_RESULT\n    | typeof ERR_MATCH_ON_OK\n    | typeof ERR_MATCH_ERR_HANDLER_NOT_RESULT\n    | typeof ERR_MATCH_TAG_MISSING_HANDLER\n    | typeof ERR_UNWRAP_ON_ERR\n    | typeof ERR_UNWRAP_ERR_ON_OK\n    | typeof ERR_EXPECT_OK\n    | typeof ERR_EXPECT_ERR;\n\nconst formatResultErrorMessage = (code: ResultErrorCode, message: string, context?: string): string => {\n    if (context) {\n        return `${code}: ${message} (context: ${context})`;\n    }\n    return `${code}: ${message}`;\n};\n\nexport class ResultError extends Error {\n    readonly code: ResultErrorCode;\n    readonly context?: string;\n\n    constructor(message: string, code: ResultErrorCode, context?: string) {\n        super(formatResultErrorMessage(code, message, context));\n        this.code = code;\n        this.context = context;\n        this.name = new.target.name;\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\nexport class ResultTypeError extends TypeError {\n    readonly code: ResultErrorCode;\n    readonly context?: string;\n\n    constructor(message: string, code: ResultErrorCode, context?: string) {\n        super(formatResultErrorMessage(code, message, context));\n        this.code = code;\n        this.context = context;\n        this.name = new.target.name;\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n}\n\nconst INVALID_RESULT_STATE_MESSAGE = 'Unreachable: Result is neither Ok nor Err';\n\nexport class InvalidResultStateError extends ResultError {\n    constructor(context?: string) {\n        super(INVALID_RESULT_STATE_MESSAGE, ERR_INVALID_RESULT_STATE, context);\n    }\n}\n\nexport class TaskYieldNotResultError extends ResultTypeError {\n    readonly yieldedValue: unknown;\n\n    constructor(yieldedValue: unknown) {\n        super('task() expected yielded values to be Result. Use `yield*` on a Result.', ERR_TASK_YIELD_NOT_RESULT);\n        this.yieldedValue = yieldedValue;\n    }\n}\n\nexport class MatchOnOkError extends ResultTypeError {\n    constructor(methodName = 'match') {\n        super(`${methodName}() can only be called on Err results. Use \\`if (result.isErr()) { ... }\\` first.`, ERR_MATCH_ON_OK);\n    }\n}\n\nexport class MatchErrHandlerNotResultError extends ResultTypeError {\n    readonly handlerName: string;\n    readonly returnedValue: unknown;\n\n    constructor(handlerName: string, returnedValue: unknown) {\n        super(`matchErr().${handlerName}() handlers must return a Result. Wrap values with ok(...) or err(...).`, ERR_MATCH_ERR_HANDLER_NOT_RESULT);\n        this.handlerName = handlerName;\n        this.returnedValue = returnedValue;\n    }\n}\n\nexport class MatchTagMissingHandlerError extends ResultTypeError {\n    readonly tagValue: unknown;\n\n    constructor(tagValue: unknown) {\n        super(`matchTag() has no handler for tag \"${String(tagValue)}\".`, ERR_MATCH_TAG_MISSING_HANDLER);\n        this.tagValue = tagValue;\n    }\n}\n\nexport class UnwrapOnErrError extends ResultTypeError {\n    readonly errorValue: unknown;\n\n    constructor(errorValue: unknown) {\n        super(`Called unwrap() on Err: ${String(errorValue)}`, ERR_UNWRAP_ON_ERR);\n        this.errorValue = errorValue;\n    }\n}\n\nexport class UnwrapErrOnOkError extends ResultTypeError {\n    readonly okValue: unknown;\n\n    constructor(okValue: unknown) {\n        super(`Called unwrapErr() on Ok: ${String(okValue)}`, ERR_UNWRAP_ERR_ON_OK);\n        this.okValue = okValue;\n    }\n}\n\nexport class ExpectOkError extends ResultError {\n    readonly expectedMessage: string;\n    readonly errorValue: unknown;\n\n    constructor(expectedMessage: string, errorValue?: unknown) {\n        super(errorValue === undefined ? expectedMessage : `${expectedMessage}: ${String(errorValue)}`, ERR_EXPECT_OK);\n        this.expectedMessage = expectedMessage;\n        this.errorValue = errorValue;\n        if (errorValue !== undefined) this.cause = errorValue;\n    }\n}\n\nexport class ExpectErrError extends ResultError {\n    readonly expectedMessage: string;\n    readonly okValue: unknown;\n\n    constructor(expectedMessage: string, okValue?: unknown) {\n        super(okValue === undefined ? expectedMessage : `${expectedMessage}: ${String(okValue)}`, ERR_EXPECT_ERR);\n        this.expectedMessage = expectedMessage;\n        this.okValue = okValue;\n        if (okValue !== undefined) this.cause = okValue;\n    }\n}\n"],"mappings":";AAAA,MAAa,2BAA2B;;AAExC,MAAa,oBAAqD;AAClE,MAAa,4BAA4B;AACzC,MAAa,kBAAkB;AAC/B,MAAa,mCAAmC;AAChD,MAAa,gCAAgC;AAC7C,MAAa,oBAAoB;AACjC,MAAa,uBAAuB;AACpC,MAAa,gBAAgB;AAC7B,MAAa,iBAAiB;AAa9B,MAAM,4BAA4B,MAAuB,SAAiB,YAA6B;CACnG,IAAI,SACA,OAAO,GAAG,KAAK,IAAI,QAAQ,aAAa,QAAQ;CAEpD,OAAO,GAAG,KAAK,IAAI;AACvB;AAEA,IAAa,cAAb,cAAiC,MAAM;CACnC,AAAS;CACT,AAAS;CAET,YAAY,SAAiB,MAAuB,SAAkB;EAClE,MAAM,yBAAyB,MAAM,SAAS,OAAO,CAAC;EACtD,KAAK,OAAO;EACZ,KAAK,UAAU;EACf,KAAK,OAAO,IAAI,OAAO;EACvB,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;CACpD;AACJ;AAEA,IAAa,kBAAb,cAAqC,UAAU;CAC3C,AAAS;CACT,AAAS;CAET,YAAY,SAAiB,MAAuB,SAAkB;EAClE,MAAM,yBAAyB,MAAM,SAAS,OAAO,CAAC;EACtD,KAAK,OAAO;EACZ,KAAK,UAAU;EACf,KAAK,OAAO,IAAI,OAAO;EACvB,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;CACpD;AACJ;AAEA,MAAM,+BAA+B;AAErC,IAAa,0BAAb,cAA6C,YAAY;CACrD,YAAY,SAAkB;EAC1B,MAAM,8BAA8B,0BAA0B,OAAO;CACzE;AACJ;AAEA,IAAa,0BAAb,cAA6C,gBAAgB;CACzD,AAAS;CAET,YAAY,cAAuB;EAC/B,MAAM,0EAA0E,yBAAyB;EACzG,KAAK,eAAe;CACxB;AACJ;AAEA,IAAa,iBAAb,cAAoC,gBAAgB;CAChD,YAAY,aAAa,SAAS;EAC9B,MAAM,GAAG,WAAW,mFAAmF,eAAe;CAC1H;AACJ;AAEA,IAAa,gCAAb,cAAmD,gBAAgB;CAC/D,AAAS;CACT,AAAS;CAET,YAAY,aAAqB,eAAwB;EACrD,MAAM,cAAc,YAAY,0EAA0E,gCAAgC;EAC1I,KAAK,cAAc;EACnB,KAAK,gBAAgB;CACzB;AACJ;AAEA,IAAa,8BAAb,cAAiD,gBAAgB;CAC7D,AAAS;CAET,YAAY,UAAmB;EAC3B,MAAM,sCAAsC,OAAO,QAAQ,EAAE,KAAK,6BAA6B;EAC/F,KAAK,WAAW;CACpB;AACJ;AAEA,IAAa,mBAAb,cAAsC,gBAAgB;CAClD,AAAS;CAET,YAAY,YAAqB;EAC7B,MAAM,2BAA2B,OAAO,UAAU,KAAK,iBAAiB;EACxE,KAAK,aAAa;CACtB;AACJ;AAEA,IAAa,qBAAb,cAAwC,gBAAgB;CACpD,AAAS;CAET,YAAY,SAAkB;EAC1B,MAAM,6BAA6B,OAAO,OAAO,KAAK,oBAAoB;EAC1E,KAAK,UAAU;CACnB;AACJ;AAEA,IAAa,gBAAb,cAAmC,YAAY;CAC3C,AAAS;CACT,AAAS;CAET,YAAY,iBAAyB,YAAsB;EACvD,MAAM,eAAe,SAAY,kBAAkB,GAAG,gBAAgB,IAAI,OAAO,UAAU,KAAK,aAAa;EAC7G,KAAK,kBAAkB;EACvB,KAAK,aAAa;EAClB,IAAI,eAAe,QAAW,KAAK,QAAQ;CAC/C;AACJ;AAEA,IAAa,iBAAb,cAAoC,YAAY;CAC5C,AAAS;CACT,AAAS;CAET,YAAY,iBAAyB,SAAmB;EACpD,MAAM,YAAY,SAAY,kBAAkB,GAAG,gBAAgB,IAAI,OAAO,OAAO,KAAK,cAAc;EACxG,KAAK,kBAAkB;EACvB,KAAK,UAAU;EACf,IAAI,YAAY,QAAW,KAAK,QAAQ;CAC5C;AACJ"}

package/dist/{flatten-Df9U40nO.cjs → flatten-B_XIkaOK.cjs}

@@ -1,5 +1,5 @@
-const require_result = require('./result-CY-KIivk.cjs');
-const require_errors = require('./errors-D2EMzJQl.cjs');
+const require_result = require('./result-BBOGxvSH.cjs');
+const require_errors = require('./errors.cjs');
 
 //#region src/core/sequenceRecord.ts
 /**
@@ -21,6 +21,26 @@ function sequenceRecord(record) {
 	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
 /**
@@ -149,6 +169,12 @@ Object.defineProperty(exports, 'collectAllErrors', {
     return collectAllErrors;
   }
 });
+Object.defineProperty(exports, 'collectFirstOk', {
+  enumerable: true,
+  get: function () {
+    return collectFirstOk;
+  }
+});
 Object.defineProperty(exports, 'collectFirstOkAsync', {
   enumerable: true,
   get: function () {
@@ -179,4 +205,4 @@ Object.defineProperty(exports, 'sequenceRecord', {
     return sequenceRecord;
   }
 });
-//# sourceMappingURL=flatten-Df9U40nO.cjs.map
+//# sourceMappingURL=flatten-B_XIkaOK.cjs.map

package/dist/flatten-B_XIkaOK.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten-B_XIkaOK.cjs","names":["isResult","InvalidResultStateError","ok","ok","InvalidResultStateError","err","ok","InvalidResultStateError","err","err","ok","InvalidResultStateError","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 */\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    const out: Partial<Out> = {};\n\n    for (const key of Reflect.ownKeys(record) as Array<keyof R>) {\n        const result = record[key];\n        if (!isResult(result)) throw new InvalidResultStateError('sequenceRecord');\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 { 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 * - Processes inputs strictly sequentially (like `for ... of` + `await`).\n * - Returns the first `Ok` and collects all errors if no `Ok` is found.\n */\nexport async function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(\n    inputs: Inputs\n): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>> {\n    const errors: Array<ErrValueOfInput<Inputs[number]>> = [];\n\n    for (const input of inputs) {\n        const pendingResult = typeof input === 'function' ? input() : input;\n        let result: Result<any, any>;\n        try {\n            result = await pendingResult;\n        } catch (error) {\n            errors.push(error as ErrValueOfInput<Inputs[number]>);\n            continue;\n        }\n\n        if (result.isOk()) {\n            return ok<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>(\n                result.value as OkValueOfInput<Inputs[number]>\n            );\n        }\n        if (result.isErr()) {\n            errors.push(result.error as ErrValueOfInput<Inputs[number]>);\n            continue;\n        }\n        throw new InvalidResultStateError('collectFirstOkAsync');\n    }\n\n    return err<ErrValueOfInput<Inputs[number]>[], OkValueOfInput<Inputs[number]>>(errors);\n}\n","import type { Awaitable } from './pipeable';\nimport type { Result } from './result';\nimport { err, ok } from './result';\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).\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 * - Rejections are treated as `ErrValue` (`caught as ErrValue`).\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 async function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(\n    inputs: Inputs\n): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>> {\n    type OkValue = OkValueOfInput<Inputs[number]>;\n    type ErrValue = ErrValueOfInput<Inputs[number]>;\n\n    if (inputs.length === 0) {\n        return err<ErrValue[], OkValue>([]);\n    }\n\n    const started = inputs.map((input) =>\n        typeof input === 'function' ? Promise.resolve().then(input) : input\n    );\n\n    const firstOk = new Promise<Result<OkValue, ErrValue[]>>((resolve) => {\n        for (const promise of started) {\n            promise\n                .then((result) => {\n                    if (result.isOk()) {\n                        resolve(ok<OkValue, ErrValue[]>(result.value as OkValue));\n                    }\n                })\n                .catch(() => {\n                    // Ignored here; handled in allSettled below.\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 === 'fulfilled') {\n                const result = entry.value;\n                if (result.isErr()) {\n                    errors.push(result.error as ErrValue);\n                } else if (!result.isOk()) {\n                    throw new InvalidResultStateError('collectFirstOkParallelAsync');\n                }\n            } else {\n                errors.push(entry.reason as ErrValue);\n            }\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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"}