@semyonf/kamchazky 0.3.0 → 1.1.0

package/README.md

@@ -48,25 +48,15 @@ Union of `OkResult<T> | ErrResult<E>`.
 type OkResult<T> = {
   readonly ok: true;
   readonly value: T;
-  map<U>(fn: (value: T) => U): OkResult<U>;
-  flatMap<U, F extends Error = never>(fn: (value: T) => Result<U, F>): Result<U, F>;
-  mapError<F extends Error>(fn: (error: never) => F): OkResult<T>;
-  inspect(fn: (value: T) => void): OkResult<T>;
-  inspectError(fn: (error: never) => void): OkResult<T>;
 };
 ```
 
 #### `ErrResult<E extends Error>`
 
 ```typescript
-type ErrResult<E extends Error = Error> = {
+type ErrResult<E extends Error> = {
   readonly ok: false;
   readonly error: E;
-  map<U>(fn: (value: never) => U): ErrResult<E>;
-  flatMap<U, F extends Error = never>(fn: (value: never) => Result<U, F>): ErrResult<E>;
-  mapError<F extends Error>(fn: (error: E) => F): ErrResult<F>;
-  inspect(fn: (value: never) => void): ErrResult<E>;
-  inspectError(fn: (error: E) => void): ErrResult<E>;
 };
 ```
 
@@ -136,23 +126,11 @@ Result.inspect(result, (value) => console.log("got", value));
 Result.inspectError(result, (error) => console.error(error));
 ```
 
-All transformations are also available as instance methods for chaining:
-
-```typescript
-ok(10)
-  .inspect((x) => console.log("start:", x))
-  .map((x) => x + 5)
-  .flatMap((x) => x > 10 ? ok(x) : err(new Error("too small")))
-  .mapError((e) => new AppError(e.message))
-  .inspectError((e) => console.error(e));
-```
-
 #### Extracting values
 
 ```typescript
 Result.unwrap(result);              // returns value or throws error
 Result.unwrapOr(result, fallback);  // returns value or fallback (same type)
-Result.expect(result, "msg");       // returns value or throws with message
 ```
 
 `unwrapOr` requires the fallback to be the same type `T` as the success value. Use `match` when you need a different return type.
@@ -212,10 +190,6 @@ Union of `Some<T> | None`.
 type Some<T> = {
   readonly some: true;
   readonly value: T;
-  map<U>(fn: (value: T) => U): Some<U>;
-  flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U>;
-  filter(predicate: (value: T) => boolean): Maybe<T>;
-  inspect(fn: (value: T) => void): Some<T>;
 };
 ```
 
@@ -224,10 +198,6 @@ type Some<T> = {
 ```typescript
 type None = {
   readonly some: false;
-  map<U>(fn: (value: never) => U): None;
-  flatMap<U>(fn: (value: never) => Maybe<U>): None;
-  filter(predicate: (value: never) => boolean): None;
-  inspect(fn: (value: never) => void): None;
 };
 ```
 
@@ -271,22 +241,11 @@ Maybe.filter(maybe, (x) => x > 0);
 Maybe.inspect(maybe, (value) => console.log("got", value));
 ```
 
-All transformations are also available as instance methods for chaining:
-
-```typescript
-some(10)
-  .inspect((x) => console.log("start:", x))
-  .map((x) => x + 5)
-  .flatMap((x) => x > 10 ? some(x) : none())
-  .filter((x) => x < 100);
-```
-
 #### Extracting values
 
 ```typescript
 Maybe.unwrap(maybe);              // returns value or throws
 Maybe.unwrapOr(maybe, fallback);  // returns value or fallback (same type)
-Maybe.expect(maybe, "msg");       // returns value or throws with message
 ```
 
 #### Pattern matching
@@ -321,13 +280,13 @@ Convert between `Result` and `Maybe`:
 Result.toMaybe(ok(42));            // some(42)
 Result.toMaybe(err(new Error())); // none()
 
-// Maybe → Result (requires an error for the None case)
-Result.fromMaybe(some(42), new Error("missing")); // ok(42)
-Result.fromMaybe(none(), new Error("missing"));   // err(Error("missing"))
+// Maybe → Result (requires an error factory for the None case)
+Result.fromMaybe(some(42), () => new Error("missing")); // ok(42)
+Result.fromMaybe(none(), () => new Error("missing"));   // err(Error("missing"))
 
 // Same operations from the Maybe side
-Maybe.fromResult(ok(42));                          // some(42)
-Maybe.toResult(some(42), new Error("missing"));    // ok(42)
+Maybe.fromResult(ok(42));                                  // some(42)
+Maybe.toResult(some(42), () => new Error("missing"));     // ok(42)
 ```
 
 ---

package/dist/eslint.cjs

@@ -0,0 +1,92 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/eslint.ts
+var eslint_exports = {};
+__export(eslint_exports, {
+  default: () => eslint_default,
+  mustUseResult: () => mustUseResult
+});
+module.exports = __toCommonJS(eslint_exports);
+var import_utils = require("@typescript-eslint/utils");
+var ts = __toESM(require("typescript"), 1);
+var createRule = import_utils.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/semyonf/kamchazky#${name}`
+);
+function isResultMember(type, checker) {
+  const ok = type.getProperty("ok");
+  if (!ok)
+    return false;
+  const okType = checker.getTypeOfSymbol(ok);
+  const isBooleanDiscriminant = (okType.flags & (ts.TypeFlags.BooleanLiteral | ts.TypeFlags.Boolean)) !== 0;
+  if (!isBooleanDiscriminant)
+    return false;
+  return Boolean(type.getProperty("value") ?? type.getProperty("error"));
+}
+function isResultLike(type, checker) {
+  if (type.isUnion()) {
+    return type.types.length > 0 && type.types.every((member) => isResultMember(member, checker));
+  }
+  return isResultMember(type, checker);
+}
+var mustUseResult = createRule({
+  name: "must-use-result",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow discarding a Result without reading it, since the error it carries would be silently lost."
+    },
+    messages: {
+      mustUse: "This Result is discarded. Read its `.ok`, pass it on, or return it \u2014 otherwise the error it carries is lost silently."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const services = import_utils.ESLintUtils.getParserServices(context);
+    const checker = services.program.getTypeChecker();
+    return {
+      ExpressionStatement(node) {
+        const type = services.getTypeAtLocation(node.expression);
+        if (isResultLike(type, checker)) {
+          context.report({ messageId: "mustUse", node: node.expression });
+        }
+      }
+    };
+  }
+});
+var eslint_default = {
+  meta: { name: "@semyonf/kamchazky" },
+  rules: { "must-use-result": mustUseResult }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mustUseResult
+});
+//# sourceMappingURL=eslint.cjs.map

package/dist/eslint.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eslint.ts"],"sourcesContent":["import { ESLintUtils } from \"@typescript-eslint/utils\";\nimport * as ts from \"typescript\";\n\nconst createRule = ESLintUtils.RuleCreator(\n  (name) => `https://github.com/semyonf/kamchazky#${name}`\n);\n\nfunction isResultMember(type: ts.Type, checker: ts.TypeChecker): boolean {\n  const ok = type.getProperty(\"ok\");\n  if (!ok) return false;\n\n  const okType = checker.getTypeOfSymbol(ok);\n  const isBooleanDiscriminant =\n    (okType.flags & (ts.TypeFlags.BooleanLiteral | ts.TypeFlags.Boolean)) !== 0;\n  if (!isBooleanDiscriminant) return false;\n\n  return Boolean(type.getProperty(\"value\") ?? type.getProperty(\"error\"));\n}\n\nfunction isResultLike(type: ts.Type, checker: ts.TypeChecker): boolean {\n  if (type.isUnion()) {\n    return (\n      type.types.length > 0 &&\n      type.types.every((member) => isResultMember(member, checker))\n    );\n  }\n\n  return isResultMember(type, checker);\n}\n\nexport const mustUseResult = createRule({\n  name: \"must-use-result\",\n  meta: {\n    type: \"problem\",\n    docs: {\n      description:\n        \"Disallow discarding a Result without reading it, since the error it carries would be silently lost.\",\n    },\n    messages: {\n      mustUse:\n        \"This Result is discarded. Read its `.ok`, pass it on, or return it — otherwise the error it carries is lost silently.\",\n    },\n    schema: [],\n  },\n  defaultOptions: [],\n  create(context) {\n    const services = ESLintUtils.getParserServices(context);\n    const checker = services.program.getTypeChecker();\n\n    return {\n      ExpressionStatement(node) {\n        const type = services.getTypeAtLocation(node.expression);\n        if (isResultLike(type, checker)) {\n          context.report({ messageId: \"mustUse\", node: node.expression });\n        }\n      },\n    };\n  },\n});\n\nexport default {\n  meta: { name: \"@semyonf/kamchazky\" },\n  rules: { \"must-use-result\": mustUseResult },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA4B;AAC5B,SAAoB;AAEpB,IAAM,aAAa,yBAAY;AAAA,EAC7B,CAAC,SAAS,wCAAwC,IAAI;AACxD;AAEA,SAAS,eAAe,MAAe,SAAkC;AACvE,QAAM,KAAK,KAAK,YAAY,IAAI;AAChC,MAAI,CAAC;AAAI,WAAO;AAEhB,QAAM,SAAS,QAAQ,gBAAgB,EAAE;AACzC,QAAM,yBACH,OAAO,SAAY,aAAU,iBAAoB,aAAU,cAAc;AAC5E,MAAI,CAAC;AAAuB,WAAO;AAEnC,SAAO,QAAQ,KAAK,YAAY,OAAO,KAAK,KAAK,YAAY,OAAO,CAAC;AACvE;AAEA,SAAS,aAAa,MAAe,SAAkC;AACrE,MAAI,KAAK,QAAQ,GAAG;AAClB,WACE,KAAK,MAAM,SAAS,KACpB,KAAK,MAAM,MAAM,CAAC,WAAW,eAAe,QAAQ,OAAO,CAAC;AAAA,EAEhE;AAEA,SAAO,eAAe,MAAM,OAAO;AACrC;AAEO,IAAM,gBAAgB,WAAW;AAAA,EACtC,MAAM;AAAA,EACN,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,MAAM;AAAA,MACJ,aACE;AAAA,IACJ;AAAA,IACA,UAAU;AAAA,MACR,SACE;AAAA,IACJ;AAAA,IACA,QAAQ,CAAC;AAAA,EACX;AAAA,EACA,gBAAgB,CAAC;AAAA,EACjB,OAAO,SAAS;AACd,UAAM,WAAW,yBAAY,kBAAkB,OAAO;AACtD,UAAM,UAAU,SAAS,QAAQ,eAAe;AAEhD,WAAO;AAAA,MACL,oBAAoB,MAAM;AACxB,cAAM,OAAO,SAAS,kBAAkB,KAAK,UAAU;AACvD,YAAI,aAAa,MAAM,OAAO,GAAG;AAC/B,kBAAQ,OAAO,EAAE,WAAW,WAAW,MAAM,KAAK,WAAW,CAAC;AAAA,QAChE;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF,CAAC;AAED,IAAO,iBAAQ;AAAA,EACb,MAAM,EAAE,MAAM,qBAAqB;AAAA,EACnC,OAAO,EAAE,mBAAmB,cAAc;AAC5C;","names":[]}

