@pvorona/failable 0.2.2 → 0.4.0

package/README.md

@@ -2,7 +2,7 @@
 
 Typed success/failure results for expected failures in TypeScript.
 
-`Failable<T, E>` is a discriminated union of `Success<T>` and `Failure<E>`. In the common case, you model the return type explicitly, construct with `success(...)` / `failure(...)`, and branch with `isSuccess(...)` / `isFailure(...)` or the `isSuccess` / `isError` flags.
+`Failable<T, E>` is a discriminated union of `Success<T>` and `Failure<E>`. In normal application code, return `success(...)` / `failure(...)`, then branch with `result.isSuccess` / `result.isError` on that local result. Reserve `isSuccess(...)` / `isFailure(...)` for validating hydrated values that arrive as `unknown`, and use `isFailableLike(...)` for plain transport shapes.
 
 ## Install
 
@@ -10,11 +10,13 @@ Typed success/failure results for expected failures in TypeScript.
 npm i @pvorona/failable
 ```
 
-## Quick start
+This package is ESM-only. Use `import` syntax; the published package declares `Node >=18`.
+
+## Quick Start
 
 ```ts
 import type { Failable } from '@pvorona/failable';
-import { failure, isFailure, success } from '@pvorona/failable';
+import { failure, success } from '@pvorona/failable';
 
 function divide(a: number, b: number): Failable<number, string> {
   if (b === 0) return failure('Cannot divide by zero');
@@ -24,22 +26,26 @@ function divide(a: number, b: number): Failable<number, string> {
 
 const result = divide(10, 2);
 
-if (isFailure(result)) {
+if (result.isError) {
   console.error(result.error);
 } else {
   console.log(result.data);
 }
 ```
 
-## Core API
+## Everyday Usage
 
-### `type Failable<T, E>`
+### Quick chooser
 
-Alias for `Success<T> | Failure<E>`.
+- Use `createFailable(() => ...)` when the boundary is synchronous code that might throw.
+- Use `await createFailable(promise)` when the boundary is async code that might reject.
+- Use `run(...)` when each step already returns `Failable` and you want to compose the happy path.
+- Use `throwIfError(result)` when you want to keep using the same `result` variable after narrowing.
+- Use `result.getOrThrow()` when you want the success value itself in expression or return position.
 
-### `success(data)` and `failure(error)`
+### Return `success(...)` and `failure(...)`
 
-Use these when you already know whether you are returning success or failure:
+Use the explicit constructors when your function already knows which branch it should return:
 
 ```ts
 import { failure, success } from '@pvorona/failable';
@@ -48,79 +54,271 @@ const ok = success({ id: '1' });
 const err = failure({ code: 'bad_request' });
 ```
 
-### `isSuccess(...)` and `isFailure(...)`
+### Branch and unwrap with helpers
 
-Use the guards or the instance booleans (`result.isSuccess` / `result.isError`) to branch:
+Hydrated `Failable` values carry booleans and convenience methods. Start with ordinary branching on the result, then pick the helper that matches how you want to unwrap:
 
 ```ts
-import { failure, isSuccess, success } from '@pvorona/failable';
+import { failure, success } from '@pvorona/failable';
 
-const result = Math.random() > 0.5 ? success(123) : failure('boom');
+const portResult = Math.random() > 0.5
+  ? success(3000)
+  : failure('Missing port');
 
-if (isSuccess(result)) {
-  console.log(result.data);
+if (portResult.isError) {
+  console.error(portResult.error);
 } else {
-  console.error(result.error);
+  console.log(portResult.data);
+}
+
+const port = portResult.getOr(3000);
+const ensuredPort = portResult.or(3000);
+console.log(port, ensuredPort.data);
+```
+
+- `result.isSuccess` / `result.isError`: branch on a hydrated result
+- `result.getOr(fallback)`: eagerly get the success value or a fallback
+- `result.getOrElse(() => fallback)`: lazily compute a fallback value only on failure
+- `result.or(fallback)`: eagerly recover to a `Success` result
+- `result.orElse(() => fallback)`: lazily recover to a `Success` result only on failure
+- `result.match(onSuccess, onFailure)`: map both branches to one output type
+- `throwIfError(result)`: throw the stored failure unchanged and keep using the same result on success
+- `result.getOrThrow()`: unwrap success as a value or throw the stored failure unchanged
+
+Use `throwIfError(result)` when you want to keep the same result variable and continue with narrowed access to `result.data`:
+
+```ts
+import {
+  failure,
+  success,
+  throwIfError,
+  type Failable,
+} from '@pvorona/failable';
+
+const portResult: Failable<number, string> = Math.random() > 0.5
+  ? success(3000)
+  : failure('Missing port');
+
+throwIfError(portResult);
+console.log(portResult.data);
+```
+
+Use `getOrThrow()` when you want the success value itself in expression or return position:
+
+```ts
+const requiredPort = portResult.getOrThrow();
+console.log(requiredPort);
+```
+
+Use the lazy forms when the fallback is expensive or has side effects:
+
+```ts
+import { failure, success } from '@pvorona/failable';
+
+function readFallbackPort() {
+  console.log('Reading fallback port from disk');
+  return 3000;
 }
+
+const portResult = Math.random() > 0.5
+  ? success(8080)
+  : failure('Missing port');
+
+const eagerPort = portResult.getOr(readFallbackPort());
+const lazyPort = portResult.getOrElse(() => readFallbackPort());
+const ensuredPort = portResult.orElse(() => readFallbackPort());
+
+console.log(eagerPort, lazyPort, ensuredPort.data);
+```
+
+`readFallbackPort()` runs before `getOr(...)` because the fallback expression is evaluated eagerly. With `getOrElse(...)` and `orElse(...)`, the callback runs only if the result is a failure.
+
+`match(...)` is often clearer than a fallback when both branches need real handling:
+
+```ts
+import { failure, success } from '@pvorona/failable';
+
+const portResult = Math.random() > 0.5
+  ? success(3000)
+  : failure('Missing port');
+
+const status = portResult.match(
+  (port) => `Listening on ${port}`,
+  (error) => `Cannot start server: ${error}`
+);
 ```
 
-### `createFailable(...)`
+### `createFailable(...)` for throwy or rejecting code
 
-`createFailable(...)` is a convenience wrapper when you want to capture thrown or rejected values:
+`createFailable(...)` is the boundary helper for non-`Failable` code. Use it when you need to capture sync throws, promise rejections, or rehydrate an existing result shape. Unlike `run(...)`, it is not for `Failable`-to-`Failable` composition:
 
-- `createFailable(failable)` returns the same instance
-- `createFailable(failableLike)` rehydrates into a real `Success` / `Failure`
-- `createFailable(() => value)` captures sync throws into `Failure`
-- `createFailable(promise)` captures promise rejections into `Failure`
+- `createFailable(failable)` returns the same tagged hydrated instance
+- `createFailable(failableLike)` rehydrates a strict wire shape into a real `Success` / `Failure`
+- `createFailable(() => value)` captures synchronous throws into `Failure`
+- `createFailable(promise)` captures async rejections into `Failure`
+- If a callback returns, or a promise resolves to, a `Failable` or `FailableLike`, `createFailable(...)` preserves that result instead of nesting it inside `Success`
 
-Example:
+Plain lookalike objects are not treated as hydrated `Failable` instances. If you have plain `{ status, data }` or `{ status, error }` transport data, validate it with `isFailableLike(...)` or pass it to `createFailable(...)` to rehydrate before calling instance methods.
+
+If a helper already returns `Failable`, branch on it directly or compose it with `run(...)` instead of wrapping it again with `createFailable(...)`.
 
 ```ts
-import { createFailable, isFailure } from '@pvorona/failable';
+import {
+  createFailable,
+  failure,
+  success,
+  type Failable,
+} from '@pvorona/failable';
+
+type PortError = {
+  readonly code: 'invalid_port';
+};
+
+function readPort(value: unknown): Failable<number, PortError> {
+  if (typeof value !== 'number') return failure({ code: 'invalid_port' });
 
-const responseResult = await createFailable(fetch('https://example.com/items'));
+  return success(value);
+}
+
+const configResult = createFailable(() => JSON.parse(rawConfig));
 
-if (isFailure(responseResult)) {
-  console.error('Network failure:', responseResult.error);
-} else if (!responseResult.data.ok) {
-  console.error(`Unexpected status: ${responseResult.data.status}`);
+if (configResult.isError) {
+  console.error('Invalid JSON:', configResult.error);
 } else {
-  const text = await responseResult.data.text();
-  const parseResult = createFailable(() => JSON.parse(text));
+  const portResult = readPort(configResult.data.port);
 
-  if (isFailure(parseResult)) {
-    console.error('Invalid JSON:', parseResult.error);
+  if (portResult.isError) {
+    console.error(portResult.error.code);
   } else {
-    console.log(parseResult.data);
+    console.log(portResult.data);
   }
 }
 ```
 
-## Important semantics
+Pass promises directly when you want rejection capture:
+
+```ts
+import { createFailable } from '@pvorona/failable';
+
+const responseResult = await createFailable(fetch(url));
+if (responseResult.isError) console.error(responseResult.error);
+```
+
+`createFailable(() => promise)` is not the supported API. In TypeScript, obviously promise-returning callbacks such as `async () => ...` and `() => Promise.resolve(...)` are rejected. JS callers, plus `any`/`unknown`-typed callbacks, still rely on the runtime guard; those cases stay in the failure channel as an `Error` telling you to pass the promise directly instead. That guard error is preserved even when you pass a custom `normalizeError`.
+
+### `run(...)` for `Failable` composition
+
+Use `run(...)` when each step already returns `Failable` and you want the happy path to read top-down. Inside both the sync and async builder forms, use `yield* get(result)` to unwrap success values. The mental model is simple: success values keep flowing forward, and the first yielded `Failure` short-circuits with that same `Failure` instance.
+
+```ts
+import { failure, run, success, type Failable } from '@pvorona/failable';
+
+function divide(a: number, b: number): Failable<number, string> {
+  if (b === 0) return failure('Cannot divide by zero');
 
-- `createFailable(async () => value)` is a footgun. The async function itself is treated as a sync return value, so the result is `Success<Promise<T>>`. If you want rejection capture, pass the promise directly: `await createFailable(somePromise)`.
+  return success(a / b);
+}
+
+const result = run(function* ({ get }) {
+  const first = yield* get(divide(20, 2));
+  const second = yield* get(divide(first, 5));
+
+  return success(second);
+});
+
+if (result.isError) {
+  console.error(result.error);
+} else {
+  console.log(result.data); // 2
+}
+```
+
+Async builders use the same composition pattern. Keep using `yield* get(...)`; do not switch to `await get(...)`:
+
+```ts
+import { failure, run, success, type Failable } from '@pvorona/failable';
+
+function divide(a: number, b: number): Failable<number, string> {
+  if (b === 0) return failure('Cannot divide by zero');
+
+  return success(a / b);
+}
+
+async function divideAsync(
+  a: number,
+  b: number,
+): Promise<Failable<number, string>> {
+  return divide(a, b);
+}
+
+const result = await run(async function* ({ get }) {
+  const first = yield* get(divide(20, 2));
+  const second = yield* get(divideAsync(first, 5));
+
+  return success(second);
+});
+
+if (result.isError) {
+  console.error(result.error);
+} else {
+  console.log(result.data); // 2
+}
+```
+
+Important `run(...)` rules:
+
+- Use `run(...)` for `Failable`-to-`Failable` composition. Use `createFailable(...)` when you need to capture sync throws, promise rejections, or rehydrate a `FailableLike`.
+- In async builders, keep using `yield* get(...)`. Do not write `await get(...)`.
+- `get(...)` accepts `Failable` sources in both modes and `PromiseLike<Failable>` sources in async builders only.
+- Use `yield* get(failable)` inside the callback. Other interaction with `get` internals is unsupported and not part of the API contract.
+- `get` exists only inside the generator callback; it is not a public export.
+- Return `success(...)`, `failure(...)`, or another `Failable`. An empty generator or bare `return` becomes `Success<void>`, but raw return values are rejected.
+- Throwing inside the generator is not converted into `Failure`, and rejected promised sources are not converted into `Failure`; foreign exceptions and rejections escape unchanged.
+- Rare cleanup edge cases: cleanup `yield* get(...)` steps unwind before a yielded `Failure` returns, cleanup `Failure`s preserve the original `Failure` while outer `finally` blocks keep unwinding, and promised source rejections still unwind managed cleanup before rejecting. Direct `throw`s inside `finally` are outside that managed cleanup and can replace the in-flight failure or rejection.
+
+### Use guards for `unknown` values
+
+Use `isFailable(...)`, `isSuccess(...)`, and `isFailure(...)` when you start from `unknown` and need to validate something that might already be a hydrated `Failable` instance. If you already have a local result from your own code, keep branching with `result.isSuccess` / `result.isError` instead of re-validating it with top-level guards:
+
+```ts
+import { isFailable } from '@pvorona/failable';
+
+const candidate: unknown = maybeFromAnotherModule();
+
+if (isFailable(candidate) && candidate.isError) {
+  console.error(candidate.error);
+}
+```
+
+These guards only recognize tagged hydrated instances created by `success(...)`, `failure(...)`, or `createFailable(...)`. Plain objects that merely look similar are not enough.
+
+Use `isSuccess(...)` / `isFailure(...)` when you only care about one branch. If you are validating plain wire data, use `isFailableLike(...)` and then rehydrate with `createFailable(...)` before calling instance methods.
+
+## Important Semantics
+
+- Hydrated `Failable` values are frozen plain objects with methods. Prefer `result.isSuccess` / `result.isError`, and do not use `instanceof`.
+- `run(...)` supports both `function*` and `async function*` builders. In both forms, use `yield* get(...)`; async builders still do not use `await get(...)`.
+- `run(...)` short-circuits on the first yielded failure, preserves that original `Failure` instance unchanged, and enters `finally` cleanup before returning. Cleanup keeps unwinding while cleanup `yield* get(...)` steps succeed. Cleanup `Failure`s preserve the original `Failure` and continue into outer `finally` blocks, while promised cleanup rejections still escape unchanged.
+- In async builders, promised `get(...)` source rejections still escape unchanged after managed `yield* get(...)` cleanup unwinds. Managed cleanup `Failure`s and managed cleanup promise rejections do not replace that original rejection. Direct `throw`s inside `finally` are outside managed cleanup: they still escape unchanged, and they can replace an in-flight yielded `Failure` or main-path rejection.
+- `run(...)` composes existing `Failable` results only. It does not capture thrown values or rejected promises into `Failure`.
 - `or(...)` and `getOr(...)` are eager. The fallback expression runs before the method call.
-- `isFailableLike(...)` is intentionally strict. It only accepts exactly `{ status, data }` or `{ status, error }` with no extra enumerable keys.
+- `orElse(...)` and `getOrElse(...)` are lazy. The callback runs only on failure.
+- `match(onSuccess, onFailure)` is useful when both branches should converge to the same output type.
+- `throwIfError(result)` throws `result.error` unchanged on failures and narrows the same hydrated result to `Success<T>` on return.
+- `throwIfError(result)` is deliberately minimal. It does not normalize or map errors; if you want `Error` values, normalize earlier with `createFailable(..., NormalizedErrors)` or a custom `normalizeError`.
+- `isFailable(...)`, `isSuccess(...)`, and `isFailure(...)` recognize only tagged hydrated instances, not public-shape lookalikes.
+- `isFailableLike(...)` remains the validator for transport shapes, and `createFailable(failableLike)` is the supported rehydration path before calling instance methods.
+- `createFailable(...)` remains the boundary tool for capture. Use `createFailable(() => ...)` for synchronous throw capture and `await createFailable(promise)` for async rejection capture.
 - By default, `createFailable(...)` preserves raw thrown and rejected values. If something throws `'boom'`, `{ code: 'bad_request' }`, or `[error1, error2]`, that exact value becomes `.error`.
-- `createFailable(input, NormalizedErrors)` converts non-`Error` failures into `Error` values:
-  - existing `Error` values pass through unchanged
-  - arrays become `AggregateError`
-  - other values become `Error`
-  - the original raw value is preserved in `error.cause`
-- `createFailable(input, { normalizeError })` lets you supply your own normalization strategy.
-- The library still uses private runtime tags internally for hydrated instances, but those details are not part of the public API.
-- This package is ESM-only. Use `import` syntax; there is no `require` export condition.
+- `getOrThrow()` returns the success value and throws `result.error` unchanged on failures. Use `throwIfError(result)` when you want control-flow narrowing instead of a returned value.
+- `createFailable(() => ...)` is for genuinely synchronous callbacks. TypeScript rejects obviously promise-returning callbacks, but JS callers and `any`/`unknown`-typed callbacks still rely on the runtime guard. If you already have a promise, pass it directly: `await createFailable(promise)`. That guard error stays actionable even when a custom `normalizeError` is present.
 
-## Normalizing errors
+## Normalizing Errors
 
-If you want `Error`-shaped handling at the boundary, opt in explicitly:
+If you want `Error`-shaped failures, opt in explicitly with `NormalizedErrors`:
 
 ```ts
-import {
-  createFailable,
-  isFailure,
-  NormalizedErrors,
-} from '@pvorona/failable';
+import { createFailable, NormalizedErrors } from '@pvorona/failable';
 
 const result = createFailable(
   () => {
@@ -129,12 +327,27 @@ const result = createFailable(
   NormalizedErrors
 );
 
-if (isFailure(result)) {
+if (result.isError) {
   console.error(result.error.message);
   console.error(result.error.cause); // { code: 'bad_request' }
 }
 ```
 
+The same preset also normalizes existing `failure(...)` values and rehydrated `FailableLike`
+failures, while still passing through existing `Error` instances unchanged.
+
+Built-in normalization behaves like this:
+
+- existing `Error` values pass through unchanged
+- arrays become `AggregateError`
+- other values become `Error`
+- the original raw value is preserved in `error.cause`
+
+Custom normalization is different: `normalizeError` runs for failure values, including
+existing `Error` instances, so you can wrap or replace them. The one exception is the
+internal sync-only callback misuse guard error from `createFailable(() => promise)`,
+which is preserved as-is so the actionable message survives.
+
 For custom normalization:
 
 ```ts
@@ -142,55 +355,36 @@ import { createFailable } from '@pvorona/failable';
 
 const result = createFailable(doThing, {
   normalizeError(error) {
-    return error instanceof Error
-      ? error
-      : new Error('Operation failed', { cause: error });
+    return new Error('Operation failed', { cause: error });
   },
 });
 ```
 
-## Structured-clone transport
+## Boundary Transport
 
-Hydrated `Failable` instances have methods and private runtime details that do not survive structured cloning (`postMessage`, `MessagePort`, extension messaging, etc.). Convert them to plain objects first:
+Hydrated `Failable` values do not survive structured cloning because they carry methods and runtime details. If you need to cross a message boundary, convert to a plain shape first and rehydrate on the receiving side:
 
 ```ts
 import { createFailable, toFailableLike } from '@pvorona/failable';
 
-const result = createFailable(() => JSON.parse('{"ok":true}'));
-
-// sender
 const wire = toFailableLike(result);
-postMessage(wire);
-
-// receiver
 const hydrated = createFailable(wire);
 ```
 
-The transport shape is:
-
-- `FailableLikeSuccess<T>`: `{ status: FailableStatus.Success, data: T }`
-- `FailableLikeFailure<E>`: `{ status: FailableStatus.Failure, error: E }`
-
-`FailableStatus` is a runtime object:
-
-```ts
-import { FailableStatus, type FailableLike } from '@pvorona/failable';
-
-const wire: FailableLike<number, string> = {
-  status: FailableStatus.Success,
-  data: 1,
-};
-```
+`isFailableLike(...)` validates the strict wire shape `{ status, data }` or `{ status, error }`, and the inner `data` / `error` values must still be structured-cloneable.
 
-## API at a glance
+## API At A Glance
 
 - `type Failable<T, E>`: `Success<T> | Failure<E>`
-- `type Success<T>`: success variant with `data`, `or(...)`, `getOr(...)`, and `getOrThrow()`
-- `type Failure<E>`: failure variant with `error`, `or(...)`, `getOr(...)`, and `getOrThrow()`
-- `const FailableStatus`: runtime `{ Success, Failure }` object
+- `type Success<T>`: success variant with `isSuccess`, `data`, `or(...)`, `orElse(...)`, `getOr(...)`, `getOrElse(...)`, `match(...)`, and `getOrThrow()`
+- `type Failure<E>`: failure variant with `isError`, `error`, `or(...)`, `orElse(...)`, `getOr(...)`, `getOrElse(...)`, `match(...)`, and `getOrThrow()`
+- `type FailableLike<T, E>`: strict structured-clone-friendly wire shape
 - `const NormalizedErrors`: built-in token for `Error` normalization
 - `success(data)` / `failure(error)`: explicit constructors
-- `isFailable(...)`, `isSuccess(...)`, `isFailure(...)`: runtime guards for hydrated values
-- `toFailableLike(...)`: convert a hydrated result into a structured-clone-friendly value
-- `isFailableLike(...)`: validate the strict structured-clone shape
-- `createFailable(...)`: wrap, rehydrate, or normalize results
+- `throwIfError(result)`: throw the stored failure unchanged and narrow the same result on success
+- `run(...)`: compose sync or async `Failable` steps with short-circuiting
+- `createFailable(...)`: wrap, preserve, rehydrate, or normalize results
+- `isFailable(...)`, `isSuccess(...)`, `isFailure(...)`: runtime validators for tagged hydrated values
+- `toFailableLike(...)`: convert a hydrated result into a plain transport shape
+- `isFailableLike(...)`: validate the strict wire shape
+- `const FailableStatus`: runtime `{ Success, Failure }` object for wire values

package/dist/index.js

@@ -1,119 +1,294 @@
-import { isFunction as s, isObject as i, hasOwnPropertyValue as F, hasOwnKey as b } from "@pvorona/assert";
-import { notImplemented as f } from "@pvorona/not-implemented";
-const h = /* @__PURE__ */ Symbol("Failable"), d = /* @__PURE__ */ Symbol("Success"), m = /* @__PURE__ */ Symbol("Failure"), n = Object.freeze({
+import { isFunction as d, isObject as l, hasOwnPropertyValue as b, hasOwnKey as F } from "@pvorona/assert";
+import { notImplemented as i } from "@pvorona/not-implemented";
+const g = /* @__PURE__ */ Symbol("Failable"), A = /* @__PURE__ */ Symbol("Success"), y = /* @__PURE__ */ Symbol("Failure"), u = Object.freeze({
   Success: "success",
   Failure: "failure"
-}), j = Object.freeze({
+}), k = Object.freeze({
   mode: "normalized-errors"
 });
-function A(r) {
-  return i(r) && Object.keys(r).length === 2 && F(r, "status", n.Success) && b(r, "data");
+function P(r) {
+  return l(r) && Object.keys(r).length === 2 && b(r, "status", u.Success) && F(r, "data");
 }
-function w(r) {
-  return i(r) && Object.keys(r).length === 2 && F(r, "status", n.Failure) && b(r, "error");
+function G(r) {
+  return l(r) && Object.keys(r).length === 2 && b(r, "status", u.Failure) && F(r, "error");
 }
-function a(r) {
-  return w(r) || A(r);
+function w(r) {
+  return G(r) || P(r);
 }
-const E = {
-  [h]: !0,
+const m = {
+  [g]: !0,
   isSuccess: !1,
   isError: !1,
   data: null,
   error: null,
-  or: f,
-  getOr: f,
-  getOrThrow: f
-}, y = (() => {
-  const r = Object.create(E);
-  return r[d] = !0, r.status = n.Success, r.isSuccess = !0, r.or = function() {
+  or: i,
+  orElse: i,
+  getOr: i,
+  getOrElse: i,
+  getOrThrow: i,
+  match: i
+}, T = (() => {
+  const r = Object.create(m);
+  return r[A] = !0, r.status = u.Success, r.isSuccess = !0, r.or = function() {
+    return this;
+  }, r.orElse = function() {
     return this;
   }, r.getOr = function() {
     return this.data;
+  }, r.getOrElse = function() {
+    return this.data;
   }, r.getOrThrow = function() {
     return this.data;
+  }, r.match = function(t) {
+    return t(this.data);
   }, Object.freeze(r);
-})(), T = (() => {
-  const r = Object.create(E);
-  return r[m] = !0, r.status = n.Failure, r.isError = !0, r.or = function(t) {
-    return c(t);
+})(), C = (() => {
+  const r = Object.create(m);
+  return r[y] = !0, r.status = u.Failure, r.isError = !0, r.or = function(t) {
+    return a(t);
+  }, r.orElse = function(t) {
+    return a(t());
   }, r.getOr = function(t) {
     return t;
+  }, r.getOrElse = function(t) {
+    return t();
   }, r.getOrThrow = function() {
     throw this.error;
+  }, r.match = function(t, n) {
+    return n(this.error);
   }, Object.freeze(r);
 })();
-function O(r) {
-  return !(!i(r) || r.status !== n.Success || r.isSuccess !== !0 || r.isError !== !1 || !("data" in r) || r.error !== null || !s(r.or) || !s(r.getOr) || !s(r.getOrThrow));
-}
-function g(r) {
-  return !(!i(r) || r.status !== n.Failure || r.isSuccess !== !1 || r.isError !== !0 || !("error" in r) || r.data !== null || !s(r.or) || !s(r.getOr) || !s(r.getOrThrow));
+function h(r, e) {
+  return l(r) ? r[e] === !0 : !1;
 }
-function l(r) {
-  return g(r) || O(r);
+function c(r) {
+  return h(r, g);
 }
-function U(r) {
-  return O(r);
+function ur(r) {
+  return h(r, A);
 }
-function N(r) {
-  return g(r);
+function or(r) {
+  return h(r, y);
 }
-function c(r) {
-  const e = Object.create(y);
+function a(r) {
+  const e = Object.create(T);
   return e.data = r, Object.freeze(e);
 }
-function o(r) {
-  const e = Object.create(T);
+function E(r) {
+  const e = Object.create(C);
   return e.error = r, Object.freeze(e);
 }
-function G(r) {
-  return r.status === n.Failure ? { status: n.Failure, error: r.error } : { status: n.Success, data: r.data };
+function cr(r) {
+  if (r.status === u.Failure) throw r.error;
+}
+function sr(r) {
+  return r.status === u.Failure ? { status: u.Failure, error: r.error } : { status: u.Success, data: r.data };
+}
+const U = "`createFailable(() => ...)` only accepts synchronous callbacks. This callback returned a Promise. Pass the promise directly instead: `await createFailable(promise)`.", R = /* @__PURE__ */ Symbol(
+  "CreateFailablePromiseCallbackGuard"
+), N = /* @__PURE__ */ Symbol("RunGet");
+class s {
+  [N] = !0;
+  source;
+  constructor(e) {
+    this.source = e;
+  }
+  static create(e) {
+    return new s(e);
+  }
+}
+const f = "`run()` generators must yield only values produced by `get(...)`. Use `yield* get(...)` in normal code.", B = "`run()` generators must return a `Failable` or finish without returning a value.";
+function* x(r) {
+  return yield s.create(r);
+}
+async function* D(r) {
+  return yield s.create(r);
+}
+function O(r) {
+  return !l(r) && !d(r) ? !1 : d(r.then);
+}
+function M(r) {
+  return O(r) ? D(r) : x(r);
+}
+const z = Object.freeze({
+  get: M
+});
+function I(r) {
+  if (!(r instanceof s))
+    throw new Error(f);
+  const e = r.source;
+  if (!c(e))
+    throw new Error(f);
+  return e;
 }
-function R(r, e) {
-  return l(r) ? u(r, e) : a(r) ? u(S(r), e) : s(r) ? L(r, e) : k(r, e);
+async function p(r) {
+  if (!(r instanceof s))
+    throw new Error(f);
+  const e = await r.source;
+  if (!c(e))
+    throw new Error(f);
+  return e;
+}
+async function j(r) {
+  if (!(r instanceof s))
+    throw new Error(f);
+  let e;
+  try {
+    e = await r.source;
+  } catch (t) {
+    return { kind: "rejection", rejection: t };
+  }
+  if (!c(e))
+    throw new Error(f);
+  return { kind: "source", source: e };
+}
+function v(r, e) {
+  let t = r.return(e);
+  for (; !t.done; ) {
+    const n = I(t.value);
+    if (n.status === u.Failure) {
+      t = r.return(e);
+      continue;
+    }
+    t = r.next(n.data);
+  }
+}
+async function K(r, e) {
+  let t = await r.return(e);
+  for (; !t.done; ) {
+    const n = await p(t.value);
+    if (n.status === u.Failure) {
+      t = await r.return(e);
+      continue;
+    }
+    t = await r.next(n.data);
+  }
+}
+async function V(r) {
+  let e = await r.return(void 0);
+  for (; !e.done; ) {
+    const t = await j(e.value);
+    if (t.kind === "rejection") {
+      e = await r.return(void 0);
+      continue;
+    }
+    const n = t.source;
+    if (n.status === u.Failure) {
+      e = await r.return(void 0);
+      continue;
+    }
+    e = await r.next(n.data);
+  }
+}
+function _(r) {
+  if (c(r))
+    return r;
+  if (r === void 0)
+    return a(void 0);
+  throw new Error(B);
+}
+function H(r) {
+  return Symbol.asyncIterator in r;
+}
+function W(r) {
+  let e = r.next();
+  for (; !e.done; ) {
+    const t = I(e.value);
+    if (t.status === u.Failure)
+      return v(r, t), t;
+    e = r.next(t.data);
+  }
+  return _(e.value);
+}
+async function Y(r) {
+  let e = await r.next();
+  for (; !e.done; ) {
+    const t = await j(e.value);
+    if (t.kind === "rejection")
+      throw await V(r), t.rejection;
+    const n = t.source;
+    if (n.status === u.Failure)
+      return await K(r, n), n;
+    e = await r.next(n.data);
+  }
+  return _(e.value);
+}
+function ir(r) {
+  const e = r(z);
+  return H(e) ? Y(e) : W(e);
+}
+function ar(r, e) {
+  return c(r) ? o(r, e) : w(r) ? o(S(r), e) : d(r) ? X(r, e) : Z(r, e);
 }
 function S(r) {
-  return r.status === n.Success ? c(r.data) : o(r.error);
+  return r.status === u.Success ? a(r.data) : E(r.error);
 }
-function L(r, e) {
+function q() {
+  const r = new Error(
+    U
+  );
+  return Object.defineProperty(r, R, {
+    value: !0,
+    enumerable: !1,
+    configurable: !1,
+    writable: !1
+  }), r;
+}
+function J(r) {
+  return r instanceof Error ? Object.getOwnPropertyDescriptor(
+    r,
+    R
+  )?.value === !0 : !1;
+}
+function Q(r) {
+  Promise.resolve(r).catch(() => {
+  });
+}
+function X(r, e) {
   try {
     const t = r();
-    return l(t) ? u(t, e) : a(t) ? u(S(t), e) : c(t);
+    return O(t) ? (Q(t), o(
+      E(q()),
+      e
+    )) : c(t) ? o(t, e) : w(t) ? o(S(t), e) : a(t);
   } catch (t) {
-    return u(o(t), e);
+    return o(E(t), e);
   }
 }
-function k(r, e) {
+function Z(r, e) {
   return Promise.resolve(r).then(
-    (t) => l(t) ? u(t, e) : a(t) ? u(S(t), e) : c(t),
-    (t) => u(o(t), e)
+    (t) => c(t) ? o(t, e) : w(t) ? o(S(t), e) : a(t),
+    (t) => o(E(t), e)
   );
 }
-function u(r, e) {
-  const t = P(e);
-  return t === null || r.status === n.Success || r.error instanceof Error ? r : o(t(r.error));
+function o(r, e) {
+  if (r.status === u.Success || J(r.error)) return r;
+  const t = $(e);
+  return t === null || r.error instanceof Error && e !== void 0 && L(e) ? r : E(t(r.error));
 }
-function P(r) {
-  return r === void 0 ? null : z(r) ? B : _(r) ? r.normalizeError : null;
+function $(r) {
+  return r === void 0 ? null : L(r) ? er : rr(r) ? r.normalizeError : null;
 }
-function z(r) {
-  return !i(r) || Object.keys(r).length !== 1 ? !1 : Object.getOwnPropertyDescriptor(r, "mode")?.value === j.mode;
+function L(r) {
+  return !l(r) || Object.keys(r).length !== 1 ? !1 : Object.getOwnPropertyDescriptor(r, "mode")?.value === k.mode;
 }
-function _(r) {
-  return i(r) ? s(r.normalizeError) : !1;
+function rr(r) {
+  return l(r) ? d(r.normalizeError) : !1;
 }
-function B(r) {
+function er(r) {
   return r instanceof Error ? r : Array.isArray(r) ? new AggregateError(r, "Multiple errors", { cause: r }) : new Error(String(r), { cause: r });
 }
 export {
-  n as FailableStatus,
-  j as NormalizedErrors,
-  R as createFailable,
-  o as failure,
-  l as isFailable,
-  a as isFailableLike,
-  N as isFailure,
-  U as isSuccess,
-  c as success,
-  G as toFailableLike
+  u as FailableStatus,
+  k as NormalizedErrors,
+  ar as createFailable,
+  E as failure,
+  c as isFailable,
+  w as isFailableLike,
+  or as isFailure,
+  ur as isSuccess,
+  ir as run,
+  a as success,
+  cr as throwIfError,
+  sr as toFailableLike
 };

package/dist/lib/failable.d.ts

@@ -10,7 +10,12 @@ export type CreateFailableNormalizeErrorOptions = {
     readonly normalizeError: (error: unknown) => Error;
 };
 type CreateFailableNormalizeErrorInput = typeof NormalizedErrors | CreateFailableNormalizeErrorOptions;
-export type Failable<T, E> = Success<T> | Failure<E>;
+type Match<T, E> = <U>(onSuccess: (data: T) => U, onFailure: (error: E) => U) => U;
+export type Failable<T, E> = ((Success<T> & {
+    readonly match: Match<T, E>;
+}) | (Failure<E> & {
+    readonly match: Match<T, E>;
+}));
 /**
  * Structured-clone-friendly representation of {@link Failable}.
  *
@@ -35,6 +40,12 @@ export type FailableLikeFailure<E> = {
     readonly status: typeof FailableStatus.Failure;
     readonly error: E;
 };
+type SuccessMatch<T> = {
+    <U, E>(onSuccess: (data: T) => U, onFailure: (error: E) => U): U;
+};
+type FailureMatch<E> = {
+    <U, T>(onSuccess: (data: T) => U, onFailure: (error: E) => U): U;
+};
 export declare function isFailableLike(value: unknown): value is FailableLike<unknown, unknown>;
 export type Success<T> = {
     readonly status: typeof FailableStatus.Success;
@@ -43,8 +54,11 @@ export type Success<T> = {
     readonly data: T;
     readonly error: null;
     readonly or: <U>(value: U) => Success<T>;
+    readonly orElse: <U>(getValue: () => U) => Success<T>;
     readonly getOr: <U>(value: U) => T;
+    readonly getOrElse: <U>(getValue: () => U) => T;
     readonly getOrThrow: () => T;
+    readonly match: SuccessMatch<T>;
 };
 export type Failure<E> = {
     readonly status: typeof FailableStatus.Failure;
@@ -53,20 +67,63 @@ export type Failure<E> = {
     readonly error: E;
     readonly data: null;
     readonly or: <U>(value: U) => Success<U>;
+    readonly orElse: <U>(getValue: () => U) => Success<U>;
     readonly getOr: <U>(value: U) => U;
+    readonly getOrElse: <U>(getValue: () => U) => U;
     readonly getOrThrow: () => never;
+    readonly match: FailureMatch<E>;
 };
 export declare function isFailable(value: unknown): value is Failable<unknown, unknown>;
 export declare function isSuccess(value: unknown): value is Success<unknown>;
 export declare function isFailure(value: unknown): value is Failure<unknown>;
 export declare function success<T = void>(data: T): Success<T>;
 export declare function failure<E = void>(error: E): Failure<E>;
+/**
+ * Throw `result.error` unchanged on failure, or narrow the same result to {@link Success} on return.
+ *
+ * Use this when you want control-flow narrowing without replacing the original variable.
+ * Use `result.getOrThrow()` when you need the success value itself in expression or return position.
+ * If you need `Error`-shaped failures, normalize earlier with `createFailable(...)`.
+ */
+export declare function throwIfError<T, E>(result: Failable<T, E>): asserts result is Success<T>;
 export declare function toFailableLike<T>(value: Success<T>): FailableLikeSuccess<T>;
 export declare function toFailableLike<E>(value: Failure<E>): FailableLikeFailure<E>;
 export declare function toFailableLike<T, E>(value: Failable<T, E>): FailableLike<T, E>;
-type InferReturnTypeFromFunction<F extends () => R, E = unknown, R = ReturnType<F>> = [R] extends [never] ? Failure<E> : R extends Success<infer A> ? Success<A> : R extends Failure<infer A> ? Failure<A> : R extends FailableLikeSuccess<infer A> ? Success<A> : R extends FailableLikeFailure<infer A> ? Failure<A> : R extends Failable<infer A, infer B> ? Failable<A, B> : R extends FailableLike<infer A, infer B> ? Failable<A, B> : Failable<R, E>;
+type InferCreateFailableFromValue<T, E = unknown> = [T] extends [never] ? Failure<E> : T extends Success<infer A> ? Success<A> : T extends Failure<infer A> ? Failure<A> : T extends FailableLikeSuccess<infer A> ? Success<A> : T extends FailableLikeFailure<infer A> ? Failure<A> : T extends Failable<infer A, infer B> ? Failable<A, B> : T extends FailableLike<infer A, infer B> ? Failable<A, B> : Failable<T, E>;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type HasKnownPromiseLikeReturn<T> = IsAny<T> extends true ? false : unknown extends T ? false : [Extract<T, PromiseLike<unknown>>] extends [never] ? false : true;
+type CreateFailableSyncOnlyCallback<F extends () => unknown> = F & (HasKnownPromiseLikeReturn<ReturnType<F>> extends true ? {
+    readonly __createFailablePassPromiseDirectly: never;
+} : unknown);
 type InferReturnTypeFromPromise<T, E = unknown, P extends PromiseLike<T> = PromiseLike<T>> = [Awaited<P>] extends [never] ? Promise<Failure<E>> : Awaited<P> extends Success<infer A> ? Promise<Success<A>> : Awaited<P> extends Failure<infer A> ? Promise<Failure<A>> : Awaited<P> extends Failable<unknown, unknown> ? Promise<Awaited<P>> : Awaited<P> extends FailableLikeSuccess<infer A> ? Promise<Success<A>> : Awaited<P> extends FailableLikeFailure<infer A> ? Promise<Failure<A>> : Awaited<P> extends FailableLike<infer A, infer B> ? Promise<Failable<A, B>> : Promise<Failable<Awaited<P>, E>>;
 type NormalizeCreateFailableResult<T> = [T] extends [never] ? Failure<Error> : T extends Success<infer A> ? Success<A> : T extends Failure<unknown> ? Failure<Error> : T extends FailableLikeSuccess<infer A> ? Success<A> : T extends FailableLikeFailure<unknown> ? Failure<Error> : T extends Failable<infer A, unknown> ? Failable<A, Error> : T extends FailableLike<infer A, unknown> ? Failable<A, Error> : Failable<T, Error>;
+declare const RUN_GET_TAG: unique symbol;
+declare class RunGet<T, E, TSource = Failable<T, E>> {
+    readonly [RUN_GET_TAG] = true;
+    readonly source: TSource;
+    private constructor();
+    static create<T, E, TSource extends Failable<T, E> | PromiseLike<Failable<T, E>>>(source: TSource): RunGet<T, E, TSource>;
+}
+type RunGetIterator<T, E> = Generator<RunGet<T, E>, T, unknown>;
+type RunHelpers = {
+    readonly get: {
+        <T>(source: Success<T>): RunGetIterator<T, never>;
+        <E>(source: Failure<E>): RunGetIterator<never, E>;
+        <T, E>(source: Failable<T, E>): RunGetIterator<T, E>;
+        <T>(source: PromiseLike<Success<T>>): AsyncGenerator<RunGet<T, never, unknown>, T, unknown>;
+        <E>(source: PromiseLike<Failure<E>>): AsyncGenerator<RunGet<never, E, unknown>, never, unknown>;
+        <T, E>(source: PromiseLike<Failable<T, E>>): AsyncGenerator<RunGet<T, E, unknown>, T, unknown>;
+    };
+};
+type RunYield = RunGet<unknown, unknown>;
+type RunReturn = void | Success<unknown> | Failure<unknown> | Failable<unknown, unknown>;
+type InferRunYieldError<TYield> = TYield extends RunGet<unknown, infer TError, unknown> ? TError : never;
+type InferRunReturnData<TResult> = TResult extends void ? void : TResult extends Success<infer TData> ? TData : TResult extends Failure<unknown> ? never : TResult extends Failable<infer TData, unknown> ? TData : never;
+type InferRunReturnError<TResult> = TResult extends void ? never : TResult extends Success<unknown> ? never : TResult extends Failure<infer TError> ? TError : TResult extends Failable<unknown, infer TError> ? TError : never;
+type InferRunError<TYield, TResult> = InferRunYieldError<TYield> | InferRunReturnError<TResult>;
+type InferRunResult<TYield, TResult> = [TResult] extends [never] ? [InferRunYieldError<TYield>] extends [never] ? never : Failure<InferRunYieldError<TYield>> : [InferRunReturnData<TResult>] extends [never] ? Failure<InferRunError<TYield, TResult>> : [InferRunError<TYield, TResult>] extends [never] ? Success<InferRunReturnData<TResult>> : Failable<InferRunReturnData<TResult>, InferRunError<TYield, TResult>>;
+export declare function run<TYield extends RunGet<unknown, unknown, unknown> = never, TResult extends RunReturn = RunReturn>(builder: (helpers: RunHelpers) => AsyncGenerator<TYield, TResult, unknown>): Promise<InferRunResult<TYield, TResult>>;
+export declare function run<TYield extends RunYield = never, TResult extends RunReturn = RunReturn>(builder: (helpers: RunHelpers) => Generator<TYield, TResult, unknown>): InferRunResult<TYield, TResult>;
 export declare function createFailable<T>(value: Success<T>): Success<T>;
 export declare function createFailable<E>(value: Failure<E>): Failure<E>;
 export declare function createFailable<T, E>(value: Failable<T, E>): Failable<T, E>;
@@ -79,9 +136,21 @@ export declare function createFailable<T, E>(value: Failable<T, E>, normalizeOpt
 export declare function createFailable<T>(value: FailableLikeSuccess<T>, normalizeOption: CreateFailableNormalizeErrorInput): Success<T>;
 export declare function createFailable<E>(value: FailableLikeFailure<E>, normalizeOption: CreateFailableNormalizeErrorInput): Failure<Error>;
 export declare function createFailable<T, E>(value: FailableLike<T, E>, normalizeOption: CreateFailableNormalizeErrorInput): Failable<T, Error>;
-export declare function createFailable<F extends () => R, E = unknown, R = ReturnType<F>>(fun: F): InferReturnTypeFromFunction<F, E, R>;
-export declare function createFailable<F extends () => R, R = ReturnType<F>>(fun: F, normalizeOption: CreateFailableNormalizeErrorInput): NormalizeCreateFailableResult<R>;
-export declare function createFailable<T, E = unknown, P extends PromiseLike<T> = PromiseLike<T>>(promise: P): InferReturnTypeFromPromise<T, E, P>;
+/**
+ * Capture the boundary you actually have:
+ * - `createFailable(() => value)` for synchronous callbacks that may throw
+ * - `await createFailable(promise)` for promise-based code that may reject
+ * - `run(...)` when the steps already return `Failable`
+ *
+ * In TypeScript, obviously promise-returning callbacks like `async () => ...` and
+ * `() => Promise.resolve(...)` are rejected. JS callers, plus `any`/`unknown`-typed
+ * callbacks, still rely on the runtime guard and receive a `Failure<Error>` telling
+ * them to pass the promise directly instead. That guard error is preserved even when
+ * a custom `normalizeError` callback is provided.
+ */
 export declare function createFailable<T, P extends PromiseLike<T> = PromiseLike<T>>(promise: P, normalizeOption: CreateFailableNormalizeErrorInput): Promise<NormalizeCreateFailableResult<Awaited<P>>>;
+export declare function createFailable<T, E = unknown, P extends PromiseLike<T> = PromiseLike<T>>(promise: P): InferReturnTypeFromPromise<T, E, P>;
+export declare function createFailable<F extends () => unknown>(fun: CreateFailableSyncOnlyCallback<F>, normalizeOption: CreateFailableNormalizeErrorInput): NormalizeCreateFailableResult<ReturnType<F>>;
+export declare function createFailable<F extends () => unknown, E = unknown>(fun: CreateFailableSyncOnlyCallback<F>): InferCreateFailableFromValue<ReturnType<F>, E>;
 export {};
 //# sourceMappingURL=failable.d.ts.map

package/dist/lib/failable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"failable.d.ts","sourceRoot":"","sources":["../../src/lib/failable.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"failable.d.ts","sourceRoot":"","sources":["../../src/lib/failable.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,cAAc;;;EAGhB,CAAC;AAEZ,MAAM,MAAM,cAAc,GACxB,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAEvD,eAAO,MAAM,gBAAgB;;EAElB,CAAC;AAEZ,MAAM,MAAM,mCAAmC,GAAG;IAChD,QAAQ,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,CAAC;CACpD,CAAC;AAEF,KAAK,iCAAiC,GAClC,OAAO,gBAAgB,GACvB,mCAAmC,CAAC;AAExC,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,EACnB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EACzB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,KACvB,CAAC,CAAC;AAEP,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,IACvB,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG;IACb,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAC7B,CAAC,GACA,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG;IACZ,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAC7B,CAAC,CAAC,CAAC;AAER;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,CAAC,IACzB,mBAAmB,CAAC,CAAC,CAAC,GACtB,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAE3B,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI;IACnC,QAAQ,CAAC,MAAM,EAAE,OAAO,cAAc,CAAC,OAAO,CAAC;IAC/C,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI;IACnC,QAAQ,CAAC,MAAM,EAAE,OAAO,cAAc,CAAC,OAAO,CAAC;IAC/C,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB,CAAC;AAEF,KAAK,YAAY,CAAC,CAAC,IAAI;IACrB,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;CAClE,CAAC;AAEF,KAAK,YAAY,CAAC,CAAC,IAAI;IACrB,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;CAClE,CAAC;AAwBF,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CAEzC;AAED,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACvB,QAAQ,CAAC,MAAM,EAAE,OAAO,cAAc,CAAC,OAAO,CAAC;IAC/C,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IACrB,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IACtD,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAChD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACvB,QAAQ,CAAC,MAAM,EAAE,OAAO,cAAc,CAAC,OAAO,CAAC;IAC/C,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IACtD,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAChD,QAAQ,CAAC,UAAU,EAAE,MAAM,KAAK,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;CACjC,CAAC;AAuKF,wBAAgB,UAAU,CACxB,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAErC;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAEnE;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAEnE;AAED,wBAAgB,OAAO,CAAC,CAAC,GAAG,IAAI,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAIrD;AAED,wBAAgB,OAAO,CAAC,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAItD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAC/B,MAAM,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,GACrB,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,CAE9B;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAC7E,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAC7E,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAShF,KAAK,4BAA4B,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GACnE,OAAO,CAAC,CAAC,CAAC,GACV,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAC1B,OAAO,CAAC,CAAC,CAAC,GACV,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAC1B,OAAO,CAAC,CAAC,CAAC,GACV,CAAC,SAAS,mBAAmB,CAAC,MAAM,CAAC,CAAC,GACtC,OAAO,CAAC,CAAC,CAAC,GACV,CAAC,SAAS,mBAAmB,CAAC,MAAM,CAAC,CAAC,GACtC,OAAO,CAAC,CAAC,CAAC,GACV,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GACpC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,GACd,CAAC,SAAS,YAAY,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GACxC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,GACd,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEnB,KAAK,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AAE/C,KAAK,yBAAyB,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,SAAS,IAAI,GACrD,KAAK,GACL,OAAO,SAAS,CAAC,GACjB,KAAK,GACL,CAAC,OAAO,CAAC,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAClD,KAAK,GACL,IAAI,CAAC;AAET,KAAK,8BAA8B,CAAC,CAAC,SAAS,MAAM,OAAO,IAAI,CAAC,GAC9D,CAAC,yBAAyB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAClD;IAAE,QAAQ,CAAC,mCAAmC,EAAE,KAAK,CAAA;CAAE,GACvD,OAAO,CAAC,CAAC;AAEf,KAAK,0BAA0B,CAC7B,CAAC,EACD,CAAC,GAAG,OAAO,EACX,CAAC,SAAS,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,IACvC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAC5B,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GACnC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GACnC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,SAAS,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,GAC7C,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,SAAS,mBAAmB,CAAC,MAAM,CAAC,CAAC,GAC/C,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,SAAS,mBAAmB,CAAC,MAAM,CAAC,CAAC,GAC/C,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,SAAS,YAAY,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GACjD,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GACvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAErC,KAAK,6BAA6B,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GACvD,OAAO,CAAC,KAAK,CAAC,GACd,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAC1B,OAAO,CAAC,CAAC,CAAC,GACV,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,GAC1B,OAAO,CAAC,KAAK,CAAC,GACd,CAAC,SAAS,mBAAmB,CAAC,MAAM,CAAC,CAAC,GACtC,OAAO,CAAC,CAAC,CAAC,GACV,CAAC,SAAS,mBAAmB,CAAC,OAAO,CAAC,GACtC,OAAO,CAAC,KAAK,CAAC,GACd,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,GACpC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,GAClB,CAAC,SAAS,YAAY,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,GACxC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,GAClB,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AAkBvB,QAAA,MAAM,WAAW,eAAmB,CAAC;AAErC,cAAM,MAAM,CACV,CAAC,EACD,CAAC,EACD,OAAO,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;IAExB,QAAQ,CAAC,CAAC,WAAW,CAAC,QAAQ;IAC9B,SAAgB,MAAM,EAAE,OAAO,CAAC;IAEhC,OAAO;IAIP,MAAM,CAAC,MAAM,CACX,CAAC,EACD,CAAC,EACD,OAAO,SAAS,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAE5D,MAAM,EAAE,OAAO,GACd,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC;CAGzB;AAED,KAAK,cAAc,CAAC,CAAC,EAAE,CAAC,IAAI,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;AAEhE,KAAK,UAAU,GAAG;IAChB,QAAQ,CAAC,GAAG,EAAE;QACZ,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAClD,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAClD,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACrD,CAAC,CAAC,EACA,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAC9B,cAAc,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;QACzD,CAAC,CAAC,EACA,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAC9B,cAAc,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QAC7D,CAAC,CAAC,EAAE,CAAC,EACH,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAClC,cAAc,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;KACtD,CAAC;CACH,CAAC;AAEF,KAAK,QAAQ,GAAG,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AACzC,KAAK,SAAS,GACV,IAAI,GACJ,OAAO,CAAC,OAAO,CAAC,GAChB,OAAO,CAAC,OAAO,CAAC,GAChB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AAE/B,KAAK,kBAAkB,CAAC,MAAM,IAAI,MAAM,SAAS,MAAM,CACrD,OAAO,EACP,MAAM,MAAM,EACZ,OAAO,CACR,GACG,MAAM,GACN,KAAK,CAAC;AAEV,KAAK,kBAAkB,CAAC,OAAO,IAAI,OAAO,SAAS,IAAI,GACnD,IAAI,GACJ,OAAO,SAAS,OAAO,CAAC,MAAM,KAAK,CAAC,GACpC,KAAK,GACL,OAAO,SAAS,OAAO,CAAC,OAAO,CAAC,GAChC,KAAK,GACL,OAAO,SAAS,QAAQ,CAAC,MAAM,KAAK,EAAE,OAAO,CAAC,GAC9C,KAAK,GACL,KAAK,CAAC;AAEV,KAAK,mBAAmB,CAAC,OAAO,IAAI,OAAO,SAAS,IAAI,GACpD,KAAK,GACL,OAAO,SAAS,OAAO,CAAC,OAAO,CAAC,GAChC,KAAK,GACL,OAAO,SAAS,OAAO,CAAC,MAAM,MAAM,CAAC,GACrC,MAAM,GACN,OAAO,SAAS,QAAQ,CAAC,OAAO,EAAE,MAAM,MAAM,CAAC,GAC/C,MAAM,GACN,KAAK,CAAC;AAEV,KAAK,aAAa,CAAC,MAAM,EAAE,OAAO,IAC9B,kBAAkB,CAAC,MAAM,CAAC,GAC1B,mBAAmB,CAAC,OAAO,CAAC,CAAC;AAEjC,KAAK,cAAc,CAAC,MAAM,EAAE,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,GAC5D,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAC1C,KAAK,GACL,OAAO,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,GACrC,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAC7C,OAAO,CAAC,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,CAAC,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAChD,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,GACpC,QAAQ,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAgR1E,wBAAgB,GAAG,CACjB,MAAM,SAAS,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,GAAG,KAAK,EACxD,OAAO,SAAS,SAAS,GAAG,SAAS,EAErC,OAAO,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,GACzE,OAAO,CAAC,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAC5C,wBAAgB,GAAG,CACjB,MAAM,SAAS,QAAQ,GAAG,KAAK,EAC/B,OAAO,SAAS,SAAS,GAAG,SAAS,EAErC,OAAO,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,GACpE,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAqBnC,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AACjE,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AACjE,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC5E,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAC7E,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAC7E,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAChF,wBAAgB,cAAc,CAAC,CAAC,EAC9B,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,EACjB,eAAe,EAAE,iCAAiC,GACjD,OAAO,CAAC,CAAC,CAAC,CAAC;AACd,wBAAgB,cAAc,CAAC,CAAC,EAC9B,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,EACjB,eAAe,EAAE,iCAAiC,GACjD,OAAO,CAAC,KAAK,CAAC,CAAC;AAClB,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EACjC,KAAK,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EACrB,eAAe,EAAE,iCAAiC,GACjD,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AACtB,wBAAgB,cAAc,CAAC,CAAC,EAC9B,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAC7B,eAAe,EAAE,iCAAiC,GACjD,OAAO,CAAC,CAAC,CAAC,CAAC;AACd,wBAAgB,cAAc,CAAC,CAAC,EAC9B,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAC7B,eAAe,EAAE,iCAAiC,GACjD,OAAO,CAAC,KAAK,CAAC,CAAC;AAClB,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EACjC,KAAK,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,EACzB,eAAe,EAAE,iCAAiC,GACjD,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AACtB;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EACzE,OAAO,EAAE,CAAC,EACV,eAAe,EAAE,iCAAiC,GACjD,OAAO,CAAC,6BAA6B,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACtD,wBAAgB,cAAc,CAC5B,CAAC,EACD,CAAC,GAAG,OAAO,EACX,CAAC,SAAS,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EACzC,OAAO,EAAE,CAAC,GAAG,0BAA0B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AACnD,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,OAAO,EACpD,GAAG,EAAE,8BAA8B,CAAC,CAAC,CAAC,EACtC,eAAe,EAAE,iCAAiC,GACjD,6BAA6B,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AAChD,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,CAAC,GAAG,OAAO,EACjE,GAAG,EAAE,8BAA8B,CAAC,CAAC,CAAC,GACrC,4BAA4B,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pvorona/failable",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "Typed success/failure results for expected failures in TypeScript.",
   "keywords": [
     "failable",
@@ -30,14 +30,18 @@
     "!**/*.tsbuildinfo"
   ],
   "scripts": {
+    "test-public-api": "vitest run --config vitest.public-surface.config.mts",
+    "typecheck-public-api": "tsc --project tests/consumer/tsconfig.json --noEmit",
     "check-package-surface": "node ./scripts/check-package-surface.mjs",
-    "prepublishOnly": "npm run check-package-surface"
+    "check-public-surface": "npm run test-public-api && npm run typecheck-public-api && npm run check-package-surface",
+    "prepublishOnly": "npm exec nx run @pvorona/failable:check-public-surface"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@pvorona/assert": "~0.1.0",
-    "@pvorona/not-implemented": "~0.0.1"
+    "@pvorona/assert": "~1.0.0",
+    "@pvorona/not-implemented": "~0.0.1",
+    "@pvorona/types": "^0.0.0"
   }
 }