@shirudo/result 0.0.5 → 1.0.0

package/dist/errors-2WOswg7r.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-2WOswg7r.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["export const ERR_INVALID_RESULT_STATE = 'ERR_INVALID_RESULT_STATE' as const;\nexport const ERR_INVALID_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_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_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 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\n    constructor(expectedMessage: string) {\n        super(expectedMessage, ERR_EXPECT_OK);\n        this.expectedMessage = expectedMessage;\n    }\n}\n\nexport class ExpectErrError extends ResultError {\n    readonly expectedMessage: string;\n\n    constructor(expectedMessage: string) {\n        super(expectedMessage, ERR_EXPECT_ERR);\n        this.expectedMessage = expectedMessage;\n    }\n}\n"],"mappings":";AAAA,MAAa,2BAA2B;AACxC,MAAa,oBAAoB;AACjC,MAAa,4BAA4B;AACzC,MAAa,kBAAkB;AAC/B,MAAa,mCAAmC;AAChD,MAAa,oBAAoB;AACjC,MAAa,uBAAuB;AACpC,MAAa,gBAAgB;AAC7B,MAAa,iBAAiB;AAY9B,MAAM,4BAA4B,MAAuB,SAAiB,YAA6B;AACnG,KAAI,QACA,QAAO,GAAG,KAAK,IAAI,QAAQ,aAAa,QAAQ;AAEpD,QAAO,GAAG,KAAK,IAAI;;AAGvB,IAAa,cAAb,cAAiC,MAAM;CACnC,AAAS;CACT,AAAS;CAET,YAAY,SAAiB,MAAuB,SAAkB;AAClE,QAAM,yBAAyB,MAAM,SAAS,QAAQ,CAAC;AACvD,OAAK,OAAO;AACZ,OAAK,UAAU;AACf,OAAK,OAAO,IAAI,OAAO;AACvB,SAAO,eAAe,MAAM,IAAI,OAAO,UAAU;;;AAIzD,IAAa,kBAAb,cAAqC,UAAU;CAC3C,AAAS;CACT,AAAS;CAET,YAAY,SAAiB,MAAuB,SAAkB;AAClE,QAAM,yBAAyB,MAAM,SAAS,QAAQ,CAAC;AACvD,OAAK,OAAO;AACZ,OAAK,UAAU;AACf,OAAK,OAAO,IAAI,OAAO;AACvB,SAAO,eAAe,MAAM,IAAI,OAAO,UAAU;;;AAIzD,MAAM,+BAA+B;AAErC,IAAa,0BAAb,cAA6C,YAAY;CACrD,YAAY,SAAkB;AAC1B,QAAM,8BAA8B,0BAA0B,QAAQ;;;AAI9E,IAAa,0BAAb,cAA6C,gBAAgB;CACzD,AAAS;CAET,YAAY,cAAuB;AAC/B,QAAM,0EAA0E,0BAA0B;AAC1G,OAAK,eAAe;;;AAI5B,IAAa,iBAAb,cAAoC,gBAAgB;CAChD,YAAY,aAAa,SAAS;AAC9B,QAAM,GAAG,WAAW,mFAAmF,gBAAgB;;;AAI/H,IAAa,gCAAb,cAAmD,gBAAgB;CAC/D,AAAS;CACT,AAAS;CAET,YAAY,aAAqB,eAAwB;AACrD,QAAM,cAAc,YAAY,0EAA0E,iCAAiC;AAC3I,OAAK,cAAc;AACnB,OAAK,gBAAgB;;;AAI7B,IAAa,mBAAb,cAAsC,gBAAgB;CAClD,AAAS;CAET,YAAY,YAAqB;AAC7B,QAAM,2BAA2B,OAAO,WAAW,IAAI,kBAAkB;AACzE,OAAK,aAAa;;;AAI1B,IAAa,qBAAb,cAAwC,gBAAgB;CACpD,AAAS;CAET,YAAY,SAAkB;AAC1B,QAAM,6BAA6B,OAAO,QAAQ,IAAI,qBAAqB;AAC3E,OAAK,UAAU;;;AAIvB,IAAa,gBAAb,cAAmC,YAAY;CAC3C,AAAS;CAET,YAAY,iBAAyB;AACjC,QAAM,iBAAiB,cAAc;AACrC,OAAK,kBAAkB;;;AAI/B,IAAa,iBAAb,cAAoC,YAAY;CAC5C,AAAS;CAET,YAAY,iBAAyB;AACjC,QAAM,iBAAiB,eAAe;AACtC,OAAK,kBAAkB"}