package/dist/eslint.d.cts

@@ -0,0 +1,17 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+declare const mustUseResult: ESLintUtils.RuleModule<"mustUse", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+declare const _default: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        "must-use-result": ESLintUtils.RuleModule<"mustUse", [], unknown, ESLintUtils.RuleListener> & {
+            name: string;
+        };
+    };
+};
+
+export { _default as default, mustUseResult };

package/dist/eslint.d.ts

@@ -0,0 +1,17 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+declare const mustUseResult: ESLintUtils.RuleModule<"mustUse", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+declare const _default: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        "must-use-result": ESLintUtils.RuleModule<"mustUse", [], unknown, ESLintUtils.RuleListener> & {
+            name: string;
+        };
+    };
+};
+
+export { _default as default, mustUseResult };

package/dist/eslint.js

@@ -0,0 +1,57 @@
+// src/eslint.ts
+import { ESLintUtils } from "@typescript-eslint/utils";
+import * as ts from "typescript";
+var createRule = ESLintUtils.RuleCreator(
+  (name) => `https://github.com/semyonf/kamchazky#${name}`
+);
+function isResultMember(type, checker) {
+  const ok = type.getProperty("ok");
+  if (!ok)
+    return false;
+  const okType = checker.getTypeOfSymbol(ok);
+  const isBooleanDiscriminant = (okType.flags & (ts.TypeFlags.BooleanLiteral | ts.TypeFlags.Boolean)) !== 0;
+  if (!isBooleanDiscriminant)
+    return false;
+  return Boolean(type.getProperty("value") ?? type.getProperty("error"));
+}
+function isResultLike(type, checker) {
+  if (type.isUnion()) {
+    return type.types.length > 0 && type.types.every((member) => isResultMember(member, checker));
+  }
+  return isResultMember(type, checker);
+}
+var mustUseResult = createRule({
+  name: "must-use-result",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow discarding a Result without reading it, since the error it carries would be silently lost."
+    },
+    messages: {
+      mustUse: "This Result is discarded. Read its `.ok`, pass it on, or return it \u2014 otherwise the error it carries is lost silently."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const services = ESLintUtils.getParserServices(context);
+    const checker = services.program.getTypeChecker();
+    return {
+      ExpressionStatement(node) {
+        const type = services.getTypeAtLocation(node.expression);
+        if (isResultLike(type, checker)) {
+          context.report({ messageId: "mustUse", node: node.expression });
+        }
+      }
+    };
+  }
+});
+var eslint_default = {
+  meta: { name: "@semyonf/kamchazky" },
+  rules: { "must-use-result": mustUseResult }
+};
+export {
+  eslint_default as default,
+  mustUseResult
+};
+//# sourceMappingURL=eslint.js.map

package/dist/eslint.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/eslint.ts"],"sourcesContent":["import { ESLintUtils } from \"@typescript-eslint/utils\";\nimport * as ts from \"typescript\";\n\nconst createRule = ESLintUtils.RuleCreator(\n  (name) => `https://github.com/semyonf/kamchazky#${name}`\n);\n\nfunction isResultMember(type: ts.Type, checker: ts.TypeChecker): boolean {\n  const ok = type.getProperty(\"ok\");\n  if (!ok) return false;\n\n  const okType = checker.getTypeOfSymbol(ok);\n  const isBooleanDiscriminant =\n    (okType.flags & (ts.TypeFlags.BooleanLiteral | ts.TypeFlags.Boolean)) !== 0;\n  if (!isBooleanDiscriminant) return false;\n\n  return Boolean(type.getProperty(\"value\") ?? type.getProperty(\"error\"));\n}\n\nfunction isResultLike(type: ts.Type, checker: ts.TypeChecker): boolean {\n  if (type.isUnion()) {\n    return (\n      type.types.length > 0 &&\n      type.types.every((member) => isResultMember(member, checker))\n    );\n  }\n\n  return isResultMember(type, checker);\n}\n\nexport const mustUseResult = createRule({\n  name: \"must-use-result\",\n  meta: {\n    type: \"problem\",\n    docs: {\n      description:\n        \"Disallow discarding a Result without reading it, since the error it carries would be silently lost.\",\n    },\n    messages: {\n      mustUse:\n        \"This Result is discarded. Read its `.ok`, pass it on, or return it — otherwise the error it carries is lost silently.\",\n    },\n    schema: [],\n  },\n  defaultOptions: [],\n  create(context) {\n    const services = ESLintUtils.getParserServices(context);\n    const checker = services.program.getTypeChecker();\n\n    return {\n      ExpressionStatement(node) {\n        const type = services.getTypeAtLocation(node.expression);\n        if (isResultLike(type, checker)) {\n          context.report({ messageId: \"mustUse\", node: node.expression });\n        }\n      },\n    };\n  },\n});\n\nexport default {\n  meta: { name: \"@semyonf/kamchazky\" },\n  rules: { \"must-use-result\": mustUseResult },\n};\n"],"mappings":";AAAA,SAAS,mBAAmB;AAC5B,YAAY,QAAQ;AAEpB,IAAM,aAAa,YAAY;AAAA,EAC7B,CAAC,SAAS,wCAAwC,IAAI;AACxD;AAEA,SAAS,eAAe,MAAe,SAAkC;AACvE,QAAM,KAAK,KAAK,YAAY,IAAI;AAChC,MAAI,CAAC;AAAI,WAAO;AAEhB,QAAM,SAAS,QAAQ,gBAAgB,EAAE;AACzC,QAAM,yBACH,OAAO,SAAY,aAAU,iBAAoB,aAAU,cAAc;AAC5E,MAAI,CAAC;AAAuB,WAAO;AAEnC,SAAO,QAAQ,KAAK,YAAY,OAAO,KAAK,KAAK,YAAY,OAAO,CAAC;AACvE;AAEA,SAAS,aAAa,MAAe,SAAkC;AACrE,MAAI,KAAK,QAAQ,GAAG;AAClB,WACE,KAAK,MAAM,SAAS,KACpB,KAAK,MAAM,MAAM,CAAC,WAAW,eAAe,QAAQ,OAAO,CAAC;AAAA,EAEhE;AAEA,SAAO,eAAe,MAAM,OAAO;AACrC;AAEO,IAAM,gBAAgB,WAAW;AAAA,EACtC,MAAM;AAAA,EACN,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,MAAM;AAAA,MACJ,aACE;AAAA,IACJ;AAAA,IACA,UAAU;AAAA,MACR,SACE;AAAA,IACJ;AAAA,IACA,QAAQ,CAAC;AAAA,EACX;AAAA,EACA,gBAAgB,CAAC;AAAA,EACjB,OAAO,SAAS;AACd,UAAM,WAAW,YAAY,kBAAkB,OAAO;AACtD,UAAM,UAAU,SAAS,QAAQ,eAAe;AAEhD,WAAO;AAAA,MACL,oBAAoB,MAAM;AACxB,cAAM,OAAO,SAAS,kBAAkB,KAAK,UAAU;AACvD,YAAI,aAAa,MAAM,OAAO,GAAG;AAC/B,kBAAQ,OAAO,EAAE,WAAW,WAAW,MAAM,KAAK,WAAW,CAAC;AAAA,QAChE;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF,CAAC;AAED,IAAO,iBAAQ;AAAA,EACb,MAAM,EAAE,MAAM,qBAAqB;AAAA,EACnC,OAAO,EAAE,mBAAmB,cAAc;AAC5C;","names":[]}

package/dist/index.cjs

@@ -33,55 +33,20 @@ __export(src_exports, {
   some: () => some
 });
 module.exports = __toCommonJS(src_exports);
