@semyonf/kamchazky 1.0.0 → 1.1.0

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

@@ -353,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,
@@ -385,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};\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;\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} as const;\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":[]}

package/dist/index.js

@@ -319,6 +319,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,
@@ -351,6 +356,7 @@ var Result = {
   toMaybe: resultToMaybe,
   fromMaybe: resultFromMaybe,
   transpose: resultTranspose
+  // See comment on Maybe above.
 };
 export {
   Maybe,

package/dist/index.js.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};\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;\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} as const;\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":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semyonf/kamchazky",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "author": "Semyón <taxnuke@gmail.com>",
   "homepage": "https://github.com/semyonf/kamchazky#readme",
   "bugs": {
@@ -21,6 +21,16 @@
         "types": "./dist/index.d.cts",
         "default": "./dist/index.cjs"
       }
+    },
+    "./eslint": {
+      "import": {
+        "types": "./dist/eslint.d.ts",
+        "default": "./dist/eslint.js"
+      },
+      "require": {
+        "types": "./dist/eslint.d.cts",
+        "default": "./dist/eslint.cjs"
+      }
     }
   },
   "files": [
@@ -58,6 +68,18 @@
   "publishConfig": {
     "access": "public"
   },
+  "peerDependencies": {
+    "@typescript-eslint/utils": ">=8.0.0",
+    "typescript": ">=4.8.4"
+  },
+  "peerDependenciesMeta": {
+    "@typescript-eslint/utils": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    }
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/semyonf/kamchazky.git"
@@ -67,6 +89,11 @@
     "@changesets/cli": "^2.31.0",
     "@tsconfig/node20": "20.1.9",
     "@tsconfig/strictest": "2.0.8",
+    "@types/node": "^20.19.43",
+    "@typescript-eslint/parser": "8.62.1",
+    "@typescript-eslint/rule-tester": "8.62.1",
+    "@typescript-eslint/utils": "8.62.1",
+    "eslint": "9.31.0",
     "tsup": "8.0.0",
     "typescript": "5.9.3",
     "vitest": "3.0.0"