package/dist/errors-BFjY06EV.d.cts

@@ -0,0 +1,55 @@
+//#region src/errors.d.ts
+declare const ERR_INVALID_RESULT_STATE: "ERR_INVALID_RESULT_STATE";
+declare const ERR_INVALID_STATE: "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_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_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 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;
+  constructor(expectedMessage: string);
+}
+declare class ExpectErrError extends ResultError {
+  readonly expectedMessage: string;
+  constructor(expectedMessage: string);
+}
+//#endregion
+export { ResultTypeError as _, ERR_MATCH_ERR_HANDLER_NOT_RESULT as a, UnwrapOnErrError as b, ERR_UNWRAP_ERR_ON_OK as c, ExpectOkError as d, InvalidResultStateError as f, ResultErrorCode 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, TaskYieldNotResultError as v, UnwrapErrOnOkError as y };
+//# sourceMappingURL=errors-BFjY06EV.d.cts.map

package/dist/errors-BFjY06EV.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-BFjY06EV.d.cts","names":[],"sources":["../src/errors.ts"],"sourcesContent":[],"mappings":";cAAa;AAAA,cACA,iBAD8D,EAAA,0BAAA;AAC9D,cACA,yBAD4C,EAAA,2BAAA;AAC5C,cACA,eADgE,EAAA,iBAAA;AAChE,cACA,gCAD4C,EAAA,kCAAA;AAC5C,cACA,iBADA,EAA8E,mBAAA;AAC9E,cACA,oBADgD,EAAA,sBAAA;AAChD,cACA,aADsD,EAAA,eAAA;AACtD,cACA,cADwC,EAAA,gBAAA;AACxC,KAED,eAAA,GAF2C,OAG1C,wBAH0C,GAAA,OAI1C,yBAJ0C,GAAA,OAK1C,eAL0C,GAAA,OAM1C,gCAN0C,GAAA,OAO1C,iBAP0C,GAAA,OAQ1C,oBAR0C,GAAA,OAS1C,aAT0C,GAAA,OAU1C,cAV0C;AAE3C,cAiBC,WAAA,SAAoB,KAAA,CAjBN;EACd,SAAA,IAAA,EAiBM,eAjBN;EACA,SAAA,OAAA,CAAA,EAAA,MAAA;EACA,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,IAAA,EAkB0B,eAlB1B,EAAA,OAAA,CAAA,EAAA,MAAA;;AAEA,cAyBA,eAAA,SAAwB,SAAA,CAzBxB;EACA,SAAA,IAAA,EAyBM,eAzBN;EACA,SAAA,OAAA,CAAA,EAAA,MAAA;EACA,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,IAAA,EA0B0B,eA1B1B,EAAA,OAAA,CAAA,EAAA,MAAA;;AASA,cA4BA,uBAAA,SAAgC,WAAA,CA5BpB;EACN,WAAA,CAAA,OAAA,CAAA,EAAA,MAAA;;AADc,cAkCpB,uBAAA,SAAgC,eAAA,CAlCZ;EAAK,SAAA,YAAA,EAAA,OAAA;EAazB,WAAA,CAAA,YAAgB,EAAA,OAAA;;AAIU,cA0B1B,cAAA,SAAuB,eAAA,CA1BG;EAJF,WAAA,CAAA,UAAA,CAAA,EAAA,MAAA;;AAexB,cAqBA,6BAAA,SAAsC,eAAA,CArBK;EAM3C,SAAA,WAAA,EAAA,MAAwB;EASxB,SAAA,aAAe,EAAA,OAAQ;EAMvB,WAAA,CAAA,WAAA,EAAA,MAAA,EAA8B,aAAQ,EAAA,OAAA;AAWnD;AASa,cATA,gBAAA,SAAyB,eAAA,CASiB;EAS1C,SAAA,UAAc,EAAA,OAAQ;EAStB,WAAA,CAAA,UAAe,EAAA,OAAQ;;cAlBvB,kBAAA,SAA2B,eAAA;;;;cAS3B,aAAA,SAAsB,WAAA;;;;cAStB,cAAA,SAAuB,WAAA"}