-function ok(value) {
-  const self = Object.freeze({
+function createOk(value) {
+  return Object.freeze({
     ok: true,
-    value,
-    map: (fn) => ok(fn(value)),
-    flatMap: (fn) => fn(value),
-    mapError: (_fn) => self,
-    inspect: (fn) => {
-      fn(value);
-      return self;
-    },
-    inspectError: (_fn) => self,
-    match: (handlers) => handlers.ok(value),
-    unwrap: () => value,
-    unwrapOr: (_fallback) => value,
-    unwrapOrElse: (_fn) => value,
-    expect: (_message) => value
+    value
   });
-  return self;
+}
+function ok(...args) {
+  return args.length === 0 ? createOk(void 0) : createOk(args[0]);
 }
 function err(error) {
-  const self = Object.freeze({
+  return Object.freeze({
     ok: false,
-    error,
-    map: (_fn) => self,
-    flatMap: (_fn) => self,
-    mapError: (fn) => err(fn(error)),
-    inspect: (_fn) => self,
-    inspectError: (fn) => {
-      fn(error);
-      return self;
-    },
-    match: (handlers) => handlers.err(error),
-    unwrap: () => {
-      throw error;
-    },
-    unwrapOr: (fallback) => fallback,
-    unwrapOrElse: (fn) => fn(),
-    expect: (message) => {
-      const thrown = new Error(`${message}: ${error.message}`, {
-        cause: error
-      });
-      Object.setPrototypeOf(thrown, error.constructor.prototype);
-      if (error.stack !== void 0)
-        thrown.stack = error.stack;
-      throw thrown;
-    }
+    error
   });
-  return self;
 }
 function isOk(result) {
   return result.ok;
@@ -144,17 +109,6 @@ function unwrapOr(result, fallback) {
 function unwrapOrElse(result, fn) {
   return result.ok ? result.value : fn();
 }
-function expect(result, message) {
-  if (result.ok)
-    return result.value;
-  const thrown = new Error(`${message}: ${result.error.message}`, {
-    cause: result.error
-  });
-  Object.setPrototypeOf(thrown, result.error.constructor.prototype);
-  if (result.error.stack !== void 0)
-    thrown.stack = result.error.stack;
-  throw thrown;
-}
 function fromNullable(value, errorFactory) {
   return value != null ? ok(value) : err(errorFactory());
 }
@@ -267,39 +221,13 @@ function collect(...results) {
   return ok(values);
 }
 function some(value) {
-  const self = Object.freeze({
+  return Object.freeze({
     some: true,
-    value,
-    map: (fn) => some(fn(value)),
-    flatMap: (fn) => fn(value),
-    filter: (predicate) => predicate(value) ? self : NONE,
-    inspect: (fn) => {
-      fn(value);
-      return self;
-    },
-    match: (handlers) => handlers.some(value),
-    unwrap: () => value,
-    expect: (_message) => value,
-    unwrapOr: (_fallback) => value,
-    unwrapOrElse: (_fn) => value
+    value
   });
-  return self;
 }
 var NONE = Object.freeze({
-  some: false,
-  map: (_fn) => NONE,
-  flatMap: (_fn) => NONE,
-  filter: (_predicate) => NONE,
-  inspect: (_fn) => NONE,
-  match: (handlers) => handlers.none(),
-  unwrap: () => {
-    throw new Error("Called unwrap on None");
-  },
-  expect: (message) => {
-    throw new Error(message);
-  },
-  unwrapOr: (fallback) => fallback,
-  unwrapOrElse: (fn) => fn()
+  some: false
 });
 function none() {
   return NONE;
@@ -341,11 +269,6 @@ function maybeUnwrapOr(maybe, fallback) {
 function maybeUnwrapOrElse(maybe, fn) {
   return maybe.some ? maybe.value : fn();
 }
-function maybeExpect(maybe, message) {
-  if (maybe.some)
-    return maybe.value;
-  throw new Error(message);
-}
 function maybeFromNullable(value) {
   return value != null ? some(value) : NONE;
 }
@@ -421,7 +344,6 @@ var Maybe = {
   unwrap: maybeUnwrap,
   unwrapOr: maybeUnwrapOr,
   unwrapOrElse: maybeUnwrapOrElse,
-  expect: maybeExpect,
   fromNullable: maybeFromNullable,
   fromPredicate: maybeFromPredicate,
   all: maybeAll,
@@ -431,6 +353,11 @@ var Maybe = {
   toResult: maybeToResult,
   fromResult: maybeFromResult,
   transpose: maybeTranspose
+  // `as const` without `satisfies Record<string, Function>`: the namespace is a
+  // small, static, hand-maintained list of named function references — the
+  // function-only invariant is obvious from inspection and enforced by code
+  // review. Adding `satisfies` would guard a near-zero-probability mistake that
+  // TypeScript would catch at every call site anyway, for no consumer benefit.
 };
 var Result = {
   ok,
@@ -450,7 +377,6 @@ var Result = {
   unwrap,
   unwrapOr,
   unwrapOrElse,
-  expect,
   fromNullable,
   fromPredicate,
   normalizeError,
@@ -464,6 +390,7 @@ var Result = {
   toMaybe: resultToMaybe,
   fromMaybe: resultFromMaybe,
   transpose: resultTranspose
+  // See comment on Maybe above.
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/** A successful result containing a value of type `T`. */\nexport type OkResult<T> = {\n  readonly ok: true;\n  readonly value: T;\n  map<U>(fn: (value: T) => U): OkResult<U>;\n  flatMap<U, F extends Error = never>(\n    fn: (value: T) => Result<U, F>\n  ): Result<U, F>;\n  mapError<F extends Error>(fn: (error: never) => F): OkResult<T>;\n  inspect(fn: (value: T) => void): OkResult<T>;\n  inspectError(fn: (error: never) => void): OkResult<T>;\n  match<R>(handlers: { ok: (value: T) => R; err: (error: never) => R }): R;\n  unwrap(): T;\n  unwrapOr(fallback: T): T;\n  unwrapOrElse(fn: () => T): T;\n  expect(message: string): T;\n};\n\n/** A failed result containing an error of type `E`. */\nexport type ErrResult<E extends Error = Error> = {\n  readonly ok: false;\n  readonly error: E;\n  map<U>(fn: (value: never) => U): ErrResult<E>;\n  flatMap<U, F extends Error = never>(\n    fn: (value: never) => Result<U, F>\n  ): ErrResult<E>;\n  mapError<F extends Error>(fn: (error: E) => F): ErrResult<F>;\n  inspect(fn: (value: never) => void): ErrResult<E>;\n  inspectError(fn: (error: E) => void): ErrResult<E>;\n  match<R>(handlers: { ok: (value: never) => R; err: (error: E) => R }): R;\n  unwrap(): never;\n  unwrapOr<T>(fallback: T): T;\n  unwrapOrElse<T>(fn: () => T): T;\n  expect(message: string): never;\n};\n\n/**\n * A value that is either a success (`OkResult<T>`) or a failure\n * (`ErrResult<E>`).  Use `Result.ok` / `Result.err` to construct, and the\n * companion `Result.*` functions or instance methods to transform.\n */\nexport type Result<T, E extends Error = Error> = OkResult<T> | ErrResult<E>;\n\ntype AnyResult = Result<unknown, Error>;\n\ntype ValueOf<R> = R extends OkResult<infer T> ? T : never;\ntype ErrorOf<R> = R extends ErrResult<infer E> ? E : never;\n\ntype TupleValues<R extends readonly AnyResult[]> = {\n  [K in keyof R]: ValueOf<R[K]>;\n};\ntype TupleErrors<R extends readonly AnyResult[]> = ErrorOf<R[number]>;\n\n/** Create a successful `Result` containing `value`. */\nfunction ok(): OkResult<undefined>;\nfunction ok<T>(value: T): OkResult<T>;\nfunction ok<T>(value?: T): OkResult<T | undefined> {\n  const self: OkResult<T | undefined> = Object.freeze({\n    ok: true as const,\n    value,\n    map: <U>(fn: (value: T | undefined) => U): OkResult<U> => ok(fn(value)),\n    flatMap: <U, F extends Error = never>(\n      fn: (value: T | undefined) => Result<U, F>\n    ): Result<U, F> => fn(value),\n    mapError: <F extends Error>(\n      _fn: (error: never) => F\n    ): OkResult<T | undefined> => self,\n    inspect: (fn: (value: T | undefined) => void): OkResult<T | undefined> => {\n      fn(value);\n      return self;\n    },\n    inspectError: (_fn: (error: never) => void): OkResult<T | undefined> =>\n      self,\n    match: <R>(handlers: {\n      ok: (value: T | undefined) => R;\n      err: (error: never) => R;\n    }): R => handlers.ok(value),\n    unwrap: (): T | undefined => value,\n    unwrapOr: (_fallback: T | undefined): T | undefined => value,\n    unwrapOrElse: (_fn: () => T | undefined): T | undefined => value,\n    expect: (_message: string): T | undefined => value,\n  });\n  return self;\n}\n\n/** Create a failed `Result` containing `error`. */\nfunction err<E extends Error>(error: E): ErrResult<E> {\n  const self: ErrResult<E> = Object.freeze({\n    ok: false as const,\n    error,\n    map: <U>(_fn: (value: never) => U): ErrResult<E> => self,\n    flatMap: <U, F extends Error = never>(\n      _fn: (value: never) => Result<U, F>\n    ): ErrResult<E> => self,\n    mapError: <F extends Error>(fn: (error: E) => F): ErrResult<F> =>\n      err(fn(error)),\n    inspect: (_fn: (value: never) => void): ErrResult<E> => self,\n    inspectError: (fn: (error: E) => void): ErrResult<E> => {\n      fn(error);\n      return self;\n    },\n    match: <R>(handlers: {\n      ok: (value: never) => R;\n      err: (error: E) => R;\n    }): R => handlers.err(error),\n    unwrap: (): never => {\n      throw error;\n    },\n    unwrapOr: <T>(fallback: T): T => fallback,\n    unwrapOrElse: <T>(fn: () => T): T => fn(),\n    expect: (message: string): never => {\n      const thrown = new Error(`${message}: ${error.message}`, {\n        cause: error,\n      });\n      Object.setPrototypeOf(thrown, error.constructor.prototype);\n      if (error.stack !== undefined) thrown.stack = error.stack;\n      throw thrown;\n    },\n  });\n  return self;\n}\n\n/** Narrow a `Result` to `OkResult`. */\nfunction isOk<T, E extends Error>(result: Result<T, E>): result is OkResult<T> {\n  return result.ok;\n}\n\n/** Narrow a `Result` to `ErrResult`. */\nfunction isErr<T, E extends Error>(\n  result: Result<T, E>\n): result is ErrResult<E> {\n  return !result.ok;\n}\n\n/** Transform the value inside an `Ok`, leaving `Err` unchanged. */\nfunction map<T, U>(result: OkResult<T>, fn: (value: T) => U): OkResult<U>;\nfunction map<T, U, E extends Error>(\n  result: Result<T, E>,\n  fn: (value: T) => U\n): Result<U, E>;\nfunction map<T, U, E extends Error>(\n  result: Result<T, E>,\n  fn: (value: T) => U\n): Result<U, E> {\n  return result.ok ? ok(fn(result.value)) : result;\n}\n\n/** Transform the error inside an `Err`, leaving `Ok` unchanged. */\nfunction mapError<T>(\n  result: OkResult<T>,\n  fn: (error: never) => Error\n): OkResult<T>;\nfunction mapError<T, E extends Error, F extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => F\n): Result<T, F>;\nfunction mapError<T, E extends Error, F extends Error>(\n  result: OkResult<T> | Result<T, E>,\n  fn: ((error: never) => Error) | ((error: E) => F)\n): OkResult<T> | Result<T, F> {\n  return result.ok ? result : err((fn as (error: E) => F)(result.error));\n}\n\n/** Run a side-effect on the `Ok` value without transforming the result. */\nfunction inspect<T>(result: OkResult<T>, fn: (value: T) => void): OkResult<T>;\nfunction inspect<T, E extends Error>(\n  result: Result<T, E>,\n  fn: (value: T) => void\n): Result<T, E>;\nfunction inspect<T, E extends Error>(\n  result: Result<T, E>,\n  fn: (value: T) => void\n): Result<T, E> {\n  if (result.ok) fn(result.value);\n  return result;\n}\n\n/** Run a side-effect on the `Err` error without transforming the result. */\nfunction inspectError<E extends Error>(\n  result: ErrResult<E>,\n  fn: (error: E) => void\n): ErrResult<E>;\nfunction inspectError<T, E extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => void\n): Result<T, E>;\nfunction inspectError<T, E extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => void\n): Result<T, E> {\n  if (!result.ok) fn(result.error);\n  return result;\n}\n\n/** Chain a `Result`-returning function on the `Ok` value. */\nfunction flatMap<T, U, E extends Error, F extends Error = never>(\n  result: Result<T, E>,\n  fn: (value: T) => Result<U, F>\n): Result<U, E | F> {\n  if (result.ok) return fn(result.value);\n  // Safe: ErrResult<E> ⊆ Result<U, E | F>  — error type is widened, value\n  // channel is unused.  The assertion is needed because ErrResult's methods\n  // make E invariant in TypeScript's structural checker.\n  return result as ErrResult<E | F>;\n}\n\n/**\n * Recover from an error by applying `fn` to produce a new `Result`.\n * Alias: `flatMapErr`.\n */\nfunction orElse<T, E extends Error, F extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => Result<T, F>\n): Result<T, F> {\n  if (!result.ok) return fn(result.error);\n  // Safe: OkResult<T> ⊆ Result<T, F> — same variance pattern as flatMap.\n  return result as OkResult<T>;\n}\n\n/**\n * Recover from an error by applying `fn` to produce a new `Result`.\n * Alias for `orElse`.\n */\nfunction flatMapErr<T, E extends Error, F extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => Result<T, F>\n): Result<T, F> {\n  return orElse(result, fn);\n}\n\n/** Flatten a nested `Result<Result<T, E>, F>` into `Result<T, E | F>`. */\nfunction flatten<T, E extends Error, F extends Error>(\n  result: Result<Result<T, E>, F>\n): Result<T, E | F> {\n  // Safe: both branches widen the error type — same variance pattern as flatMap.\n  return (result.ok ? result.value : result) as Result<T, E | F>;\n}\n\n/** Exhaustively handle both `Ok` and `Err` branches, returning `R`. */\nfunction match<T, E extends Error, R>(\n  result: Result<T, E>,\n  handlers: { ok: (value: T) => R; err: (error: E) => R }\n): R {\n  return result.ok ? handlers.ok(result.value) : handlers.err(result.error);\n}\n\n/** Compile-time exhaustiveness guard — only accepts `never`. */\nfunction exhaustive(value: never): never {\n  let detail: string;\n  try {\n    detail = JSON.stringify(value);\n  } catch {\n    detail = String(value);\n  }\n  throw new Error(`Unhandled result case: ${detail}`);\n}\n\n/** Return the `Ok` value or throw the contained error. */\nfunction unwrap<T, E extends Error>(result: Result<T, E>): T {\n  if (result.ok) return result.value;\n  throw result.error;\n}\n\n/**\n * Return the `Ok` value or `fallback`.\n *\n * The fallback must be the same type `T` as the success value.  This is\n * intentional — use `match` when you need a different return type.\n */\nfunction unwrapOr<T, E extends Error>(result: Result<T, E>, fallback: T): T {\n  return result.ok ? result.value : fallback;\n}\n\n/** Return the `Ok` value, or compute a fallback from `fn`. */\nfunction unwrapOrElse<T, E extends Error>(\n  result: Result<T, E>,\n  fn: () => T\n): T {\n  return result.ok ? result.value : fn();\n}\n\n/** Return the `Ok` value or throw with a custom `message`. */\nfunction expect<T, E extends Error>(result: Result<T, E>, message: string): T {\n  if (result.ok) return result.value;\n  const thrown = new Error(`${message}: ${result.error.message}`, {\n    cause: result.error,\n  });\n  Object.setPrototypeOf(thrown, result.error.constructor.prototype);\n  if (result.error.stack !== undefined) thrown.stack = result.error.stack;\n  throw thrown;\n}\n\n/** Convert a nullable value to a `Result`. */\nfunction fromNullable<T, E extends Error>(\n  value: T | null | undefined,\n  errorFactory: () => E\n): Result<NonNullable<T>, E> {\n  return value != null ? ok(value as NonNullable<T>) : err(errorFactory());\n}\n\n/** Convert a predicate check to a `Result`.  Supports type-guard predicates. */\nfunction fromPredicate<T, S extends T, E extends Error>(\n  value: T,\n  predicate: (value: T) => value is S,\n  errorFactory: () => E\n): Result<S, E>;\nfunction fromPredicate<T, E extends Error>(\n  value: T,\n  predicate: (value: T) => boolean,\n  errorFactory: () => E\n): Result<T, E>;\nfunction fromPredicate<T, E extends Error>(\n  value: T,\n  predicate: (value: T) => boolean,\n  errorFactory: () => E\n): Result<T, E> {\n  return predicate(value) ? ok(value) : err(errorFactory());\n}\n\n/** Convert an unknown thrown value to an `Error` instance. */\nfunction normalizeError(error: unknown): Error {\n  if (error instanceof Error) return error;\n  if (error === null || error === undefined) return new Error(String(error));\n  if (typeof error === \"object\") {\n    try {\n      const json = JSON.stringify(error);\n      if (json !== \"{}\") return new Error(json);\n      // JSON.stringify produced '{}' — likely RegExp or similar with no\n      // enumerable own properties. Fall through to String().\n    } catch {\n      // JSON.stringify throws on BigInt and circular references\n    }\n  }\n  try {\n    return new Error(String(error));\n  } catch {\n    return new Error(\"Non-stringifiable thrown value\");\n  }\n}\n\n/** Wrap a synchronous function that may throw into a `Result`. */\nfunction tryCatch<T>(fn: () => T): Result<T, Error>;\nfunction tryCatch<T, E extends Error>(\n  fn: () => T,\n  onError: (error: unknown) => E\n): Result<T, E>;\nfunction tryCatch<T, E extends Error>(\n  fn: () => T,\n  onError?: (error: unknown) => E\n): Result<T, E | Error> {\n  try {\n    return ok(fn());\n  } catch (error) {\n    try {\n      return err(onError ? onError(error) : normalizeError(error));\n    } catch (mapperError) {\n      return err(new Error(\"Error mapper threw\", { cause: mapperError }));\n    }\n  }\n}\n\n/** Wrap an asynchronous function that may reject into a `Result`. */\nfunction tryCatchAsync<T>(fn: () => Promise<T>): Promise<Result<T, Error>>;\nfunction tryCatchAsync<T, E extends Error>(\n  fn: () => Promise<T>,\n  onError: (error: unknown) => E\n): Promise<Result<T, E>>;\nasync function tryCatchAsync<T, E extends Error>(\n  fn: () => Promise<T>,\n  onError?: (error: unknown) => E\n): Promise<Result<T, E | Error>> {\n  try {\n    return ok(await fn());\n  } catch (error) {\n    try {\n      return err(onError ? onError(error) : normalizeError(error));\n    } catch (mapperError) {\n      return err(new Error(\"Error mapper threw\", { cause: mapperError }));\n    }\n  }\n}\n\n/** Wrap a `Promise` that may reject into a `Result`. */\nfunction fromPromise<T>(promise: Promise<T>): Promise<Result<T, Error>>;\nfunction fromPromise<T, E extends Error>(\n  promise: Promise<T>,\n  onError: (error: unknown) => E\n): Promise<Result<T, E>>;\nasync function fromPromise<T, E extends Error>(\n  promise: Promise<T>,\n  onError?: (error: unknown) => E\n): Promise<Result<T, E | Error>> {\n  try {\n    return ok(await promise);\n  } catch (error) {\n    try {\n      return err(onError ? onError(error) : normalizeError(error));\n    } catch (mapperError) {\n      return err(new Error(\"Error mapper threw\", { cause: mapperError }));\n    }\n  }\n}\n\n/**\n * Combine multiple `Result`s into a single `Result` containing a tuple of\n * values.  Returns the first `Err` encountered (fail-fast).\n *\n * Pass results as individual arguments — spreading an array loses tuple\n * inference and degrades value types to `unknown[]`.\n */\nfunction all<const R extends readonly AnyResult[]>(\n  ...results: R\n): Result<TupleValues<R>, TupleErrors<R>> {\n  const values: unknown[] = [];\n  for (const result of results) {\n    if (!result.ok) return err(result.error) as ErrResult<TupleErrors<R>>;\n    values.push(result.value);\n  }\n  return ok(values) as OkResult<TupleValues<R>>;\n}\n\n/**\n * Like `all`, but accepts promises of `Result`s.  All promises are resolved\n * concurrently via `Promise.allSettled` before checking for errors.\n *\n * Promises are expected to resolve to `Result`s — not reject.  If a promise\n * does reject, the rejection is caught and wrapped as an `Err`.\n *\n * @breaking v0.2 — Uses `Promise.allSettled` instead of `Promise.all`. All\n * promises are now always awaited to completion; the first error found during\n * iteration is returned.\n */\nasync function allAsync<const R extends readonly Promise<AnyResult>[]>(\n  ...promises: R\n): Promise<\n  Result<\n    { [K in keyof R]: ValueOf<Awaited<R[K]>> },\n    ErrorOf<Awaited<R[number]>> | Error\n  >\n> {\n  type Values = { [K in keyof R]: ValueOf<Awaited<R[K]>> };\n  type Errors = ErrorOf<Awaited<R[number]>> | Error;\n\n  const settled = await Promise.allSettled(promises);\n  const values: unknown[] = [];\n  for (const s of settled) {\n    if (s.status === \"rejected\") {\n      return err(normalizeError(s.reason)) as ErrResult<Errors>;\n    }\n    if (!s.value.ok) {\n      return err(s.value.error) as ErrResult<Errors>;\n    }\n    values.push(s.value.value);\n  }\n  return ok(values) as OkResult<Values>;\n}\n\n/**\n * Like `collect`, but for promises of `Result`s.  Resolves all promises\n * via `Promise.allSettled`, then collects all errors.  Returns an\n * `AggregateError` containing every error found.\n */\nasync function collectAsync<const R extends readonly Promise<AnyResult>[]>(\n  ...promises: R\n): Promise<Result<{ [K in keyof R]: ValueOf<Awaited<R[K]>> }, AggregateError>> {\n  type Values = { [K in keyof R]: ValueOf<Awaited<R[K]>> };\n\n  const settled = await Promise.allSettled(promises);\n  const values: unknown[] = [];\n  const errors: Error[] = [];\n  for (const s of settled) {\n    if (s.status === \"rejected\") {\n      errors.push(normalizeError(s.reason));\n    } else if (!s.value.ok) {\n      errors.push(s.value.error);\n    } else {\n      values.push(s.value.value);\n    }\n  }\n  if (errors.length > 0)\n    return err(new AggregateError(errors)) as ErrResult<AggregateError>;\n  return ok(values) as OkResult<Values>;\n}\n\n/**\n * Combine multiple `Result`s, collecting **all** errors instead of\n * short-circuiting on the first one.  Returns an `AggregateError` whose\n * `.errors` array contains every individual error.\n */\nfunction collect<const R extends readonly AnyResult[]>(\n  ...results: R\n): Result<TupleValues<R>, AggregateError> {\n  const values: unknown[] = [];\n  const errors: Error[] = [];\n  for (const result of results) {\n    if (result.ok) values.push(result.value);\n    else errors.push(result.error);\n  }\n  if (errors.length > 0)\n    return err(new AggregateError(errors)) as ErrResult<AggregateError>;\n  return ok(values) as OkResult<TupleValues<R>>;\n}\n\n// ===========================================================================\n// Maybe\n// ===========================================================================\n\n/** A `Maybe` that contains a value of type `T`. */\nexport type Some<T> = {\n  readonly some: true;\n  readonly value: T;\n  map<U>(fn: (value: T) => U): Some<U>;\n  flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U>;\n  filter(predicate: (value: T) => boolean): Maybe<T>;\n  inspect(fn: (value: T) => void): Some<T>;\n  match<R>(handlers: { some: (value: T) => R; none: () => R }): R;\n  unwrap(): T;\n  expect(message: string): T;\n  unwrapOr(fallback: T): T;\n  unwrapOrElse(fn: () => T): T;\n};\n\n/** A `Maybe` that contains no value. */\nexport type None = {\n  readonly some: false;\n  map<U>(fn: (value: never) => U): None;\n  flatMap<U>(fn: (value: never) => Maybe<U>): None;\n  filter(predicate: (value: never) => boolean): None;\n  inspect(fn: (value: never) => void): None;\n  match<R>(handlers: { some: (value: never) => R; none: () => R }): R;\n  unwrap(): never;\n  expect(message: string): never;\n  unwrapOr<T>(fallback: T): T;\n  unwrapOrElse<T>(fn: () => T): T;\n};\n\n/**\n * A value that is either present (`Some<T>`) or absent (`None`).\n * Use `Maybe.some` / `Maybe.none` to construct, and the companion `Maybe.*`\n * functions or instance methods to transform.\n */\nexport type Maybe<T> = Some<T> | None;\n\ntype AnyMaybe = Maybe<unknown>;\n\ntype MaybeValueOf<M> = M extends Some<infer T> ? T : never;\n\ntype TupleMaybeValues<M extends readonly AnyMaybe[]> = {\n  [K in keyof M]: MaybeValueOf<M[K]>;\n};\n\n/** Create a `Maybe` containing `value`. */\nfunction some<T>(value: T): Some<T> {\n  const self: Some<T> = Object.freeze({\n    some: true as const,\n    value,\n    map: <U>(fn: (value: T) => U): Some<U> => some(fn(value)),\n    flatMap: <U>(fn: (value: T) => Maybe<U>): Maybe<U> => fn(value),\n    filter: (predicate: (value: T) => boolean): Maybe<T> =>\n      predicate(value) ? self : NONE,\n    inspect: (fn: (value: T) => void): Some<T> => {\n      fn(value);\n      return self;\n    },\n    match: <R>(handlers: { some: (value: T) => R; none: () => R }): R =>\n      handlers.some(value),\n    unwrap: (): T => value,\n    expect: (_message: string): T => value,\n    unwrapOr: (_fallback: T): T => value,\n    unwrapOrElse: (_fn: () => T): T => value,\n  });\n  return self;\n}\n\nconst NONE: None = Object.freeze({\n  some: false as const,\n  map: <U>(_fn: (value: never) => U): None => NONE,\n  flatMap: <U>(_fn: (value: never) => Maybe<U>): None => NONE,\n  filter: (_predicate: (value: never) => boolean): None => NONE,\n  inspect: (_fn: (value: never) => void): None => NONE,\n  match: <R>(handlers: { some: (value: never) => R; none: () => R }): R =>\n    handlers.none(),\n  unwrap: (): never => {\n    throw new Error(\"Called unwrap on None\");\n  },\n  expect: (message: string): never => {\n    throw new Error(message);\n  },\n  unwrapOr: <T>(fallback: T): T => fallback,\n  unwrapOrElse: <T>(fn: () => T): T => fn(),\n});\n\n/** Create an empty `Maybe`. */\nfunction none(): None {\n  return NONE;\n}\n\n/** Narrow a `Maybe` to `Some`. */\nfunction isSome<T>(maybe: Maybe<T>): maybe is Some<T> {\n  return maybe.some;\n}\n\n/** Narrow a `Maybe` to `None`. */\nfunction isNone<T>(maybe: Maybe<T>): maybe is None {\n  return !maybe.some;\n}\n\n/** Transform the value inside a `Some`, leaving `None` unchanged. */\nfunction maybeMap<T, U>(maybe: Some<T>, fn: (value: T) => U): Some<U>;\nfunction maybeMap<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nfunction maybeMap<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> {\n  return maybe.some ? some(fn(maybe.value)) : NONE;\n}\n\n/** Chain a `Maybe`-returning function on the `Some` value. */\nfunction maybeFlatMap<T, U>(\n  maybe: Maybe<T>,\n  fn: (value: T) => Maybe<U>\n): Maybe<U> {\n  return maybe.some ? fn(maybe.value) : NONE;\n}\n\n/** Flatten a nested `Maybe<Maybe<T>>` into `Maybe<T>`. */\nfunction maybeFlatten<T>(maybe: Maybe<Maybe<T>>): Maybe<T> {\n  return maybe.some ? maybe.value : NONE;\n}\n\n/** Keep the `Some` value only if `predicate` returns true. */\nfunction maybeFilter<T, S extends T>(\n  maybe: Maybe<T>,\n  predicate: (value: T) => value is S\n): Maybe<S>;\nfunction maybeFilter<T>(\n  maybe: Maybe<T>,\n  predicate: (value: T) => boolean\n): Maybe<T>;\nfunction maybeFilter<T>(\n  maybe: Maybe<T>,\n  predicate: (value: T) => boolean\n): Maybe<T> {\n  return maybe.some && predicate(maybe.value) ? maybe : NONE;\n}\n\n/** Run a side-effect on the `Some` value without transforming the maybe. */\nfunction maybeInspect<T>(maybe: Some<T>, fn: (value: T) => void): Some<T>;\nfunction maybeInspect<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nfunction maybeInspect<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> {\n  if (maybe.some) fn(maybe.value);\n  return maybe;\n}\n\n/** Exhaustively handle both `Some` and `None` branches, returning `R`. */\nfunction maybeMatch<T, R>(\n  maybe: Maybe<T>,\n  handlers: { some: (value: T) => R; none: () => R }\n): R {\n  return maybe.some ? handlers.some(maybe.value) : handlers.none();\n}\n\n/** Return the `Some` value or throw. */\nfunction maybeUnwrap<T>(maybe: Maybe<T>): T {\n  if (maybe.some) return maybe.value;\n  throw new Error(\"Called unwrap on None\");\n}\n\n/**\n * Return the `Some` value or `fallback`.\n *\n * The fallback must be the same type `T` as the contained value.  This is\n * intentional — use `match` when you need a different return type.\n */\nfunction maybeUnwrapOr<T>(maybe: Maybe<T>, fallback: T): T {\n  return maybe.some ? maybe.value : fallback;\n}\n\n/** Return the `Some` value, or compute a fallback from `fn`. */\nfunction maybeUnwrapOrElse<T>(maybe: Maybe<T>, fn: () => T): T {\n  return maybe.some ? maybe.value : fn();\n}\n\n/** Return the `Some` value or throw with a custom `message`. */\nfunction maybeExpect<T>(maybe: Maybe<T>, message: string): T {\n  if (maybe.some) return maybe.value;\n  throw new Error(message);\n}\n\n/** Convert a nullable value to a `Maybe`. */\nfunction maybeFromNullable<T>(\n  value: T | null | undefined\n): Maybe<NonNullable<T>> {\n  return value != null ? some(value as NonNullable<T>) : NONE;\n}\n\n/** Convert a predicate check to a `Maybe`.  Supports type-guard predicates. */\nfunction maybeFromPredicate<T, S extends T>(\n  value: T,\n  predicate: (value: T) => value is S\n): Maybe<S>;\nfunction maybeFromPredicate<T>(\n  value: T,\n  predicate: (value: T) => boolean\n): Maybe<T>;\nfunction maybeFromPredicate<T>(\n  value: T,\n  predicate: (value: T) => boolean\n): Maybe<T> {\n  return predicate(value) ? some(value) : NONE;\n}\n\n/**\n * Combine multiple `Maybe`s into a single `Maybe` containing a tuple of\n * values.  Returns `None` if any input is `None` (fail-fast).\n *\n * Pass maybes as individual arguments — spreading an array loses tuple\n * inference and degrades value types to `unknown[]`.\n */\nfunction maybeAll<const M extends readonly AnyMaybe[]>(\n  ...maybes: M\n): Maybe<TupleMaybeValues<M>> {\n  const values: unknown[] = [];\n  for (const m of maybes) {\n    if (!m.some) return NONE;\n    values.push(m.value);\n  }\n  return some(values) as Some<TupleMaybeValues<M>>;\n}\n\n/** Return the first `Some` found, or `None` if all are `None`. */\nfunction maybeFirstSome<T>(...maybes: Maybe<T>[]): Maybe<T> {\n  for (const m of maybes) {\n    if (m.some) return m;\n  }\n  return NONE;\n}\n\n/** Like `all`, but for promises of `Maybe`s.  Resolves all promises\n *  concurrently via `Promise.allSettled`. */\nasync function maybeAllAsync<const M extends readonly Promise<AnyMaybe>[]>(\n  ...promises: M\n): Promise<Maybe<{ [K in keyof M]: MaybeValueOf<Awaited<M[K]>> }>> {\n  type Values = { [K in keyof M]: MaybeValueOf<Awaited<M[K]>> };\n\n  const settled = await Promise.allSettled(promises);\n  const values: unknown[] = [];\n  for (const s of settled) {\n    if (s.status === \"rejected\") return NONE;\n    if (!s.value.some) return NONE;\n    values.push(s.value.value);\n  }\n  return some(values) as Some<Values>;\n}\n\n/** Combine multiple `Maybe's, returning `None` if any is `None`.\n * Same as `all` — `None` carries no error data to collect,\n * unlike `Result.collect` which gathers all errors.\n */\nconst maybeCollect = maybeAll;\n\n// ---------------------------------------------------------------------------\n// Maybe <-> Result interop\n// ---------------------------------------------------------------------------\n\n/** Convert a `Maybe` to a `Result`, calling `errorFactory` only when `None`.\n *\n * @breaking v0.2 — The second argument changed from `error: E` to\n * `errorFactory: () => E`. The factory is only called when the Maybe is\n * None, avoiding unnecessary error construction for Some.\n */\nfunction maybeToResult<T, E extends Error>(\n  maybe: Maybe<T>,\n  errorFactory: () => E\n): Result<T, E> {\n  return maybe.some ? ok(maybe.value) : err(errorFactory());\n}\n\n/** Convert a `Result` to a `Maybe`, discarding the error. */\nfunction maybeFromResult<T, E extends Error>(result: Result<T, E>): Maybe<T> {\n  return result.ok ? some(result.value) : NONE;\n}\n\n/** Convert a `Result` to a `Maybe`, discarding the error. */\nfunction resultToMaybe<T, E extends Error>(result: Result<T, E>): Maybe<T> {\n  return maybeFromResult(result);\n}\n\n/** Convert a `Maybe` to a `Result`, calling `errorFactory` only when `None`.\n * Alias for `maybeToResult`.\n *\n * @breaking v0.2 — The second argument changed from `error: E` to\n * `errorFactory: () => E`.\n */\nfunction resultFromMaybe<T, E extends Error>(\n  maybe: Maybe<T>,\n  errorFactory: () => E\n): Result<T, E> {\n  return maybeToResult(maybe, errorFactory);\n}\n\n/** Convert a `Result<Maybe<T>, E>` to `Maybe<Result<T, E>>`. */\nfunction resultTranspose<T, E extends Error>(\n  result: Result<Maybe<T>, E>\n): Maybe<Result<T, E>> {\n  if (!result.ok) return some(result as ErrResult<E>);\n  if (result.value.some) return some(ok(result.value.value));\n  return NONE;\n}\n\n/** Convert a `Maybe<Result<T, E>>` to `Result<Maybe<T>, E>`. */\nfunction maybeTranspose<T, E extends Error>(\n  maybe: Maybe<Result<T, E>>\n): Result<Maybe<T>, E> {\n  if (!maybe.some) return ok(NONE) as OkResult<Maybe<T>>;\n  if (maybe.value.ok) return ok(some(maybe.value.value));\n  return err(maybe.value.error) as ErrResult<E>;\n}\n\nexport const Maybe = {\n  some,\n  none,\n  isSome,\n  isNone,\n  map: maybeMap,\n  flatMap: maybeFlatMap,\n  flatten: maybeFlatten,\n  filter: maybeFilter,\n  inspect: maybeInspect,\n  match: maybeMatch,\n  unwrap: maybeUnwrap,\n  unwrapOr: maybeUnwrapOr,\n  unwrapOrElse: maybeUnwrapOrElse,\n  expect: maybeExpect,\n  fromNullable: maybeFromNullable,\n  fromPredicate: maybeFromPredicate,\n  all: maybeAll,\n  allAsync: maybeAllAsync,\n  collect: maybeCollect,\n  firstSome: maybeFirstSome,\n  toResult: maybeToResult,\n  fromResult: maybeFromResult,\n  transpose: maybeTranspose,\n} as const satisfies Record<string, (...args: never[]) => unknown>;\n\n// Add interop to Result namespace\nexport const Result = {\n  ok,\n  err,\n  isOk,\n  isErr,\n  map,\n  mapError,\n  inspect,\n  inspectError,\n  flatMap,\n  flatMapErr,\n  orElse,\n  flatten,\n  match,\n  exhaustive,\n  unwrap,\n  unwrapOr,\n  unwrapOrElse,\n  expect,\n  fromNullable,\n  fromPredicate,\n  normalizeError,\n  tryCatch,\n  tryCatchAsync,\n  fromPromise,\n  all,\n  allAsync,\n  collect,\n  collectAsync,\n  toMaybe: resultToMaybe,\n  fromMaybe: resultFromMaybe,\n  transpose: resultTranspose,\n} as const satisfies Record<string, (...args: never[]) => unknown>;\n\nexport { err, isErr, isNone, isOk, isSome, none, normalizeError, ok, some };\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/** A successful result containing a value of type `T`. */\nexport type OkResult<T> = {\n  readonly ok: true;\n  readonly value: T;\n};\n\n/** A failed result containing an error of type `E`. */\nexport type ErrResult<E extends Error = Error> = {\n  readonly ok: false;\n  readonly error: E;\n};\n\n/**\n * A value that is either a success (`OkResult<T>`) or a failure\n * (`ErrResult<E>`). Use `Result.ok` / `Result.err` to construct, and the\n * companion `Result.*` functions to transform.\n */\nexport type Result<T, E extends Error = Error> = OkResult<T> | ErrResult<E>;\n\ntype AnyResult = Result<unknown, Error>;\n\ntype ValueOf<R> = R extends OkResult<infer T> ? T : never;\ntype ErrorOf<R> = R extends ErrResult<infer E> ? E : never;\n\ntype TupleValues<R extends readonly AnyResult[]> = {\n  [K in keyof R]: ValueOf<R[K]>;\n};\ntype TupleErrors<R extends readonly AnyResult[]> = ErrorOf<R[number]>;\n\nfunction createOk<T>(value: T): OkResult<T> {\n  return Object.freeze({\n    ok: true as const,\n    value,\n  });\n}\n\nfunction ok(): OkResult<undefined>;\nfunction ok<T>(value: T): OkResult<T>;\nfunction ok<T>(...args: [] | [value: T]): OkResult<undefined> | OkResult<T> {\n  return args.length === 0 ? createOk(undefined) : createOk(args[0]);\n}\n\n/** Create a failed `Result` containing `error`. */\nfunction err<E extends Error>(error: E): ErrResult<E> {\n  return Object.freeze({\n    ok: false as const,\n    error,\n  });\n}\n\n/** Narrow a `Result` to `OkResult`. */\nfunction isOk<T, E extends Error>(result: Result<T, E>): result is OkResult<T> {\n  return result.ok;\n}\n\n/** Narrow a `Result` to `ErrResult`. */\nfunction isErr<T, E extends Error>(\n  result: Result<T, E>\n): result is ErrResult<E> {\n  return !result.ok;\n}\n\n/** Transform the value inside an `Ok`, leaving `Err` unchanged. */\nfunction map<T, U>(result: OkResult<T>, fn: (value: T) => U): OkResult<U>;\nfunction map<T, U, E extends Error>(\n  result: Result<T, E>,\n  fn: (value: T) => U\n): Result<U, E>;\nfunction map<T, U, E extends Error>(\n  result: Result<T, E>,\n  fn: (value: T) => U\n): Result<U, E> {\n  return result.ok ? ok(fn(result.value)) : result;\n}\n\n/** Transform the error inside an `Err`, leaving `Ok` unchanged. */\nfunction mapError<T>(\n  result: OkResult<T>,\n  fn: (error: never) => Error\n): OkResult<T>;\nfunction mapError<T, E extends Error, F extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => F\n): Result<T, F>;\nfunction mapError<T, E extends Error, F extends Error>(\n  result: OkResult<T> | Result<T, E>,\n  fn: ((error: never) => Error) | ((error: E) => F)\n): OkResult<T> | Result<T, F> {\n  return result.ok ? result : err((fn as (error: E) => F)(result.error));\n}\n\n/** Run a side-effect on the `Ok` value without transforming the result. */\nfunction inspect<T>(result: OkResult<T>, fn: (value: T) => void): OkResult<T>;\nfunction inspect<T, E extends Error>(\n  result: Result<T, E>,\n  fn: (value: T) => void\n): Result<T, E>;\nfunction inspect<T, E extends Error>(\n  result: Result<T, E>,\n  fn: (value: T) => void\n): Result<T, E> {\n  if (result.ok) fn(result.value);\n  return result;\n}\n\n/** Run a side-effect on the `Err` error without transforming the result. */\nfunction inspectError<E extends Error>(\n  result: ErrResult<E>,\n  fn: (error: E) => void\n): ErrResult<E>;\nfunction inspectError<T, E extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => void\n): Result<T, E>;\nfunction inspectError<T, E extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => void\n): Result<T, E> {\n  if (!result.ok) fn(result.error);\n  return result;\n}\n\n/** Chain a `Result`-returning function on the `Ok` value. */\nfunction flatMap<T, U, E extends Error, F extends Error = never>(\n  result: Result<T, E>,\n  fn: (value: T) => Result<U, F>\n): Result<U, E | F> {\n  if (result.ok) return fn(result.value);\n  return result;\n}\n\n/**\n * Recover from an error by applying `fn` to produce a new `Result`.\n * Alias: `flatMapErr`.\n */\nfunction orElse<T, E extends Error, F extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => Result<T, F>\n): Result<T, F> {\n  if (!result.ok) return fn(result.error);\n  return result;\n}\n\n/**\n * Recover from an error by applying `fn` to produce a new `Result`.\n * Alias for `orElse`.\n */\nfunction flatMapErr<T, E extends Error, F extends Error>(\n  result: Result<T, E>,\n  fn: (error: E) => Result<T, F>\n): Result<T, F> {\n  return orElse(result, fn);\n}\n\n/** Flatten a nested `Result<Result<T, E>, F>` into `Result<T, E | F>`. */\nfunction flatten<T, E extends Error, F extends Error>(\n  result: Result<Result<T, E>, F>\n): Result<T, E | F> {\n  return result.ok ? result.value : result;\n}\n\n/** Exhaustively handle both `Ok` and `Err` branches, returning `R`. */\nfunction match<T, E extends Error, R>(\n  result: Result<T, E>,\n  handlers: { ok: (value: T) => R; err: (error: E) => R }\n): R {\n  return result.ok ? handlers.ok(result.value) : handlers.err(result.error);\n}\n\n/** Compile-time exhaustiveness guard — only accepts `never`. */\nfunction exhaustive(value: never): never {\n  let detail: string;\n  try {\n    detail = JSON.stringify(value);\n  } catch {\n    detail = String(value);\n  }\n  throw new Error(`Unhandled result case: ${detail}`);\n}\n\n/** Return the `Ok` value or throw the contained error. */\nfunction unwrap<T, E extends Error>(result: Result<T, E>): T {\n  if (result.ok) return result.value;\n  throw result.error;\n}\n\n/**\n * Return the `Ok` value or `fallback`.\n *\n * The fallback must be the same type `T` as the success value.  This is\n * intentional — use `match` when you need a different return type.\n */\nfunction unwrapOr<T, E extends Error>(result: Result<T, E>, fallback: T): T {\n  return result.ok ? result.value : fallback;\n}\n\n/** Return the `Ok` value, or compute a fallback from `fn`. */\nfunction unwrapOrElse<T, E extends Error>(\n  result: Result<T, E>,\n  fn: () => T\n): T {\n  return result.ok ? result.value : fn();\n}\n\n/** Convert a nullable value to a `Result`. */\nfunction fromNullable<T, E extends Error>(\n  value: T | null | undefined,\n  errorFactory: () => E\n): Result<NonNullable<T>, E> {\n  return value != null ? ok(value) : err(errorFactory());\n}\n\n/** Convert a predicate check to a `Result`.  Supports type-guard predicates. */\nfunction fromPredicate<T, S extends T, E extends Error>(\n  value: T,\n  predicate: (value: T) => value is S,\n  errorFactory: () => E\n): Result<S, E>;\nfunction fromPredicate<T, E extends Error>(\n  value: T,\n  predicate: (value: T) => boolean,\n  errorFactory: () => E\n): Result<T, E>;\nfunction fromPredicate<T, E extends Error>(\n  value: T,\n  predicate: (value: T) => boolean,\n  errorFactory: () => E\n): Result<T, E> {\n  return predicate(value) ? ok(value) : err(errorFactory());\n}\n\n/** Convert an unknown thrown value to an `Error` instance. */\nfunction normalizeError(error: unknown): Error {\n  if (error instanceof Error) return error;\n  if (error === null || error === undefined) return new Error(String(error));\n  if (typeof error === \"object\") {\n    try {\n      const json = JSON.stringify(error);\n      if (json !== \"{}\") return new Error(json);\n      // JSON.stringify produced '{}' — likely RegExp or similar with no\n      // enumerable own properties. Fall through to String().\n    } catch {\n      // JSON.stringify throws on BigInt and circular references\n    }\n  }\n  try {\n    return new Error(String(error));\n  } catch {\n    return new Error(\"Non-stringifiable thrown value\");\n  }\n}\n\n/** Wrap a synchronous function that may throw into a `Result`. */\nfunction tryCatch<T>(fn: () => T): Result<T, Error>;\nfunction tryCatch<T, E extends Error>(\n  fn: () => T,\n  onError: (error: unknown) => E\n): Result<T, E>;\nfunction tryCatch<T, E extends Error>(\n  fn: () => T,\n  onError?: (error: unknown) => E\n): Result<T, E | Error> {\n  try {\n    return ok(fn());\n  } catch (error) {\n    try {\n      return err(onError ? onError(error) : normalizeError(error));\n    } catch (mapperError) {\n      return err(new Error(\"Error mapper threw\", { cause: mapperError }));\n    }\n  }\n}\n\n/** Wrap an asynchronous function that may reject into a `Result`. */\nfunction tryCatchAsync<T>(fn: () => Promise<T>): Promise<Result<T, Error>>;\nfunction tryCatchAsync<T, E extends Error>(\n  fn: () => Promise<T>,\n  onError: (error: unknown) => E\n): Promise<Result<T, E>>;\nasync function tryCatchAsync<T, E extends Error>(\n  fn: () => Promise<T>,\n  onError?: (error: unknown) => E\n): Promise<Result<T, E | Error>> {\n  try {\n    return ok(await fn());\n  } catch (error) {\n    try {\n      return err(onError ? onError(error) : normalizeError(error));\n    } catch (mapperError) {\n      return err(new Error(\"Error mapper threw\", { cause: mapperError }));\n    }\n  }\n}\n\n/** Wrap a `Promise` that may reject into a `Result`. */\nfunction fromPromise<T>(promise: Promise<T>): Promise<Result<T, Error>>;\nfunction fromPromise<T, E extends Error>(\n  promise: Promise<T>,\n  onError: (error: unknown) => E\n): Promise<Result<T, E>>;\nasync function fromPromise<T, E extends Error>(\n  promise: Promise<T>,\n  onError?: (error: unknown) => E\n): Promise<Result<T, E | Error>> {\n  try {\n    return ok(await promise);\n  } catch (error) {\n    try {\n      return err(onError ? onError(error) : normalizeError(error));\n    } catch (mapperError) {\n      return err(new Error(\"Error mapper threw\", { cause: mapperError }));\n    }\n  }\n}\n\n/**\n * Combine multiple `Result`s into a single `Result` containing a tuple of\n * values.  Returns the first `Err` encountered (fail-fast).\n *\n * Pass results as individual arguments — spreading an array loses tuple\n * inference and degrades value types to `unknown[]`.\n */\nfunction all<const R extends readonly AnyResult[]>(\n  ...results: R\n): Result<TupleValues<R>, TupleErrors<R>> {\n  const values: unknown[] = [];\n  for (const result of results) {\n    if (!result.ok) return err(result.error) as ErrResult<TupleErrors<R>>;\n    values.push(result.value);\n  }\n  return ok(values) as OkResult<TupleValues<R>>;\n}\n\n/**\n * Like `all`, but accepts promises of `Result`s.  All promises are resolved\n * concurrently via `Promise.allSettled` before checking for errors.\n *\n * Promises are expected to resolve to `Result`s — not reject.  If a promise\n * does reject, the rejection is caught and wrapped as an `Err`.\n *\n * @breaking v0.2 — Uses `Promise.allSettled` instead of `Promise.all`. All\n * promises are now always awaited to completion; the first error found during\n * iteration is returned.\n */\nasync function allAsync<const R extends readonly Promise<AnyResult>[]>(\n  ...promises: R\n): Promise<\n  Result<\n    { [K in keyof R]: ValueOf<Awaited<R[K]>> },\n    ErrorOf<Awaited<R[number]>> | Error\n  >\n> {\n  type Values = { [K in keyof R]: ValueOf<Awaited<R[K]>> };\n  type Errors = ErrorOf<Awaited<R[number]>> | Error;\n\n  const settled = await Promise.allSettled(promises);\n  const values: unknown[] = [];\n  for (const s of settled) {\n    if (s.status === \"rejected\") {\n      return err(normalizeError(s.reason)) as ErrResult<Errors>;\n    }\n    if (!s.value.ok) {\n      return err(s.value.error) as ErrResult<Errors>;\n    }\n    values.push(s.value.value);\n  }\n  return ok(values) as OkResult<Values>;\n}\n\n/**\n * Like `collect`, but for promises of `Result`s.  Resolves all promises\n * via `Promise.allSettled`, then collects all errors.  Returns an\n * `AggregateError` containing every error found.\n */\nasync function collectAsync<const R extends readonly Promise<AnyResult>[]>(\n  ...promises: R\n): Promise<Result<{ [K in keyof R]: ValueOf<Awaited<R[K]>> }, AggregateError>> {\n  type Values = { [K in keyof R]: ValueOf<Awaited<R[K]>> };\n\n  const settled = await Promise.allSettled(promises);\n  const values: unknown[] = [];\n  const errors: Error[] = [];\n  for (const s of settled) {\n    if (s.status === \"rejected\") {\n      errors.push(normalizeError(s.reason));\n    } else if (!s.value.ok) {\n      errors.push(s.value.error);\n    } else {\n      values.push(s.value.value);\n    }\n  }\n  if (errors.length > 0)\n    return err(new AggregateError(errors)) as ErrResult<AggregateError>;\n  return ok(values) as OkResult<Values>;\n}\n\n/**\n * Combine multiple `Result`s, collecting **all** errors instead of\n * short-circuiting on the first one.  Returns an `AggregateError` whose\n * `.errors` array contains every individual error.\n */\nfunction collect<const R extends readonly AnyResult[]>(\n  ...results: R\n): Result<TupleValues<R>, AggregateError> {\n  const values: unknown[] = [];\n  const errors: Error[] = [];\n  for (const result of results) {\n    if (result.ok) values.push(result.value);\n    else errors.push(result.error);\n  }\n  if (errors.length > 0)\n    return err(new AggregateError(errors)) as ErrResult<AggregateError>;\n  return ok(values) as OkResult<TupleValues<R>>;\n}\n\n// ===========================================================================\n// Maybe\n// ===========================================================================\n\n/** A `Maybe` that contains a value of type `T`. */\nexport type Some<T> = {\n  readonly some: true;\n  readonly value: T;\n};\n\n/** A `Maybe` that contains no value. */\nexport type None = {\n  readonly some: false;\n};\n\n/**\n * A value that is either present (`Some<T>`) or absent (`None`).\n * Use `Maybe.some` / `Maybe.none` to construct, and the companion `Maybe.*`\n * functions to transform.\n */\nexport type Maybe<T> = Some<T> | None;\n\ntype AnyMaybe = Maybe<unknown>;\n\ntype MaybeValueOf<M> = M extends Some<infer T> ? T : never;\n\ntype TupleMaybeValues<M extends readonly AnyMaybe[]> = {\n  [K in keyof M]: MaybeValueOf<M[K]>;\n};\n\n/** Create a `Maybe` containing `value`. */\nfunction some<T>(value: T): Some<T> {\n  return Object.freeze({\n    some: true as const,\n    value,\n  });\n}\n\nconst NONE: None = Object.freeze({\n  some: false as const,\n});\n\n/** Create an empty `Maybe`. */\nfunction none(): None {\n  return NONE;\n}\n\n/** Narrow a `Maybe` to `Some`. */\nfunction isSome<T>(maybe: Maybe<T>): maybe is Some<T> {\n  return maybe.some;\n}\n\n/** Narrow a `Maybe` to `None`. */\nfunction isNone<T>(maybe: Maybe<T>): maybe is None {\n  return !maybe.some;\n}\n\n/** Transform the value inside a `Some`, leaving `None` unchanged. */\nfunction maybeMap<T, U>(maybe: Some<T>, fn: (value: T) => U): Some<U>;\nfunction maybeMap<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nfunction maybeMap<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> {\n  return maybe.some ? some(fn(maybe.value)) : NONE;\n}\n\n/** Chain a `Maybe`-returning function on the `Some` value. */\nfunction maybeFlatMap<T, U>(\n  maybe: Maybe<T>,\n  fn: (value: T) => Maybe<U>\n): Maybe<U> {\n  return maybe.some ? fn(maybe.value) : NONE;\n}\n\n/** Flatten a nested `Maybe<Maybe<T>>` into `Maybe<T>`. */\nfunction maybeFlatten<T>(maybe: Maybe<Maybe<T>>): Maybe<T> {\n  return maybe.some ? maybe.value : NONE;\n}\n\n/** Keep the `Some` value only if `predicate` returns true. */\nfunction maybeFilter<T, S extends T>(\n  maybe: Maybe<T>,\n  predicate: (value: T) => value is S\n): Maybe<S>;\nfunction maybeFilter<T>(\n  maybe: Maybe<T>,\n  predicate: (value: T) => boolean\n): Maybe<T>;\nfunction maybeFilter<T>(\n  maybe: Maybe<T>,\n  predicate: (value: T) => boolean\n): Maybe<T> {\n  return maybe.some && predicate(maybe.value) ? maybe : NONE;\n}\n\n/** Run a side-effect on the `Some` value without transforming the maybe. */\nfunction maybeInspect<T>(maybe: Some<T>, fn: (value: T) => void): Some<T>;\nfunction maybeInspect<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nfunction maybeInspect<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> {\n  if (maybe.some) fn(maybe.value);\n  return maybe;\n}\n\n/** Exhaustively handle both `Some` and `None` branches, returning `R`. */\nfunction maybeMatch<T, R>(\n  maybe: Maybe<T>,\n  handlers: { some: (value: T) => R; none: () => R }\n): R {\n  return maybe.some ? handlers.some(maybe.value) : handlers.none();\n}\n\n/** Return the `Some` value or throw. */\nfunction maybeUnwrap<T>(maybe: Maybe<T>): T {\n  if (maybe.some) return maybe.value;\n  throw new Error(\"Called unwrap on None\");\n}\n\n/**\n * Return the `Some` value or `fallback`.\n *\n * The fallback must be the same type `T` as the contained value.  This is\n * intentional — use `match` when you need a different return type.\n */\nfunction maybeUnwrapOr<T>(maybe: Maybe<T>, fallback: T): T {\n  return maybe.some ? maybe.value : fallback;\n}\n\n/** Return the `Some` value, or compute a fallback from `fn`. */\nfunction maybeUnwrapOrElse<T>(maybe: Maybe<T>, fn: () => T): T {\n  return maybe.some ? maybe.value : fn();\n}\n\n/** Convert a nullable value to a `Maybe`. */\nfunction maybeFromNullable<T>(\n  value: T | null | undefined\n): Maybe<NonNullable<T>> {\n  return value != null ? some(value) : NONE;\n}\n\n/** Convert a predicate check to a `Maybe`.  Supports type-guard predicates. */\nfunction maybeFromPredicate<T, S extends T>(\n  value: T,\n  predicate: (value: T) => value is S\n): Maybe<S>;\nfunction maybeFromPredicate<T>(\n  value: T,\n  predicate: (value: T) => boolean\n): Maybe<T>;\nfunction maybeFromPredicate<T>(\n  value: T,\n  predicate: (value: T) => boolean\n): Maybe<T> {\n  return predicate(value) ? some(value) : NONE;\n}\n\n/**\n * Combine multiple `Maybe`s into a single `Maybe` containing a tuple of\n * values.  Returns `None` if any input is `None` (fail-fast).\n *\n * Pass maybes as individual arguments — spreading an array loses tuple\n * inference and degrades value types to `unknown[]`.\n */\nfunction maybeAll<const M extends readonly AnyMaybe[]>(\n  ...maybes: M\n): Maybe<TupleMaybeValues<M>> {\n  const values: unknown[] = [];\n  for (const m of maybes) {\n    if (!m.some) return NONE;\n    values.push(m.value);\n  }\n  return some(values) as Some<TupleMaybeValues<M>>;\n}\n\n/** Return the first `Some` found, or `None` if all are `None`. */\nfunction maybeFirstSome<T>(...maybes: Maybe<T>[]): Maybe<T> {\n  for (const m of maybes) {\n    if (m.some) return m;\n  }\n  return NONE;\n}\n\n/** Like `all`, but for promises of `Maybe`s.  Resolves all promises\n *  concurrently via `Promise.allSettled`. */\nasync function maybeAllAsync<const M extends readonly Promise<AnyMaybe>[]>(\n  ...promises: M\n): Promise<Maybe<{ [K in keyof M]: MaybeValueOf<Awaited<M[K]>> }>> {\n  type Values = { [K in keyof M]: MaybeValueOf<Awaited<M[K]>> };\n\n  const settled = await Promise.allSettled(promises);\n  const values: unknown[] = [];\n  for (const s of settled) {\n    if (s.status === \"rejected\") return NONE;\n    if (!s.value.some) return NONE;\n    values.push(s.value.value);\n  }\n  return some(values) as Some<Values>;\n}\n\n/** Combine multiple `Maybe's, returning `None` if any is `None`.\n * Same as `all` — `None` carries no error data to collect,\n * unlike `Result.collect` which gathers all errors.\n */\nconst maybeCollect = maybeAll;\n\n// ---------------------------------------------------------------------------\n// Maybe <-> Result interop\n// ---------------------------------------------------------------------------\n\n/** Convert a `Maybe` to a `Result`, calling `errorFactory` only when `None`.\n *\n * @breaking v0.2 — The second argument changed from `error: E` to\n * `errorFactory: () => E`. The factory is only called when the Maybe is\n * None, avoiding unnecessary error construction for Some.\n */\nfunction maybeToResult<T, E extends Error>(\n  maybe: Maybe<T>,\n  errorFactory: () => E\n): Result<T, E> {\n  return maybe.some ? ok(maybe.value) : err(errorFactory());\n}\n\n/** Convert a `Result` to a `Maybe`, discarding the error. */\nfunction maybeFromResult<T, E extends Error>(result: Result<T, E>): Maybe<T> {\n  return result.ok ? some(result.value) : NONE;\n}\n\n/** Convert a `Result` to a `Maybe`, discarding the error. */\nfunction resultToMaybe<T, E extends Error>(result: Result<T, E>): Maybe<T> {\n  return maybeFromResult(result);\n}\n\n/** Convert a `Maybe` to a `Result`, calling `errorFactory` only when `None`.\n * Alias for `maybeToResult`.\n *\n * @breaking v0.2 — The second argument changed from `error: E` to\n * `errorFactory: () => E`.\n */\nfunction resultFromMaybe<T, E extends Error>(\n  maybe: Maybe<T>,\n  errorFactory: () => E\n): Result<T, E> {\n  return maybeToResult(maybe, errorFactory);\n}\n\n/** Convert a `Result<Maybe<T>, E>` to `Maybe<Result<T, E>>`. */\nfunction resultTranspose<T, E extends Error>(\n  result: Result<Maybe<T>, E>\n): Maybe<Result<T, E>> {\n  if (!result.ok) return some(result);\n  if (result.value.some) return some(ok(result.value.value));\n  return NONE;\n}\n\n/** Convert a `Maybe<Result<T, E>>` to `Result<Maybe<T>, E>`. */\nfunction maybeTranspose<T, E extends Error>(\n  maybe: Maybe<Result<T, E>>\n): Result<Maybe<T>, E> {\n  if (!maybe.some) return ok(NONE);\n  if (maybe.value.ok) return ok(some(maybe.value.value));\n  return err(maybe.value.error);\n}\n\nexport const Maybe = {\n  some,\n  none,\n  isSome,\n  isNone,\n  map: maybeMap,\n  flatMap: maybeFlatMap,\n  flatten: maybeFlatten,\n  filter: maybeFilter,\n  inspect: maybeInspect,\n  match: maybeMatch,\n  unwrap: maybeUnwrap,\n  unwrapOr: maybeUnwrapOr,\n  unwrapOrElse: maybeUnwrapOrElse,\n  fromNullable: maybeFromNullable,\n  fromPredicate: maybeFromPredicate,\n  all: maybeAll,\n  allAsync: maybeAllAsync,\n  collect: maybeCollect,\n  firstSome: maybeFirstSome,\n  toResult: maybeToResult,\n  fromResult: maybeFromResult,\n  transpose: maybeTranspose,\n  // `as const` without `satisfies Record<string, Function>`: the namespace is a\n  // small, static, hand-maintained list of named function references — the\n  // function-only invariant is obvious from inspection and enforced by code\n  // review. Adding `satisfies` would guard a near-zero-probability mistake that\n  // TypeScript would catch at every call site anyway, for no consumer benefit.\n} as const;\n\n// Add interop to Result namespace\nexport const Result = {\n  ok,\n  err,\n  isOk,\n  isErr,\n  map,\n  mapError,\n  inspect,\n  inspectError,\n  flatMap,\n  flatMapErr,\n  orElse,\n  flatten,\n  match,\n  exhaustive,\n  unwrap,\n  unwrapOr,\n  unwrapOrElse,\n  fromNullable,\n  fromPredicate,\n  normalizeError,\n  tryCatch,\n  tryCatchAsync,\n  fromPromise,\n  all,\n  allAsync,\n  collect,\n  collectAsync,\n  toMaybe: resultToMaybe,\n  fromMaybe: resultFromMaybe,\n  transpose: resultTranspose,\n  // See comment on Maybe above.\n} as const;\n\nexport { err, isErr, isNone, isOk, isSome, none, normalizeError, ok, some };\n"],"mappings":"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","names":[]}