@pvorona/failable 0.3.0 → 0.5.0

package/README.md

@@ -2,7 +2,15 @@
 
 Typed success/failure results for expected failures in TypeScript.
 
-`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`. Keep `isSuccess(...)` / `isFailure(...)` for validating hydrated unknown values, and use `isFailableLike(...)` for plain transport shapes.
+Use `@pvorona/failable` when failure is part of normal control flow: invalid
+input, missing config, not found, or a dependency call that can fail. Return a
+`Failable<T, E>` instead of throwing, then handle the result explicitly.
+
+A `Failable<T, E>` is either `Success<T>` or `Failure<E>`.
+
+- `success(...)` / `failure(...)` create results
+- `failable(...)` captures thrown or rejected boundaries
+- `run(...)` composes multiple `Failable` steps
 
 ## Install
 
@@ -10,261 +18,433 @@ Typed success/failure results for expected failures in TypeScript.
 npm i @pvorona/failable
 ```
 
-This package is ESM-only. Use `import` syntax; the published package declares `Node >=18`.
+This package is ESM-only and requires Node 18+.
+
+## Migration Note
+
+If you are upgrading from the previous API name:
+
+- `createFailable(x)` -> `failable(x)`
+- `CreateFailableNormalizeErrorOptions` -> `FailableNormalizeErrorOptions`
+
+## Basic Usage
 
-## Quick Start
+Use `Failable` when callers need different behavior for different expected
+failures. This is especially useful for business rules that schema validators do
+not model for you:
 
 ```ts