package/dist/errors-C5qGMRiU.d.mts

@@ -0,0 +1,55 @@
+//#region src/errors.d.ts
+declare const ERR_INVALID_RESULT_STATE: "ERR_INVALID_RESULT_STATE";
+declare const ERR_INVALID_STATE: "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_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_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 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;
+  constructor(expectedMessage: string);
+}
+declare class ExpectErrError extends ResultError {
+  readonly expectedMessage: string;
+  constructor(expectedMessage: string);
+}
+//#endregion
+export { ResultTypeError as _, ERR_MATCH_ERR_HANDLER_NOT_RESULT as a, UnwrapOnErrError as b, ERR_UNWRAP_ERR_ON_OK as c, ExpectOkError as d, InvalidResultStateError as f, ResultErrorCode 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, TaskYieldNotResultError as v, UnwrapErrOnOkError as y };
+//# sourceMappingURL=errors-C5qGMRiU.d.mts.map

package/dist/errors-C5qGMRiU.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-C5qGMRiU.d.mts","names":[],"sources":["../src/errors.ts"],"sourcesContent":[],"mappings":";cAAa;AAAA,cACA,iBAD8D,EAAA,0BAAA;AAC9D,cACA,yBAD4C,EAAA,2BAAA;AAC5C,cACA,eADgE,EAAA,iBAAA;AAChE,cACA,gCAD4C,EAAA,kCAAA;AAC5C,cACA,iBADA,EAA8E,mBAAA;AAC9E,cACA,oBADgD,EAAA,sBAAA;AAChD,cACA,aADsD,EAAA,eAAA;AACtD,cACA,cADwC,EAAA,gBAAA;AACxC,KAED,eAAA,GAF2C,OAG1C,wBAH0C,GAAA,OAI1C,yBAJ0C,GAAA,OAK1C,eAL0C,GAAA,OAM1C,gCAN0C,GAAA,OAO1C,iBAP0C,GAAA,OAQ1C,oBAR0C,GAAA,OAS1C,aAT0C,GAAA,OAU1C,cAV0C;AAE3C,cAiBC,WAAA,SAAoB,KAAA,CAjBN;EACd,SAAA,IAAA,EAiBM,eAjBN;EACA,SAAA,OAAA,CAAA,EAAA,MAAA;EACA,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,IAAA,EAkB0B,eAlB1B,EAAA,OAAA,CAAA,EAAA,MAAA;;AAEA,cAyBA,eAAA,SAAwB,SAAA,CAzBxB;EACA,SAAA,IAAA,EAyBM,eAzBN;EACA,SAAA,OAAA,CAAA,EAAA,MAAA;EACA,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,IAAA,EA0B0B,eA1B1B,EAAA,OAAA,CAAA,EAAA,MAAA;;AASA,cA4BA,uBAAA,SAAgC,WAAA,CA5BpB;EACN,WAAA,CAAA,OAAA,CAAA,EAAA,MAAA;;AADc,cAkCpB,uBAAA,SAAgC,eAAA,CAlCZ;EAAK,SAAA,YAAA,EAAA,OAAA;EAazB,WAAA,CAAA,YAAgB,EAAA,OAAA;;AAIU,cA0B1B,cAAA,SAAuB,eAAA,CA1BG;EAJF,WAAA,CAAA,UAAA,CAAA,EAAA,MAAA;;AAexB,cAqBA,6BAAA,SAAsC,eAAA,CArBK;EAM3C,SAAA,WAAA,EAAA,MAAwB;EASxB,SAAA,aAAe,EAAA,OAAQ;EAMvB,WAAA,CAAA,WAAA,EAAA,MAAA,EAA8B,aAAQ,EAAA,OAAA;AAWnD;AASa,cATA,gBAAA,SAAyB,eAAA,CASiB;EAS1C,SAAA,UAAc,EAAA,OAAQ;EAStB,WAAA,CAAA,UAAe,EAAA,OAAQ;;cAlBvB,kBAAA,SAA2B,eAAA;;;;cAS3B,aAAA,SAAsB,WAAA;;;;cAStB,cAAA,SAAuB,WAAA"}

