@semyonf/kamchazky 0.2.0 → 1.0.0

package/README.md

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

package/dist/index.cjs

@@ -33,55 +33,20 @@ __export(src_exports, {
   some: () => some
 });
 module.exports = __toCommonJS(src_exports);
-function ok(value) {
-  const self = Object.freeze({
+function createOk(value) {
+  return Object.freeze({
     ok: true,
-    value,
-    map: (fn) => ok(fn(value)),
-    flatMap: (fn) => fn(value),
-    mapError: (_fn) => self,
-    inspect: (fn) => {
-      fn(value);
-      return self;
-    },
-    inspectError: (_fn) => self,
-    match: (handlers) => handlers.ok(value),
-    unwrap: () => value,
-    unwrapOr: (_fallback) => value,
-    unwrapOrElse: (_fn) => value,
-    expect: (_message) => value
+    value
   });
-  return self;
+}
+function ok(...args) {
+  return args.length === 0 ? createOk(void 0) : createOk(args[0]);
 }
 function err(error) {
-  const self = Object.freeze({
+  return Object.freeze({
     ok: false,
-    error,
-    map: (_fn) => self,
-    flatMap: (_fn) => self,
-    mapError: (fn) => err(fn(error)),
-    inspect: (_fn) => self,
-    inspectError: (fn) => {
-      fn(error);
-      return self;
-    },
-    match: (handlers) => handlers.err(error),
-    unwrap: () => {
-      throw error;
-    },
-    unwrapOr: (fallback) => fallback,
-    unwrapOrElse: (fn) => fn(),
-    expect: (message) => {
-      const thrown = new Error(`${message}: ${error.message}`, {
-        cause: error
-      });
-      Object.setPrototypeOf(thrown, error.constructor.prototype);
-      if (error.stack !== void 0)
-        thrown.stack = error.stack;
-      throw thrown;
-    }
+    error
   });
-  return self;
 }
 function isOk(result) {
   return result.ok;
@@ -144,17 +109,6 @@ function unwrapOr(result, fallback) {
 function unwrapOrElse(result, fn) {
   return result.ok ? result.value : fn();
 }
-function expect(result, message) {
-  if (result.ok)
-    return result.value;
-  const thrown = new Error(`${message}: ${result.error.message}`, {
-    cause: result.error
-  });
-  Object.setPrototypeOf(thrown, result.error.constructor.prototype);
-  if (result.error.stack !== void 0)
-    thrown.stack = result.error.stack;
-  throw thrown;
-}
 function fromNullable(value, errorFactory) {
   return value != null ? ok(value) : err(errorFactory());
 }
@@ -267,39 +221,13 @@ function collect(...results) {
   return ok(values);
 }
 function some(value) {
-  const self = Object.freeze({
+  return Object.freeze({
     some: true,
-    value,
-    map: (fn) => some(fn(value)),
-    flatMap: (fn) => fn(value),
-    filter: (predicate) => predicate(value) ? self : NONE,
-    inspect: (fn) => {
-      fn(value);
-      return self;
-    },
-    match: (handlers) => handlers.some(value),
-    unwrap: () => value,
-    expect: (_message) => value,
-    unwrapOr: (_fallback) => value,
-    unwrapOrElse: (_fn) => value
+    value
   });
-  return self;
 }
 var NONE = Object.freeze({
-  some: false,
-  map: (_fn) => NONE,
-  flatMap: (_fn) => NONE,
-  filter: (_predicate) => NONE,
-  inspect: (_fn) => NONE,
-  match: (handlers) => handlers.none(),
-  unwrap: () => {
-    throw new Error("Called unwrap on None");
-  },
-  expect: (message) => {
-    throw new Error(message);
-  },
-  unwrapOr: (fallback) => fallback,
-  unwrapOrElse: (fn) => fn()
+  some: false
 });
 function none() {
   return NONE;
@@ -341,11 +269,6 @@ function maybeUnwrapOr(maybe, fallback) {
 function maybeUnwrapOrElse(maybe, fn) {
   return maybe.some ? maybe.value : fn();
 }
-function maybeExpect(maybe, message) {
-  if (maybe.some)
-    return maybe.value;
-  throw new Error(message);
-}
 function maybeFromNullable(value) {
   return value != null ? some(value) : NONE;
 }
@@ -421,7 +344,6 @@ var Maybe = {
   unwrap: maybeUnwrap,
   unwrapOr: maybeUnwrapOr,
   unwrapOrElse: maybeUnwrapOrElse,
-  expect: maybeExpect,
   fromNullable: maybeFromNullable,
   fromPredicate: maybeFromPredicate,
   all: maybeAll,
@@ -450,7 +372,6 @@ var Result = {
   unwrap,
   unwrapOr,
   unwrapOrElse,
-  expect,
   fromNullable,
   fromPredicate,
   normalizeError,

package/dist/index.cjs.map

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

package/dist/index.d.cts

@@ -2,37 +2,11 @@
 type OkResult<T> = {
     readonly ok: true;
     readonly value: T;
-    map<U>(fn: (value: T) => U): OkResult<U>;
-    flatMap<U, F extends Error = never>(fn: (value: T) => Result<U, F>): Result<U, F>;
-    mapError<F extends Error>(fn: (error: never) => F): OkResult<T>;
-    inspect(fn: (value: T) => void): OkResult<T>;
-    inspectError(fn: (error: never) => void): OkResult<T>;
-    match<R>(handlers: {
-        ok: (value: T) => R;
-        err: (error: never) => R;
-    }): R;
-    unwrap(): T;
-    unwrapOr(fallback: T): T;
-    unwrapOrElse(fn: () => T): T;
-    expect(message: string): T;
 };
 /** A failed result containing an error of type `E`. */
 type ErrResult<E extends Error = Error> = {
     readonly ok: false;
     readonly error: E;
-    map<U>(fn: (value: never) => U): ErrResult<E>;
-    flatMap<U, F extends Error = never>(fn: (value: never) => Result<U, F>): ErrResult<E>;
-    mapError<F extends Error>(fn: (error: E) => F): ErrResult<F>;
-    inspect(fn: (value: never) => void): ErrResult<E>;
-    inspectError(fn: (error: E) => void): ErrResult<E>;
-    match<R>(handlers: {
-        ok: (value: never) => R;
-        err: (error: E) => R;
-    }): R;
-    unwrap(): never;
-    unwrapOr<T>(fallback: T): T;
-    unwrapOrElse<T>(fn: () => T): T;
-    expect(message: string): never;
 };
 type AnyResult = Result<unknown, Error>;
 type ValueOf<R> = R extends OkResult<infer T> ? T : never;
@@ -41,7 +15,7 @@ type TupleValues<R extends readonly AnyResult[]> = {
     [K in keyof R]: ValueOf<R[K]>;
 };
 type TupleErrors<R extends readonly AnyResult[]> = ErrorOf<R[number]>;
-/** Create a successful `Result` containing `value`. */
+declare function ok(): OkResult<undefined>;
 declare function ok<T>(value: T): OkResult<T>;
 /** Create a failed `Result` containing `error`. */
 declare function err<E extends Error>(error: E): ErrResult<E>;
@@ -93,8 +67,6 @@ declare function unwrap<T, E extends Error>(result: Result<T, E>): T;
 declare function unwrapOr<T, E extends Error>(result: Result<T, E>, fallback: T): T;
 /** Return the `Ok` value, or compute a fallback from `fn`. */
 declare function unwrapOrElse<T, E extends Error>(result: Result<T, E>, fn: () => T): T;
-/** Return the `Ok` value or throw with a custom `message`. */
-declare function expect<T, E extends Error>(result: Result<T, E>, message: string): T;
 /** Convert a nullable value to a `Result`. */
 declare function fromNullable<T, E extends Error>(value: T | null | undefined, errorFactory: () => E): Result<NonNullable<T>, E>;
 /** Convert a predicate check to a `Result`.  Supports type-guard predicates. */
@@ -151,34 +123,10 @@ declare function collect<const R extends readonly AnyResult[]>(...results: R): R
 type Some<T> = {
     readonly some: true;
     readonly value: T;
-    map<U>(fn: (value: T) => U): Some<U>;
-    flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U>;
-    filter(predicate: (value: T) => boolean): Maybe<T>;
-    inspect(fn: (value: T) => void): Some<T>;
-    match<R>(handlers: {
-        some: (value: T) => R;
-        none: () => R;
-    }): R;
-    unwrap(): T;
-    expect(message: string): T;
-    unwrapOr(fallback: T): T;
-    unwrapOrElse(fn: () => T): T;
 };
 /** A `Maybe` that contains no value. */
 type None = {
     readonly some: false;
-    map<U>(fn: (value: never) => U): None;
-    flatMap<U>(fn: (value: never) => Maybe<U>): None;
-    filter(predicate: (value: never) => boolean): None;
-    inspect(fn: (value: never) => void): None;
-    match<R>(handlers: {
-        some: (value: never) => R;
-        none: () => R;
-    }): R;
-    unwrap(): never;
-    expect(message: string): never;
-    unwrapOr<T>(fallback: T): T;
-    unwrapOrElse<T>(fn: () => T): T;
 };
 type AnyMaybe = Maybe<unknown>;
 type MaybeValueOf<M> = M extends Some<infer T> ? T : never;
@@ -222,8 +170,6 @@ declare function maybeUnwrap<T>(maybe: Maybe<T>): T;
 declare function maybeUnwrapOr<T>(maybe: Maybe<T>, fallback: T): T;
 /** Return the `Some` value, or compute a fallback from `fn`. */
 declare function maybeUnwrapOrElse<T>(maybe: Maybe<T>, fn: () => T): T;
-/** Return the `Some` value or throw with a custom `message`. */
-declare function maybeExpect<T>(maybe: Maybe<T>, message: string): T;
 /** Convert a nullable value to a `Maybe`. */
 declare function maybeFromNullable<T>(value: T | null | undefined): Maybe<NonNullable<T>>;
 /** Convert a predicate check to a `Maybe`.  Supports type-guard predicates. */
@@ -269,7 +215,7 @@ declare function maybeTranspose<T, E extends Error>(maybe: Maybe<Result<T, E>>):
 /**
  * A value that is either present (`Some<T>`) or absent (`None`).
  * Use `Maybe.some` / `Maybe.none` to construct, and the companion `Maybe.*`
- * functions or instance methods to transform.
+ * functions to transform.
  */
 type Maybe<T> = Some<T> | None;
 declare const Maybe: {
@@ -286,7 +232,6 @@ declare const Maybe: {
     readonly unwrap: typeof maybeUnwrap;
     readonly unwrapOr: typeof maybeUnwrapOr;
     readonly unwrapOrElse: typeof maybeUnwrapOrElse;
-    readonly expect: typeof maybeExpect;
     readonly fromNullable: typeof maybeFromNullable;
     readonly fromPredicate: typeof maybeFromPredicate;
     readonly all: typeof maybeAll;
@@ -299,8 +244,8 @@ declare const Maybe: {
 };
 /**
  * A value that is either a success (`OkResult<T>`) or a failure
- * (`ErrResult<E>`).  Use `Result.ok` / `Result.err` to construct, and the
- * companion `Result.*` functions or instance methods to transform.
+ * (`ErrResult<E>`). Use `Result.ok` / `Result.err` to construct, and the
+ * companion `Result.*` functions to transform.
  */
 type Result<T, E extends Error = Error> = OkResult<T> | ErrResult<E>;
 declare const Result: {
@@ -321,7 +266,6 @@ declare const Result: {
     readonly unwrap: typeof unwrap;
     readonly unwrapOr: typeof unwrapOr;
     readonly unwrapOrElse: typeof unwrapOrElse;
-    readonly expect: typeof expect;
     readonly fromNullable: typeof fromNullable;
     readonly fromPredicate: typeof fromPredicate;
     readonly normalizeError: typeof normalizeError;

package/dist/index.d.ts

@@ -2,37 +2,11 @@
 type OkResult<T> = {
     readonly ok: true;
     readonly value: T;
-    map<U>(fn: (value: T) => U): OkResult<U>;
-    flatMap<U, F extends Error = never>(fn: (value: T) => Result<U, F>): Result<U, F>;
-    mapError<F extends Error>(fn: (error: never) => F): OkResult<T>;
-    inspect(fn: (value: T) => void): OkResult<T>;
-    inspectError(fn: (error: never) => void): OkResult<T>;
-    match<R>(handlers: {
-        ok: (value: T) => R;
-        err: (error: never) => R;
-    }): R;
-    unwrap(): T;
-    unwrapOr(fallback: T): T;
-    unwrapOrElse(fn: () => T): T;
-    expect(message: string): T;
 };
 /** A failed result containing an error of type `E`. */
 type ErrResult<E extends Error = Error> = {
     readonly ok: false;
     readonly error: E;
-    map<U>(fn: (value: never) => U): ErrResult<E>;
-    flatMap<U, F extends Error = never>(fn: (value: never) => Result<U, F>): ErrResult<E>;
-    mapError<F extends Error>(fn: (error: E) => F): ErrResult<F>;
-    inspect(fn: (value: never) => void): ErrResult<E>;
-    inspectError(fn: (error: E) => void): ErrResult<E>;
-    match<R>(handlers: {
-        ok: (value: never) => R;
-        err: (error: E) => R;
-    }): R;
-    unwrap(): never;
-    unwrapOr<T>(fallback: T): T;
-    unwrapOrElse<T>(fn: () => T): T;
-    expect(message: string): never;
 };
 type AnyResult = Result<unknown, Error>;
 type ValueOf<R> = R extends OkResult<infer T> ? T : never;
@@ -41,7 +15,7 @@ type TupleValues<R extends readonly AnyResult[]> = {
     [K in keyof R]: ValueOf<R[K]>;
 };
 type TupleErrors<R extends readonly AnyResult[]> = ErrorOf<R[number]>;
-/** Create a successful `Result` containing `value`. */
+declare function ok(): OkResult<undefined>;
 declare function ok<T>(value: T): OkResult<T>;
 /** Create a failed `Result` containing `error`. */
 declare function err<E extends Error>(error: E): ErrResult<E>;
@@ -93,8 +67,6 @@ declare function unwrap<T, E extends Error>(result: Result<T, E>): T;
 declare function unwrapOr<T, E extends Error>(result: Result<T, E>, fallback: T): T;
 /** Return the `Ok` value, or compute a fallback from `fn`. */
 declare function unwrapOrElse<T, E extends Error>(result: Result<T, E>, fn: () => T): T;
-/** Return the `Ok` value or throw with a custom `message`. */
-declare function expect<T, E extends Error>(result: Result<T, E>, message: string): T;
 /** Convert a nullable value to a `Result`. */
 declare function fromNullable<T, E extends Error>(value: T | null | undefined, errorFactory: () => E): Result<NonNullable<T>, E>;
 /** Convert a predicate check to a `Result`.  Supports type-guard predicates. */
@@ -151,34 +123,10 @@ declare function collect<const R extends readonly AnyResult[]>(...results: R): R
 type Some<T> = {
     readonly some: true;
     readonly value: T;
-    map<U>(fn: (value: T) => U): Some<U>;
-    flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U>;
-    filter(predicate: (value: T) => boolean): Maybe<T>;
-    inspect(fn: (value: T) => void): Some<T>;
-    match<R>(handlers: {
-        some: (value: T) => R;
-        none: () => R;
-    }): R;
-    unwrap(): T;
-    expect(message: string): T;
-    unwrapOr(fallback: T): T;
-    unwrapOrElse(fn: () => T): T;
 };
 /** A `Maybe` that contains no value. */
 type None = {
     readonly some: false;
-    map<U>(fn: (value: never) => U): None;
-    flatMap<U>(fn: (value: never) => Maybe<U>): None;
-    filter(predicate: (value: never) => boolean): None;
-    inspect(fn: (value: never) => void): None;
-    match<R>(handlers: {
-        some: (value: never) => R;
-        none: () => R;
-    }): R;
-    unwrap(): never;
-    expect(message: string): never;
-    unwrapOr<T>(fallback: T): T;
-    unwrapOrElse<T>(fn: () => T): T;
 };
 type AnyMaybe = Maybe<unknown>;
 type MaybeValueOf<M> = M extends Some<infer T> ? T : never;
@@ -222,8 +170,6 @@ declare function maybeUnwrap<T>(maybe: Maybe<T>): T;
 declare function maybeUnwrapOr<T>(maybe: Maybe<T>, fallback: T): T;
 /** Return the `Some` value, or compute a fallback from `fn`. */
 declare function maybeUnwrapOrElse<T>(maybe: Maybe<T>, fn: () => T): T;
-/** Return the `Some` value or throw with a custom `message`. */
-declare function maybeExpect<T>(maybe: Maybe<T>, message: string): T;
 /** Convert a nullable value to a `Maybe`. */
 declare function maybeFromNullable<T>(value: T | null | undefined): Maybe<NonNullable<T>>;
 /** Convert a predicate check to a `Maybe`.  Supports type-guard predicates. */
@@ -269,7 +215,7 @@ declare function maybeTranspose<T, E extends Error>(maybe: Maybe<Result<T, E>>):
 /**
  * A value that is either present (`Some<T>`) or absent (`None`).
  * Use `Maybe.some` / `Maybe.none` to construct, and the companion `Maybe.*`
- * functions or instance methods to transform.
+ * functions to transform.
  */
 type Maybe<T> = Some<T> | None;
 declare const Maybe: {
@@ -286,7 +232,6 @@ declare const Maybe: {
     readonly unwrap: typeof maybeUnwrap;
     readonly unwrapOr: typeof maybeUnwrapOr;
     readonly unwrapOrElse: typeof maybeUnwrapOrElse;
-    readonly expect: typeof maybeExpect;
     readonly fromNullable: typeof maybeFromNullable;
     readonly fromPredicate: typeof maybeFromPredicate;
     readonly all: typeof maybeAll;
@@ -299,8 +244,8 @@ declare const Maybe: {
 };
 /**
  * A value that is either a success (`OkResult<T>`) or a failure
- * (`ErrResult<E>`).  Use `Result.ok` / `Result.err` to construct, and the
- * companion `Result.*` functions or instance methods to transform.
+ * (`ErrResult<E>`). Use `Result.ok` / `Result.err` to construct, and the
+ * companion `Result.*` functions to transform.
  */
 type Result<T, E extends Error = Error> = OkResult<T> | ErrResult<E>;
 declare const Result: {
@@ -321,7 +266,6 @@ declare const Result: {
     readonly unwrap: typeof unwrap;
     readonly unwrapOr: typeof unwrapOr;
     readonly unwrapOrElse: typeof unwrapOrElse;
-    readonly expect: typeof expect;
     readonly fromNullable: typeof fromNullable;
     readonly fromPredicate: typeof fromPredicate;
     readonly normalizeError: typeof normalizeError;

package/dist/index.js

@@ -1,53 +1,18 @@
 // src/index.ts
-function ok(value) {
-  const self = Object.freeze({
+function createOk(value) {
+  return Object.freeze({
     ok: true,
-    value,
-    map: (fn) => ok(fn(value)),
-    flatMap: (fn) => fn(value),
-    mapError: (_fn) => self,
-    inspect: (fn) => {
-      fn(value);
-      return self;
-    },
-    inspectError: (_fn) => self,
-    match: (handlers) => handlers.ok(value),
-    unwrap: () => value,
-    unwrapOr: (_fallback) => value,
-    unwrapOrElse: (_fn) => value,
-    expect: (_message) => value
+    value
   });
-  return self;
+}
+function ok(...args) {
+  return args.length === 0 ? createOk(void 0) : createOk(args[0]);
 }
 function err(error) {
-  const self = Object.freeze({
+  return Object.freeze({
     ok: false,
-    error,
-    map: (_fn) => self,
-    flatMap: (_fn) => self,
-    mapError: (fn) => err(fn(error)),
-    inspect: (_fn) => self,
-    inspectError: (fn) => {
-      fn(error);
-      return self;
-    },
-    match: (handlers) => handlers.err(error),
-    unwrap: () => {
-      throw error;
-    },
-    unwrapOr: (fallback) => fallback,
-    unwrapOrElse: (fn) => fn(),
-    expect: (message) => {
-      const thrown = new Error(`${message}: ${error.message}`, {
-        cause: error
-      });
-      Object.setPrototypeOf(thrown, error.constructor.prototype);
-      if (error.stack !== void 0)
-        thrown.stack = error.stack;
-      throw thrown;
-    }
+    error
   });
-  return self;
 }
 function isOk(result) {
   return result.ok;
@@ -110,17 +75,6 @@ function unwrapOr(result, fallback) {
 function unwrapOrElse(result, fn) {
   return result.ok ? result.value : fn();
 }
-function expect(result, message) {
-  if (result.ok)
-    return result.value;
-  const thrown = new Error(`${message}: ${result.error.message}`, {
-    cause: result.error
-  });
-  Object.setPrototypeOf(thrown, result.error.constructor.prototype);
-  if (result.error.stack !== void 0)
-    thrown.stack = result.error.stack;
-  throw thrown;
-}
 function fromNullable(value, errorFactory) {
   return value != null ? ok(value) : err(errorFactory());
 }
@@ -233,39 +187,13 @@ function collect(...results) {
   return ok(values);
 }
 function some(value) {
-  const self = Object.freeze({
+  return Object.freeze({
     some: true,
-    value,
-    map: (fn) => some(fn(value)),
-    flatMap: (fn) => fn(value),
-    filter: (predicate) => predicate(value) ? self : NONE,
-    inspect: (fn) => {
-      fn(value);
-      return self;
-    },
-    match: (handlers) => handlers.some(value),
-    unwrap: () => value,
-    expect: (_message) => value,
-    unwrapOr: (_fallback) => value,
-    unwrapOrElse: (_fn) => value
+    value
   });
-  return self;
 }
 var NONE = Object.freeze({
-  some: false,
-  map: (_fn) => NONE,
-  flatMap: (_fn) => NONE,
-  filter: (_predicate) => NONE,
-  inspect: (_fn) => NONE,
-  match: (handlers) => handlers.none(),
-  unwrap: () => {
-    throw new Error("Called unwrap on None");
-  },
-  expect: (message) => {
-    throw new Error(message);
-  },
-  unwrapOr: (fallback) => fallback,
-  unwrapOrElse: (fn) => fn()
+  some: false
 });
 function none() {
   return NONE;
@@ -307,11 +235,6 @@ function maybeUnwrapOr(maybe, fallback) {
 function maybeUnwrapOrElse(maybe, fn) {
   return maybe.some ? maybe.value : fn();
 }
-function maybeExpect(maybe, message) {
-  if (maybe.some)
-    return maybe.value;
-  throw new Error(message);
-}
 function maybeFromNullable(value) {
   return value != null ? some(value) : NONE;
 }
@@ -387,7 +310,6 @@ var Maybe = {
   unwrap: maybeUnwrap,
   unwrapOr: maybeUnwrapOr,
   unwrapOrElse: maybeUnwrapOrElse,
-  expect: maybeExpect,
   fromNullable: maybeFromNullable,
   fromPredicate: maybeFromPredicate,
   all: maybeAll,
@@ -416,7 +338,6 @@ var Result = {
   unwrap,
   unwrapOr,
   unwrapOrElse,
-  expect,
   fromNullable,
   fromPredicate,
   normalizeError,

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semyonf/kamchazky",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "author": "Semyón <taxnuke@gmail.com>",
   "homepage": "https://github.com/semyonf/kamchazky#readme",
   "bugs": {