-import type { Failable } from '@pvorona/failable';
-import { failure, success } from '@pvorona/failable';
+import { failure, success, type Failable } from '@pvorona/failable';
+
+type TransferRequest = {
+  fromAccountId: string;
+  toAccountId: string;
+  amountCents: number;
+};
+
+type TransferPlan = TransferRequest & {
+  feeCents: number;
+};
+
+type TransferError =
+  | { code: 'same_account' }
+  | { code: 'amount_too_small'; minAmountCents: number }
+  | {
+      code: 'insufficient_funds';
+      balanceCents: number;
+      attemptedCents: number;
+    };
+
+function planTransfer(
+  request: TransferRequest,
+  balanceCents: number,
+): Failable<TransferPlan, TransferError> {
+  if (request.fromAccountId === request.toAccountId) {
+    return failure({ code: 'same_account' });
+  }
 
-function divide(a: number, b: number): Failable<number, string> {
-  if (b === 0) return failure('Cannot divide by zero');
+  if (request.amountCents < 100) {
+    return failure({ code: 'amount_too_small', minAmountCents: 100 });
+  }
+
+  if (balanceCents < request.amountCents) {
+    return failure({
+      code: 'insufficient_funds',
+      balanceCents,
+      attemptedCents: request.amountCents,
+    });
+  }
 
-  return success(a / b);
+  return success({ ...request, feeCents: 25 });
 }
 
-const result = divide(10, 2);
+const result = planTransfer(
+  {
+    fromAccountId: 'checking',
+    toAccountId: 'savings',
+    amountCents: 10_000,
+  },
+  4_500,
+);
 
 if (result.isError) {
-  console.error(result.error);
+  switch (result.error.code) {
+    case 'same_account':
+      console.error('Choose a different destination account');
+      break;
+    case 'amount_too_small':
+      console.error(`Transfers start at ${result.error.minAmountCents} cents`);
+      break;
+    case 'insufficient_funds':
+      console.error(
+        `Balance ${result.error.balanceCents} is below ${result.error.attemptedCents}`
+      );
+      break;
+  }
 } else {
-  console.log(result.data);
+  console.log(result.data.feeCents);
 }
 ```
 
-## Everyday Usage
+That is the default usage model for this package: return a typed result that
+carries both the success value and the expected failure reason.
 
-### Return `success(...)` and `failure(...)`
+## Choose The Right API
 
-Use the explicit constructors when your function already knows which branch it should return:
+| Need | Use |
+| --- | --- |
+| Return a successful or failed result from your own code | `success(...)` / `failure(...)` |
+| Read the value or provide a fallback | `getOr(...)` / `getOrElse(...)` |
+| Recover to `Success<T>` | `or(...)` / `orElse(...)` |
+| Map both branches to one output | `match(onSuccess, onFailure)` |
+| Throw the stored failure unchanged | `getOrThrow()` / `throwIfError(result)` |
+| Capture a throwing or rejecting boundary | `failable(...)` |
+| Compose multiple `Failable` steps | `run(...)` |
+| Cross a structured-clone boundary | `toFailableLike(...)` + `failable(...)` |
+| Validate `unknown` input | `isFailable(...)`, `isSuccess(...)`, `isFailure(...)`, `isFailableLike(...)` |
 
-```ts
-import { failure, success } from '@pvorona/failable';
+## Unwrapping And Recovery
 
-const ok = success({ id: '1' });
-const err = failure({ code: 'bad_request' });
-```
+Start with ordinary branching on `result.isError` or `result.isSuccess`. When
+you need a shorter form, use the helper that matches the job:
 
-### Branch and unwrap with instance methods
+- `result.getOr(fallback)`: return the success value or an eager fallback
+- `result.getOrElse(() => fallback)`: same, but lazily
+- `result.or(fallback)`: recover to `Success<T>` with an eager fallback
+- `result.orElse(() => fallback)`: recover to `Success<T>` lazily
+- `result.match(onSuccess, onFailure)`: map both branches to one output
+- `result.getOrThrow()`: return the success value or throw `result.error`
+- `throwIfError(result)`: throw `result.error` and narrow the same variable
 
-Hydrated `Failable` values carry booleans and convenience methods, so everyday code can stay local and direct:
+Use the lazy forms when the fallback is expensive or has side effects.
 
 ```ts
-import { failure, success } from '@pvorona/failable';
+import {
+  failure,
+  success,
+  throwIfError,
+  type Failable,
+} from '@pvorona/failable';
 
-const portResult = Math.random() > 0.5
-  ? success(3000)
-  : failure('Missing port');
+type QuoteError = {
+  code: 'pricing_unavailable';
+};
 
-if (portResult.isError) {
-  console.error(portResult.error);
-} else {
-  const requiredPort = portResult.getOrThrow();
-  console.log(requiredPort);
-}
+const feeResult: Failable<number, QuoteError> =
+  Math.random() > 0.5
+    ? success(25)
+    : failure({ code: 'pricing_unavailable' });
+
+const feeCents = feeResult.getOr(25);
+const status = feeResult.match(
+  (value) => `Fee is ${value} cents`,
+  (error) => `Cannot quote fee: ${error.code}`
+);
 
-const port = portResult.getOr(3000);
-const ensuredPort = portResult.or(3000);
-console.log(port, ensuredPort.data);
+throwIfError(feeResult);
+console.log(feeCents, status, feeResult.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 end up with `Success<T>`
-- `result.orElse(() => fallback)`: lazily recover to `Success<T>` only on failure
-- `result.match(onSuccess, onFailure)`: map both branches to one output type
-- `result.getOrThrow()`: unwrap success or throw the failure value
+## Capture Thrown Or Rejected Failures With `failable(...)`
 
-Use the lazy forms when the fallback is expensive or has side effects:
+Use `failable(...)` at boundaries that throw or reject, then normalize
+that failure once at the boundary if needed:
+
+Using `TransferPlan` from above:
 
 ```ts
-import { failure, success } from '@pvorona/failable';
+import {
+  failable,
+  run,
+  success,
+  type Failable,
+} from '@pvorona/failable';
 
-function readFallbackPort() {
-  console.log('Reading fallback port from disk');
-  return 3000;
-}
+type SubmitTransferError = Error;
 
-const portResult = Math.random() > 0.5
-  ? success(8080)
-  : failure('Missing port');
+async function postToLedger(
+  plan: TransferPlan,
+): Promise<Failable<{ transferId: string }, SubmitTransferError>> {
+  const request = (async () => {
+    if (plan.amountCents > 5_000) {
+      throw { code: 'ledger_unavailable' } as const;
+    }
 
-const eagerPort = portResult.getOr(readFallbackPort());
-const lazyPort = portResult.getOrElse(() => readFallbackPort());
-const ensuredPort = portResult.orElse(() => readFallbackPort());
+    return { transferId: 'tr_123' };
+  })();
 
-console.log(eagerPort, lazyPort, ensuredPort.data);
+  return await failable(request, {
+    normalizeError(error) {
+      return new Error('Ledger unavailable', { cause: error });
+    },
+  });
+}
+
+async function submitTransfer(
+  plan: TransferPlan,
+): Promise<Failable<{ transferId: string }, SubmitTransferError>> {
+  return await run(async function* ({ get }) {
+    const created = yield* get(postToLedger(plan));
+
+    return success(created);
+  });
+}
 ```
 
-`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.
+`postToLedger(...)` is the boundary adapter. It uses
+`failable(..., { normalizeError })` to capture a raw throw/rejection once
+and expose one stable `Error` shape to the rest of the app. If you only need
+generic `Error` normalization, `NormalizedErrors` is the built-in shortcut.
+Once that helper already returns `Failable`, `submitTransfer(...)` can use
+`run(...)` to compose it like any other step.
 
-`match(...)` is often clearer than a fallback when both branches need real handling:
+Pass a promise directly when you want rejection capture:
 
 ```ts
-import { failure, success } from '@pvorona/failable';
+const responseResult = await failable(fetch(url));
+```
 
-const portResult = Math.random() > 0.5
-  ? success(3000)
-  : failure('Missing port');
+`failable(...)` can:
 
-const status = portResult.match(
-  (port) => `Listening on ${port}`,
-  (error) => `Cannot start server: ${error}`
-);
-```
+- preserve an existing `Failable`
+- rehydrate a `FailableLike`
+- capture sync throws from a callback
+- capture promise rejections from a promise
+- normalize failures with `NormalizedErrors` or a custom `normalizeError(...)`
+
+By default, the thrown or rejected value becomes `.error` unchanged.
 
-### `createFailable(...)` for throwy or rejecting code
+Pass the promise itself when you want rejection capture.
+`failable(async () => value)` is misuse and returns a `Failure<Error>` telling
+you to pass the promise directly instead.
 
-`createFailable(...)` is the convenience entrypoint when you want to capture sync throws, promise rejections, or reuse an existing result shape:
+## Compose Existing `Failable` Steps With `run(...)`
 
-- `createFailable(failable)` returns the same tagged hydrated instance
-- `createFailable(failableLike)` rehydrates a strict wire shape into a real `Success` / `Failure`
-- `createFailable(() => value)` captures sync throws into `Failure`
-- `createFailable(promise)` captures promise 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`
+Use `run(...)` when each step already returns `Failable` and you want to write
+the success path once:
 
-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.
+Without `run(...)`, composition often becomes an error ladder:
 
 ```ts
-import {
-  createFailable,
-  failure,
-  success,
-  type Failable,
-} from '@pvorona/failable';
+import { failure, success, type Failable } from '@pvorona/failable';
 
-type PortError = {
-  readonly code: 'invalid_port';
+type Account = {
+  id: string;
+  balanceCents: number;
 };
 
-function readPort(value: unknown): Failable<number, PortError> {
-  if (typeof value !== 'number') return failure({ code: 'invalid_port' });
-
-  return success(value);
-}
+type TransferPlanningError =
+  | TransferError
+  | { code: 'source_account_not_found'; accountId: string }
+  | { code: 'destination_account_not_found'; accountId: string };
 
-const configResult = createFailable(() => JSON.parse(rawConfig));
+function readSourceAccount(
+  accountId: string,
+): Failable<Account, TransferPlanningError> {
+  if (accountId !== 'checking') {
+    return failure({ code: 'source_account_not_found', accountId });
+  }
 
-if (configResult.isError) {
-  console.error('Invalid JSON:', configResult.error);
-} else {
-  const portResult = createFailable(() => readPort(configResult.data.port));
+  return success({ id: 'checking', balanceCents: 5_000 });
+}
 
-  if (portResult.isError) {
-    console.error(portResult.error.code);
-  } else {
-    console.log(portResult.data);
+function readDestinationAccount(
+  accountId: string,
+): Failable<Account, TransferPlanningError> {
+  if (accountId !== 'savings') {
+    return failure({ code: 'destination_account_not_found', accountId });
   }
+
+  return success({ id: 'savings', balanceCents: 20_000 });
 }
-```
 
-Pass promises directly when you want rejection capture:
+function ensureDifferentAccounts(
+  source: Account,
+  destination: Account,
+): Failable<void, TransferPlanningError> {
+  if (source.id === destination.id) return failure({ code: 'same_account' });
 
-```ts
-import { createFailable } from '@pvorona/failable';
+  return success(undefined);
+}
 
-const responseResult = await createFailable(fetch(url));
-if (responseResult.isError) console.error(responseResult.error);
-```
+function ensureSufficientFunds(
+  source: Account,
+  amountCents: number,
+): Failable<Account, TransferPlanningError> {
+  if (source.balanceCents < amountCents) {
+    return failure({
+      code: 'insufficient_funds',
+      balanceCents: source.balanceCents,
+      attemptedCents: amountCents,
+    });
+  }
 
-### Use guards for `unknown` values
+  return success(source);
+}
 
-Use `isFailable(...)`, `isSuccess(...)`, and `isFailure(...)` when you are validating something that might already be a hydrated `Failable` instance:
+function planTransfer(
+  request: TransferRequest,
+): Failable<TransferPlan, TransferPlanningError> {
+  const source = readSourceAccount(request.fromAccountId);
+  if (source.isError) return source;
 
-```ts
-import { isFailable } from '@pvorona/failable';
+  const destination = readDestinationAccount(request.toAccountId);
+  if (destination.isError) return destination;
 
-const candidate: unknown = maybeFromAnotherModule();
+  const differentAccounts = ensureDifferentAccounts(source.data, destination.data);
+  if (differentAccounts.isError) return differentAccounts;
 
-if (isFailable(candidate) && candidate.isError) {
-  console.error(candidate.error);
+  const fundedSource = ensureSufficientFunds(source.data, request.amountCents);
+  if (fundedSource.isError) return fundedSource;
+
+  return success({ ...request, feeCents: 25 });
 }
 ```
 
-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.
+With the same helpers, `run(...)` keeps the flow linear:
 
-## Important Semantics
+```ts
+import { run, success, type Failable } from '@pvorona/failable';
+
+function planTransfer(
+  request: TransferRequest,
+): Failable<TransferPlan, TransferPlanningError> {
+  return run(function* ({ get }) {
+    const source = yield* get(readSourceAccount(request.fromAccountId));
+    const destination = yield* get(readDestinationAccount(request.toAccountId));
+    yield* get(ensureDifferentAccounts(source, destination));
+    yield* get(ensureSufficientFunds(source, request.amountCents));
+
+    return success({ ...request, feeCents: 25 });
+  });
+}
+```
 
-- Hydrated `Failable` values are frozen plain objects with methods. Prefer `result.isSuccess` / `result.isError`, and do not use `instanceof`.
-- `or(...)` and `getOr(...)` are eager. The fallback expression runs before the method call.
-- `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.
-- `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.
-- By default, `createFailable(...)` preserves raw thrown and rejected values. If something throws `'boom'`, `{ code: 'bad_request' }`, or `[error1, error2]`, that exact value becomes `.error`.
-- `getOrThrow()` throws `result.error` unchanged on failures. If you want `Error` values, opt into normalization.
-- `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)`.
+With one async rule added, the shape stays the same:
 
-## Normalizing Errors
+```ts
+import { failure, run, success, type Failable } from '@pvorona/failable';
 
-If you want `Error`-shaped failures, opt in explicitly with `NormalizedErrors`:
+type TransferAsyncError =
+  | TransferPlanningError
+  | { code: 'daily_limit_exceeded'; remainingCents: number };
 
-```ts
-import { createFailable, NormalizedErrors } from '@pvorona/failable';
+const request = {
+  fromAccountId: 'checking',
+  toAccountId: 'savings',
+  amountCents: 2_500,
+};
 
-const result = createFailable(
-  () => {
-    throw { code: 'bad_request' };
-  },
-  NormalizedErrors
-);
+async function ensureWithinDailyLimit(
+  accountId: string,
+  amountCents: number,
+): Promise<Failable<void, TransferAsyncError>> {
+  const remainingCents = accountId === 'checking' ? 3_000 : 0;
+  if (amountCents > remainingCents) {
+    return failure({ code: 'daily_limit_exceeded', remainingCents });
+  }
 
-if (result.isError) {
-  console.error(result.error.message);
-  console.error(result.error.cause); // { code: 'bad_request' }
+  return success(undefined);
 }
+
+const result = await run(async function* ({ get }) {
+  const source = yield* get(readSourceAccount(request.fromAccountId));
+  const destination = yield* get(readDestinationAccount(request.toAccountId));
+  yield* get(ensureDifferentAccounts(source, destination));
+  yield* get(ensureSufficientFunds(source, request.amountCents));
+  yield* get(ensureWithinDailyLimit(source.id, request.amountCents));
+
+  return success({ ...request, feeCents: 25 });
+});
 ```
 
-The same option also normalizes existing `failure(...)` values and rehydrated `FailableLike` failures.
+Keep these rules in mind:
 
-Built-in normalization behaves like this:
+- `run(...)` composes existing `Failable` values
+- if a yielded step fails, `run(...)` returns that original failure unchanged
+- in async builders, keep using `yield* get(...)`; do not write `await get(...)`
+- `run(...)` does not capture thrown values or rejected promises into `Failure`
+- wrap throwing or rejecting boundaries with `failable(...)` before they
+  enter `run(...)`
 
-- existing `Error` values pass through unchanged
-- arrays become `AggregateError`
-- other values become `Error`
-- the original raw value is preserved in `error.cause`
+## Transport And Runtime Validation
 
-For custom normalization:
+`Failable` values are hydrated objects with methods. Keep them inside your
+process. If you need a structured-clone-friendly shape, convert to
+`FailableLike<T, E>` before crossing the boundary and rehydrate on the other
+side:
 
 ```ts
-import { createFailable } from '@pvorona/failable';
+import {
+  failable,
+  toFailableLike,
+} from '@pvorona/failable';
 
-const result = createFailable(doThing, {
-  normalizeError(error) {
-    return error instanceof Error
-      ? error
-      : new Error('Operation failed', { cause: error });
+const result = planTransfer(
+  {
+    fromAccountId: 'checking',
+    toAccountId: 'savings',
+    amountCents: 2_500,
   },
-});
-```
+  5_000,
+);
 
-## Boundary Transport
+const wire = toFailableLike(result);
+const hydrated = failable(wire);
+```
 
-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:
+Use the runtime guards only when the input did not come from your own local
+control flow:
 
 ```ts
-import { createFailable, toFailableLike } from '@pvorona/failable';
+import { isFailable } from '@pvorona/failable';
 
-const wire = toFailableLike(result);
-const hydrated = createFailable(wire);
+const candidate: unknown = maybeFromAnotherModule();
+
+if (isFailable(candidate) && candidate.isError) {
+  console.error(candidate.error);
+}
 ```
 
-`isFailableLike(...)` validates the strict wire shape `{ status, data }` or `{ status, error }`, and the inner `data` / `error` values must still be structured-cloneable.
+- use `isFailable(...)`, `isSuccess(...)`, and `isFailure(...)` for `unknown`
+  values that might already be hydrated `Failable` results
+- use `isFailableLike(...)` for plain transport shapes like
+  `{ status, data }` or `{ status, error }`
 
 ## API At A Glance
 
 - `type Failable<T, E>`: `Success<T> | Failure<E>`
-- `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
-- `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
+- `type Success<T>` / `type Failure<E>`: hydrated result variants
+- `type FailableLike<T, E>`: structured-clone-friendly wire shape
+- `success(data)` / `failure(error)`: create hydrated results
+- `throwIfError(result)` / `result.getOrThrow()`: throw the stored failure
+  unchanged
+- `failable(...)`: preserve, rehydrate, capture, or normalize failures at
+  a boundary
+- `run(...)`: compose `Failable` steps without nested branching
+- `toFailableLike(...)`: convert a hydrated result into a wire shape
+- `isFailableLike(...)`: validate a wire shape
+- `isFailable(...)`, `isSuccess(...)`, `isFailure(...)`: validate hydrated
+  results
+- `NormalizedErrors`: built-in `Error` normalization for `failable(...)`
+- `FailableStatus`: runtime success/failure status values

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-export * from './lib/failable.js';
+export { FailableStatus, NormalizedErrors, failable, failure, isFailable, isFailableLike, isFailure, isSuccess, run, success, throwIfError, toFailableLike, } from './lib/failable.js';
+export type { FailableNormalizeErrorOptions, Failable, FailableLike, FailableLikeFailure, FailableLikeSuccess, Failure, Success, } from './lib/failable.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,QAAQ,EACR,OAAO,EACP,UAAU,EACV,cAAc,EACd,SAAS,EACT,SAAS,EACT,GAAG,EACH,OAAO,EACP,YAAY,EACZ,cAAc,GACf,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,6BAA6B,EAC7B,QAAQ,EACR,YAAY,EACZ,mBAAmB,EACnB,mBAAmB,EACnB,OAAO,EACP,OAAO,GACR,MAAM,mBAAmB,CAAC"}

package/dist/index.js

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

package/dist/lib/failable.d.ts

@@ -6,16 +6,16 @@ export type FailableStatus = (typeof FailableStatus)[keyof typeof FailableStatus
 export declare const NormalizedErrors: Readonly<{
     readonly mode: "normalized-errors";
 }>;
-export type CreateFailableNormalizeErrorOptions = {
+export type FailableNormalizeErrorOptions = {
     readonly normalizeError: (error: unknown) => Error;
 };
-type CreateFailableNormalizeErrorInput = typeof NormalizedErrors | CreateFailableNormalizeErrorOptions;
+type FailableNormalizeErrorInput = typeof NormalizedErrors | FailableNormalizeErrorOptions;
 type Match<T, E> = <U>(onSuccess: (data: T) => U, onFailure: (error: E) => U) => U;
-export type Failable<T, E> = (Success<T> & {
+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}.
  *
@@ -27,7 +27,7 @@ export type Failable<T, E> = (Success<T> & {
  *
  * Boundary rule:
  * - **sender**: `toFailableLike(result)`
- * - **receiver**: `createFailable(message.result)` (rehydrates into a real {@link Failable})
+ * - **receiver**: `failable(message.result)` (rehydrates into a real {@link Failable})
  *
  * Note: `data` / `error` must themselves be structured-cloneable.
  */
@@ -78,27 +78,101 @@ 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 `failable(...)`.
+ */
+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 InferFailableFromValue<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 FailableSyncOnlyCallback<F extends () => unknown> = F & (HasKnownPromiseLikeReturn<ReturnType<F>> extends true ? {
+    readonly __failablePassPromiseDirectly: 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>;
-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>;
-export declare function createFailable<T>(value: FailableLikeSuccess<T>): Success<T>;
-export declare function createFailable<E>(value: FailableLikeFailure<E>): Failure<E>;
-export declare function createFailable<T, E>(value: FailableLike<T, E>): Failable<T, E>;
-export declare function createFailable<T>(value: Success<T>, normalizeOption: CreateFailableNormalizeErrorInput): Success<T>;
-export declare function createFailable<E>(value: Failure<E>, normalizeOption: CreateFailableNormalizeErrorInput): Failure<Error>;
-export declare function createFailable<T, E>(value: Failable<T, E>, normalizeOption: CreateFailableNormalizeErrorInput): Failable<T, Error>;
-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>;
-export declare function createFailable<T, P extends PromiseLike<T> = PromiseLike<T>>(promise: P, normalizeOption: CreateFailableNormalizeErrorInput): Promise<NormalizeCreateFailableResult<Awaited<P>>>;
+type NormalizeFailableResult<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, TSource extends Failable<T, E> = Failable<T, E>> = Generator<RunGet<T, E, TSource>, T, unknown>;
+type AsyncRunGetIterator<T, E, TSource extends Failable<T, E> | PromiseLike<Failable<T, E>> = Failable<T, E> | PromiseLike<Failable<T, E>>> = AsyncGenerator<RunGet<T, E, TSource>, T, unknown>;
+type RunHelpers = {
+    readonly get: {
+        <T>(source: Success<T>): RunGetIterator<T, never, Success<T>>;
+        <E>(source: Failure<E>): RunGetIterator<never, E, Failure<E>>;
+        <T, E>(source: Failable<T, E>): RunGetIterator<T, E, Failable<T, E>>;
+        <T>(source: PromiseLike<Success<T>>): AsyncRunGetIterator<T, never, PromiseLike<Success<T>>>;
+        <E>(source: PromiseLike<Failure<E>>): AsyncRunGetIterator<never, E, PromiseLike<Failure<E>>>;
+        <T, E>(source: PromiseLike<Failable<T, E>>): AsyncRunGetIterator<T, E, PromiseLike<Failable<T, E>>>;
+    };
+};
+type RunYield = RunGet<unknown, 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 InferRunGuaranteedFailureError<TYield> = TYield extends RunGet<unknown, infer TError, infer TSource> ? [TSource] extends [Failure<TError> | PromiseLike<Failure<TError>>] ? TError : never : never;
+type RunReturnSuccessLike<TData = unknown> = {
+    readonly status: typeof FailableStatus.Success;
+    readonly data: TData;
+    readonly error: null;
+};
+type RunReturnFailureLike<TError = unknown> = {
+    readonly status: typeof FailableStatus.Failure;
+    readonly data: null;
+    readonly error: TError;
+};
+type MergeRunErrors<TYield, TError> = InferRunYieldError<TYield> | TError;
+type InferRunSuccessResult<TYield, TData> = [InferRunYieldError<TYield>] extends [
+    never
+] ? Success<TData> : Failable<TData, InferRunYieldError<TYield>>;
+type InferRunNeverSuccessResult<TYield> = [InferRunYieldError<TYield>] extends [
+    never
+] ? Success<never> : [InferRunGuaranteedFailureError<TYield>] extends [never] ? Failable<never, InferRunYieldError<TYield>> : Failure<InferRunYieldError<TYield>>;
+type InferRunUnionReturnData<TResult> = ([Extract<TResult, void>] extends [never] ? never : void) | (Extract<TResult, RunReturnSuccessLike> extends {
+    readonly data: infer TData;
+} ? TData : never);
+type InferRunUnionReturnError<TResult> = Extract<TResult, RunReturnFailureLike> extends {
+    readonly error: infer TError;
+} ? TError : never;
+type InferRunResult<TYield, TResult> = [TResult] extends [never] ? [InferRunYieldError<TYield>] extends [never] ? never : Failure<InferRunYieldError<TYield>> : [TResult] extends [void] ? InferRunSuccessResult<TYield, void> : [TResult] extends [RunReturnSuccessLike<infer TData>] ? [TData] extends [never] ? InferRunNeverSuccessResult<TYield> : InferRunSuccessResult<TYield, TData> : [TResult] extends [RunReturnFailureLike<infer TError>] ? Failure<MergeRunErrors<TYield, TError>> : [MergeRunErrors<TYield, InferRunUnionReturnError<TResult>>] extends [never] ? Success<InferRunUnionReturnData<TResult>> : Failable<InferRunUnionReturnData<TResult>, MergeRunErrors<TYield, InferRunUnionReturnError<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 failable<T>(value: Success<T>): Success<T>;
+export declare function failable<E>(value: Failure<E>): Failure<E>;
+export declare function failable<T, E>(value: Failable<T, E>): Failable<T, E>;
+export declare function failable<T>(value: FailableLikeSuccess<T>): Success<T>;
+export declare function failable<E>(value: FailableLikeFailure<E>): Failure<E>;
+export declare function failable<T, E>(value: FailableLike<T, E>): Failable<T, E>;
+export declare function failable<T>(value: Success<T>, normalizeOption: FailableNormalizeErrorInput): Success<T>;
+export declare function failable<E>(value: Failure<E>, normalizeOption: FailableNormalizeErrorInput): Failure<Error>;
+export declare function failable<T, E>(value: Failable<T, E>, normalizeOption: FailableNormalizeErrorInput): Failable<T, Error>;
+export declare function failable<T>(value: FailableLikeSuccess<T>, normalizeOption: FailableNormalizeErrorInput): Success<T>;
+export declare function failable<E>(value: FailableLikeFailure<E>, normalizeOption: FailableNormalizeErrorInput): Failure<Error>;
+export declare function failable<T, E>(value: FailableLike<T, E>, normalizeOption: FailableNormalizeErrorInput): Failable<T, Error>;
+/**
+ * Capture the boundary you actually have:
+ * - `failable(() => value)` for synchronous callbacks that may throw
+ * - `await failable(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 failable<T, P extends PromiseLike<T> = PromiseLike<T>>(promise: P, normalizeOption: FailableNormalizeErrorInput): Promise<NormalizeFailableResult<Awaited<P>>>;
+export declare function failable<T, E = unknown, P extends PromiseLike<T> = PromiseLike<T>>(promise: P): InferReturnTypeFromPromise<T, E, P>;
+export declare function failable<F extends () => unknown>(fun: FailableSyncOnlyCallback<F>, normalizeOption: FailableNormalizeErrorInput): NormalizeFailableResult<ReturnType<F>>;
+export declare function failable<F extends () => unknown, E = unknown>(fun: FailableSyncOnlyCallback<F>): InferFailableFromValue<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":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pvorona/failable",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Typed success/failure results for expected failures in TypeScript.",
   "keywords": [
     "failable",
@@ -30,14 +30,17 @@
     "!**/*.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/assert": "~1.0.0",
     "@pvorona/not-implemented": "~0.0.1",
     "@pvorona/types": "^0.0.0"
   }