package/dist/errors-D2EMzJQl.cjs

@@ -0,0 +1,209 @@
+
+//#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
+Object.defineProperty(exports, 'ERR_EXPECT_ERR', {
+  enumerable: true,
+  get: function () {
+    return ERR_EXPECT_ERR;
+  }
+});
+Object.defineProperty(exports, 'ERR_EXPECT_OK', {
+  enumerable: true,
+  get: function () {
+    return ERR_EXPECT_OK;
+  }
+});
+Object.defineProperty(exports, 'ERR_INVALID_RESULT_STATE', {
+  enumerable: true,
+  get: function () {
+    return ERR_INVALID_RESULT_STATE;
+  }
+});
+Object.defineProperty(exports, 'ERR_INVALID_STATE', {
+  enumerable: true,
+  get: function () {
+    return ERR_INVALID_STATE;
+  }
+});
+Object.defineProperty(exports, 'ERR_MATCH_ERR_HANDLER_NOT_RESULT', {
+  enumerable: true,
+  get: function () {
+    return ERR_MATCH_ERR_HANDLER_NOT_RESULT;
+  }
+});
+Object.defineProperty(exports, 'ERR_MATCH_ON_OK', {
+  enumerable: true,
+  get: function () {
+    return ERR_MATCH_ON_OK;
+  }
+});
+Object.defineProperty(exports, 'ERR_TASK_YIELD_NOT_RESULT', {
+  enumerable: true,
+  get: function () {
+    return ERR_TASK_YIELD_NOT_RESULT;
+  }
+});
+Object.defineProperty(exports, 'ERR_UNWRAP_ERR_ON_OK', {
+  enumerable: true,
+  get: function () {
+    return ERR_UNWRAP_ERR_ON_OK;
+  }
+});
+Object.defineProperty(exports, 'ERR_UNWRAP_ON_ERR', {
+  enumerable: true,
+  get: function () {
+    return ERR_UNWRAP_ON_ERR;
+  }
+});
+Object.defineProperty(exports, 'ExpectErrError', {
+  enumerable: true,
+  get: function () {
+    return ExpectErrError;
+  }
+});
+Object.defineProperty(exports, 'ExpectOkError', {
+  enumerable: true,
+  get: function () {
+    return ExpectOkError;
+  }
+});
+Object.defineProperty(exports, 'InvalidResultStateError', {
+  enumerable: true,
+  get: function () {
+    return InvalidResultStateError;
+  }
+});
+Object.defineProperty(exports, 'MatchErrHandlerNotResultError', {
+  enumerable: true,
+  get: function () {
+    return MatchErrHandlerNotResultError;
+  }
+});
+Object.defineProperty(exports, 'MatchOnOkError', {
+  enumerable: true,
+  get: function () {
+    return MatchOnOkError;
+  }
+});
+Object.defineProperty(exports, 'ResultError', {
+  enumerable: true,
+  get: function () {
+    return ResultError;
+  }
+});
+Object.defineProperty(exports, 'ResultTypeError', {
+  enumerable: true,
+  get: function () {
+    return ResultTypeError;
+  }
+});
+Object.defineProperty(exports, 'TaskYieldNotResultError', {
+  enumerable: true,
+  get: function () {
+    return TaskYieldNotResultError;
+  }
+});
+Object.defineProperty(exports, 'UnwrapErrOnOkError', {
+  enumerable: true,
+  get: function () {
+    return UnwrapErrOnOkError;
+  }
+});
+Object.defineProperty(exports, 'UnwrapOnErrError', {
+  enumerable: true,
+  get: function () {
+    return UnwrapOnErrError;
+  }
+});
+//# sourceMappingURL=errors-D2EMzJQl.cjs.map

package/dist/errors-D2EMzJQl.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-D2EMzJQl.cjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["export const ERR_INVALID_RESULT_STATE = 'ERR_INVALID_RESULT_STATE' as const;\nexport const ERR_INVALID_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_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_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 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\n    constructor(expectedMessage: string) {\n        super(expectedMessage, ERR_EXPECT_OK);\n        this.expectedMessage = expectedMessage;\n    }\n}\n\nexport class ExpectErrError extends ResultError {\n    readonly expectedMessage: string;\n\n    constructor(expectedMessage: string) {\n        super(expectedMessage, ERR_EXPECT_ERR);\n        this.expectedMessage = expectedMessage;\n    }\n}\n"],"mappings":";;AAAA,MAAa,2BAA2B;AACxC,MAAa,oBAAoB;AACjC,MAAa,4BAA4B;AACzC,MAAa,kBAAkB;AAC/B,MAAa,mCAAmC;AAChD,MAAa,oBAAoB;AACjC,MAAa,uBAAuB;AACpC,MAAa,gBAAgB;AAC7B,MAAa,iBAAiB;AAY9B,MAAM,4BAA4B,MAAuB,SAAiB,YAA6B;AACnG,KAAI,QACA,QAAO,GAAG,KAAK,IAAI,QAAQ,aAAa,QAAQ;AAEpD,QAAO,GAAG,KAAK,IAAI;;AAGvB,IAAa,cAAb,cAAiC,MAAM;CACnC,AAAS;CACT,AAAS;CAET,YAAY,SAAiB,MAAuB,SAAkB;AAClE,QAAM,yBAAyB,MAAM,SAAS,QAAQ,CAAC;AACvD,OAAK,OAAO;AACZ,OAAK,UAAU;AACf,OAAK,OAAO,IAAI,OAAO;AACvB,SAAO,eAAe,MAAM,IAAI,OAAO,UAAU;;;AAIzD,IAAa,kBAAb,cAAqC,UAAU;CAC3C,AAAS;CACT,AAAS;CAET,YAAY,SAAiB,MAAuB,SAAkB;AAClE,QAAM,yBAAyB,MAAM,SAAS,QAAQ,CAAC;AACvD,OAAK,OAAO;AACZ,OAAK,UAAU;AACf,OAAK,OAAO,IAAI,OAAO;AACvB,SAAO,eAAe,MAAM,IAAI,OAAO,UAAU;;;AAIzD,MAAM,+BAA+B;AAErC,IAAa,0BAAb,cAA6C,YAAY;CACrD,YAAY,SAAkB;AAC1B,QAAM,8BAA8B,0BAA0B,QAAQ;;;AAI9E,IAAa,0BAAb,cAA6C,gBAAgB;CACzD,AAAS;CAET,YAAY,cAAuB;AAC/B,QAAM,0EAA0E,0BAA0B;AAC1G,OAAK,eAAe;;;AAI5B,IAAa,iBAAb,cAAoC,gBAAgB;CAChD,YAAY,aAAa,SAAS;AAC9B,QAAM,GAAG,WAAW,mFAAmF,gBAAgB;;;AAI/H,IAAa,gCAAb,cAAmD,gBAAgB;CAC/D,AAAS;CACT,AAAS;CAET,YAAY,aAAqB,eAAwB;AACrD,QAAM,cAAc,YAAY,0EAA0E,iCAAiC;AAC3I,OAAK,cAAc;AACnB,OAAK,gBAAgB;;;AAI7B,IAAa,mBAAb,cAAsC,gBAAgB;CAClD,AAAS;CAET,YAAY,YAAqB;AAC7B,QAAM,2BAA2B,OAAO,WAAW,IAAI,kBAAkB;AACzE,OAAK,aAAa;;;AAI1B,IAAa,qBAAb,cAAwC,gBAAgB;CACpD,AAAS;CAET,YAAY,SAAkB;AAC1B,QAAM,6BAA6B,OAAO,QAAQ,IAAI,qBAAqB;AAC3E,OAAK,UAAU;;;AAIvB,IAAa,gBAAb,cAAmC,YAAY;CAC3C,AAAS;CAET,YAAY,iBAAyB;AACjC,QAAM,iBAAiB,cAAc;AACrC,OAAK,kBAAkB;;;AAI/B,IAAa,iBAAb,cAAoC,YAAY;CAC5C,AAAS;CAET,YAAY,iBAAyB;AACjC,QAAM,iBAAiB,eAAe;AACtC,OAAK,kBAAkB"}

package/dist/errors.cjs

@@ -0,0 +1,21 @@
+const require_errors = require('./errors-D2EMzJQl.cjs');
+
+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;

package/dist/errors.d.cts

@@ -0,0 +1,2 @@
+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 };

package/dist/errors.d.mts

@@ -0,0 +1,2 @@
+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 };

package/dist/errors.mjs

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

package/dist/flatten-B8bN6fiI.d.mts

@@ -0,0 +1,71 @@
+import { W as Awaitable, s as Result } from "./sequence-C0jlR3AY.mjs";
+
+//#region src/core/sequenceRecord.d.ts
+type OkValueOf$2<R$1> = R$1 extends Result<infer T, any> ? T : never;
+type ErrValueOf$2<R$1> = R$1 extends Result<any, infer E> ? E : never;
+/**
+ * Like `sequence`, but for Records/Objects.
+ * Short-circuits on the first Err.
+ */
+declare function sequenceRecord<const R$1 extends { readonly [K in keyof R$1]: Result<any, any> }>(record: R$1): Result<{ [K in keyof R$1]: OkValueOf$2<R$1[K]> }, ErrValueOf$2<R$1[keyof R$1]>>;
+//#endregion
+//#region src/core/collectFirstOkAsync.d.ts
+type CollectFirstOkAsyncInput$1 = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);
+type ResolvedResult$1<I> = I extends (() => infer R) ? Awaited<R> : I extends Promise<infer R> ? R : never;
+type OkValueOfInput$1<I> = ResolvedResult$1<I> extends Result<infer T, any> ? T : never;
+type ErrValueOfInput$1<I> = ResolvedResult$1<I> extends Result<any, infer E> ? E : never;
+/**
+ * Async version of collectFirstOk.
+ *
+ * - Takes either already started Promises or "Thunks" (`() => Awaitable<Result<...>>`).
+ * - Processes inputs strictly sequentially (like `for ... of` + `await`).
+ * - Returns the first `Ok` and collects all errors if no `Ok` is found.
+ */
+declare function collectFirstOkAsync<const Inputs extends readonly CollectFirstOkAsyncInput$1[]>(inputs: Inputs): Promise<Result<OkValueOfInput$1<Inputs[number]>, ErrValueOfInput$1<Inputs[number]>[]>>;
+//#endregion
+//#region src/core/collectFirstOkParallelAsync.d.ts
+type CollectFirstOkAsyncInput = Promise<Result<any, any>> | (() => Awaitable<Result<any, any>>);
+type ResolvedResult<I> = I extends (() => infer R) ? Awaited<R> : I extends Promise<infer R> ? R : never;
+type OkValueOfInput<I> = ResolvedResult<I> extends Result<infer T, any> ? T : never;
+type ErrValueOfInput<I> = ResolvedResult<I> extends Result<any, infer E> ? E : never;
+/**
+ * Parallel version of `collectFirstOkAsync`.
+ *
+ * - Starts all inputs immediately (Promises or Thunks).
+ * - Returns the first `Ok` as soon as it is available.
+ * - If no `Ok` is found, returns an `Err` with all error values (in input order).
+ * - Rejections are treated as `ErrValue` (`caught as ErrValue`).
+ * - If multiple inputs provide an `Ok`, the one that completes first wins.
+ *   In case of simultaneous completion, the first observed result wins.
+ * - If no `Ok` arrives and at least one input never settles, the Promise remains pending.
+ */
+declare function collectFirstOkParallelAsync<const Inputs extends readonly CollectFirstOkAsyncInput[]>(inputs: Inputs): Promise<Result<OkValueOfInput<Inputs[number]>, ErrValueOfInput<Inputs[number]>[]>>;
+//#endregion
+//#region src/core/collectAllErrors.d.ts
+type OkValueOf$1<R$1> = R$1 extends Result<infer T, any> ? T : never;
+type ErrValueOf$1<R$1> = R$1 extends Result<any, infer E> ? E : never;
+type CollectionValues<Results extends readonly Result<any, any>[]> = { -readonly [K in keyof Results]: OkValueOf$1<Results[K]> };
+/**
+ * Combines a list of Results.
+ * Return Ok(values) only if all are Ok, otherwise Err([errors]).
+ */
+declare function collectAllErrors<const Results extends readonly Result<any, any>[]>(results: Results): Result<CollectionValues<Results>, Array<ErrValueOf$1<Results[number]>>>;
+//#endregion
+//#region src/core/partition.d.ts
+type OkValueOf<R$1> = R$1 extends Result<infer T, any> ? T : never;
+type ErrValueOf<R$1> = R$1 extends Result<any, infer E> ? E : never;
+/**
+ * Partitions Results into Ok values and Err errors.
+ */
+declare function partition<const Results extends readonly Result<any, any>[]>(results: Results): [oks: Array<OkValueOf<Results[number]>>, errs: Array<ErrValueOf<Results[number]>>];
+//#endregion
+//#region src/core/flatten.d.ts
+/**
+ * Flattens a nested Result.
+ * Result<Result<T, E>, E> → Result<T, E>
+ * Corresponds to Rust `flatten`.
+ */
+declare function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E>;
+//#endregion
+export { collectFirstOkAsync as a, collectFirstOkParallelAsync as i, partition as n, sequenceRecord as o, collectAllErrors as r, flatten as t };
+//# sourceMappingURL=flatten-B8bN6fiI.d.mts.map

package/dist/flatten-B8bN6fiI.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten-B8bN6fiI.d.mts","names":[],"sources":["../src/core/sequenceRecord.ts","../src/core/collectFirstOkAsync.ts","../src/core/collectFirstOkParallelAsync.ts","../src/core/collectAllErrors.ts","../src/core/partition.ts","../src/core/flatten.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/flatten-C6Y9hx79.mjs

@@ -0,0 +1,147 @@
+import { B as isResult, c as ok, i as err } from "./result-DKKaNdOx.mjs";
+import { f as InvalidResultStateError } from "./errors-2WOswg7r.mjs";
+
+//#region src/core/sequenceRecord.ts
+/**
+* Like `sequence`, but for Records/Objects.
+* Short-circuits on the first Err.
+*/
+function sequenceRecord(record) {
+	const out = {};
+	for (const key of Reflect.ownKeys(record)) {
+		const result = record[key];
+		if (!isResult(result)) throw new InvalidResultStateError("sequenceRecord");
+		if (result.isOk()) {
+			out[key] = result.value;
+			continue;
+		}
+		if (result.isErr()) return result;
+		throw new InvalidResultStateError("sequenceRecord");
+	}
+	return ok(out);
+}
+
+//#endregion
+//#region src/core/collectFirstOkAsync.ts
+/**
+* Async version of collectFirstOk.
+*
+* - Takes either already started Promises or "Thunks" (`() => Awaitable<Result<...>>`).
+* - Processes inputs strictly sequentially (like `for ... of` + `await`).
+* - Returns the first `Ok` and collects all errors if no `Ok` is found.
+*/
+async function collectFirstOkAsync(inputs) {
+	const errors = [];
+	for (const input of inputs) {
+		const pendingResult = typeof input === "function" ? input() : input;
+		let result;
+		try {
+			result = await pendingResult;
+		} catch (error) {
+			errors.push(error);
+			continue;
+		}
+		if (result.isOk()) return ok(result.value);
+		if (result.isErr()) {
+			errors.push(result.error);
+			continue;
+		}
+		throw new InvalidResultStateError("collectFirstOkAsync");
+	}
+	return err(errors);
+}
+
+//#endregion
+//#region src/core/collectFirstOkParallelAsync.ts
+/**
+* Parallel version of `collectFirstOkAsync`.
+*
+* - Starts all inputs immediately (Promises or Thunks).
+* - Returns the first `Ok` as soon as it is available.
+* - If no `Ok` is found, returns an `Err` with all error values (in input order).
+* - Rejections are treated as `ErrValue` (`caught as ErrValue`).
+* - If multiple inputs provide an `Ok`, the one that completes first wins.
+*   In case of simultaneous completion, the first observed result wins.
+* - If no `Ok` arrives and at least one input never settles, the Promise remains pending.
+*/
+async function collectFirstOkParallelAsync(inputs) {
+	if (inputs.length === 0) return err([]);
+	const started = inputs.map((input) => typeof input === "function" ? Promise.resolve().then(input) : input);
+	const firstOk = new Promise((resolve) => {
+		for (const promise of started) promise.then((result) => {
+			if (result.isOk()) resolve(ok(result.value));
+		}).catch(() => {});
+	});
+	const allErrors = Promise.allSettled(started).then((settled) => {
+		const errors = [];
+		for (const entry of settled) if (entry.status === "fulfilled") {
+			const result = entry.value;
+			if (result.isErr()) errors.push(result.error);
+			else if (!result.isOk()) throw new InvalidResultStateError("collectFirstOkParallelAsync");
+		} else errors.push(entry.reason);
+		return err(errors);
+	});
+	return Promise.race([firstOk, allErrors]);
+}
+
+//#endregion
+//#region src/core/collectAllErrors.ts
+/**
+* Combines a list of Results.
+* Return Ok(values) only if all are Ok, otherwise Err([errors]).
+*/
+function collectAllErrors(results) {
+	const values = [];
+	const errors = [];
+	for (const result of results) {
+		if (result.isOk()) {
+			values.push(result.value);
+			continue;
+		}
+		if (result.isErr()) {
+			errors.push(result.error);
+			continue;
+		}
+		throw new InvalidResultStateError("collectAllErrors");
+	}
+	return errors.length === 0 ? ok(values) : err(errors);
+}
+
+//#endregion
+//#region src/core/partition.ts
+/**
+* Partitions Results into Ok values and Err errors.
+*/
+function partition(results) {
+	const oks = [];
+	const errs = [];
+	for (const result of results) {
+		if (result.isOk()) {
+			oks.push(result.value);
+			continue;
+		}
+		if (result.isErr()) {
+			errs.push(result.error);
+			continue;
+		}
+		throw new InvalidResultStateError("partition");
+	}
+	return [oks, errs];
+}
+
+//#endregion
+//#region src/core/flatten.ts
+/**
+* Flattens a nested Result.
+* Result<Result<T, E>, E> → Result<T, E>
+* Corresponds to Rust `flatten`.
+*/
+function flatten(result) {
+	if (result.isOk()) return result.value;
+	if (result.isErr()) return result;
+	throw new InvalidResultStateError("flatten");
+}
+
+//#endregion
+export { collectFirstOkAsync as a, collectFirstOkParallelAsync as i, partition as n, sequenceRecord as o, collectAllErrors as r, flatten as t };
+//# sourceMappingURL=flatten-C6Y9hx79.mjs.map

package/dist/flatten-C6Y9hx79.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten-C6Y9hx79.mjs","names":["out: Partial<Out>","errors: Array<ErrValueOfInput<Inputs[number]>>","result: Result<any, any>","errors: ErrValue[]","values: Array<OkValueOf<Results[number]>>","errors: Array<ErrValueOf<Results[number]>>","oks: Array<OkValueOf<Results[number]>>","errs: Array<ErrValueOf<Results[number]>>"],"sources":["../src/core/sequenceRecord.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 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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"}