@pvorona/failable 0.4.0 → 0.6.0

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,33 +1,33 @@
-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({
+import { isFunction as E, isObject as c, hasOwnPropertyValue as S, hasOwnKey as y } from "@pvorona/assert";
+import { notImplemented as a } from "@pvorona/not-implemented";
+const F = /* @__PURE__ */ Symbol("Failable"), A = /* @__PURE__ */ Symbol("Success"), O = /* @__PURE__ */ Symbol("Failure"), u = Object.freeze({
   Success: "success",
   Failure: "failure"
 }), k = Object.freeze({
   mode: "normalized-errors"
 });
-function P(r) {
-  return l(r) && Object.keys(r).length === 2 && b(r, "status", u.Success) && F(r, "data");
-}
 function G(r) {
-  return l(r) && Object.keys(r).length === 2 && b(r, "status", u.Failure) && F(r, "error");
+  return c(r) && Object.keys(r).length === 2 && S(r, "status", u.Success) && y(r, "data");
+}
+function T(r) {
+  return c(r) && Object.keys(r).length === 2 && S(r, "status", u.Failure) && y(r, "error");
 }
 function w(r) {
-  return G(r) || P(r);
+  return T(r) || G(r);
 }
 const m = {
-  [g]: !0,
+  [F]: !0,
   isSuccess: !1,
-  isError: !1,
+  isFailure: !1,
   data: null,
   error: null,
-  or: i,
-  orElse: i,
-  getOr: i,
-  getOrElse: i,
-  getOrThrow: i,
-  match: i
-}, T = (() => {
+  or: a,
+  orElse: a,
+  getOr: a,
+  getOrElse: a,
+  getOrThrow: a,
+  match: a
+}, p = (() => {
   const r = Object.create(m);
   return r[A] = !0, r.status = u.Success, r.isSuccess = !0, r.or = function() {
     return this;
@@ -42,12 +42,12 @@ const m = {
   }, r.match = function(t) {
     return t(this.data);
   }, Object.freeze(r);
-})(), C = (() => {
+})(), N = (() => {
   const r = Object.create(m);
-  return r[y] = !0, r.status = u.Failure, r.isError = !0, r.or = function(t) {
-    return a(t);
+  return r[O] = !0, r.status = u.Failure, r.isFailure = !0, r.or = function(t) {
+    return f(t);
   }, r.orElse = function(t) {
-    return a(t());
+    return f(t());
   }, r.getOr = function(t) {
     return t;
   }, r.getOrElse = function(t) {
@@ -58,37 +58,35 @@ const m = {
     return n(this.error);
   }, Object.freeze(r);
 })();
-function h(r, e) {
-  return l(r) ? r[e] === !0 : !1;
+function b(r, e) {
+  return c(r) ? r[e] === !0 : !1;
 }
-function c(r) {
-  return h(r, g);
+function i(r) {
+  return b(r, F);
 }
-function ur(r) {
-  return h(r, A);
+function ir(r) {
+  return b(r, A);
 }
-function or(r) {
-  return h(r, y);
+function sr(r) {
+  return b(r, O);
 }
-function a(r) {
-  const e = Object.create(T);
+function f(r) {
+  const e = Object.create(p);
   return e.data = r, Object.freeze(e);
 }
-function E(r) {
-  const e = Object.create(C);
+function d(r) {
+  const e = Object.create(N);
   return e.error = r, Object.freeze(e);
 }
-function cr(r) {
+function ar(r) {
   if (r.status === u.Failure) throw r.error;
 }
-function sr(r) {
+function fr(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");
+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 {
-  [N] = !0;
+  [C] = !0;
   source;
   constructor(e) {
     this.source = e;
@@ -97,52 +95,52 @@ class s {
     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) {
+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* D(r) {
+async function* B(r) {
   return yield s.create(r);
 }
-function O(r) {
-  return !l(r) && !d(r) ? !1 : d(r.then);
+function R(r) {
+  return !c(r) && !E(r) ? !1 : E(r.then);
 }
-function M(r) {
-  return O(r) ? D(r) : x(r);
+function x(r) {
+  return R(r) ? B(r) : z(r);
 }
-const z = Object.freeze({
-  get: M
+const D = Object.freeze({
+  get: x
 });
 function I(r) {
   if (!(r instanceof s))
-    throw new Error(f);
+    throw new Error(l);
   const e = r.source;
-  if (!c(e))
-    throw new Error(f);
+  if (!i(e))
+    throw new Error(l);
   return e;
 }
-async function p(r) {
+async function V(r) {
   if (!(r instanceof s))
-    throw new Error(f);
+    throw new Error(l);
   const e = await r.source;
-  if (!c(e))
-    throw new Error(f);
+  if (!i(e))
+    throw new Error(l);
   return e;
 }
-async function j(r) {
+async function L(r) {
   if (!(r instanceof s))
-    throw new Error(f);
+    throw new Error(l);
   let e;
   try {
     e = await r.source;
   } catch (t) {
     return { kind: "rejection", rejection: t };
   }
-  if (!c(e))
-    throw new Error(f);
+  if (!i(e))
+    throw new Error(l);
   return { kind: "source", source: e };
 }
-function v(r, e) {
+function K(r, e) {
   let t = r.return(e);
   for (; !t.done; ) {
     const n = I(t.value);
@@ -153,10 +151,10 @@ function v(r, e) {
     t = r.next(n.data);
   }
 }
-async function K(r, e) {
+async function H(r, e) {
   let t = await r.return(e);
   for (; !t.done; ) {
-    const n = await p(t.value);
+    const n = await V(t.value);
     if (n.status === u.Failure) {
       t = await r.return(e);
       continue;
@@ -164,10 +162,10 @@ async function K(r, e) {
     t = await r.next(n.data);
   }
 }
-async function V(r) {
+async function J(r) {
   let e = await r.return(void 0);
   for (; !e.done; ) {
-    const t = await j(e.value);
+    const t = await L(e.value);
     if (t.kind === "rejection") {
       e = await r.return(void 0);
       continue;
@@ -180,115 +178,139 @@ async function V(r) {
     e = await r.next(n.data);
   }
 }
-function _(r) {
-  if (c(r))
+function P(r) {
+  if (i(r))
     return r;
   if (r === void 0)
-    return a(void 0);
-  throw new Error(B);
+    return f(void 0);
+  throw new Error(M);
 }
-function H(r) {
+function W(r) {
   return Symbol.asyncIterator in r;
 }
-function W(r) {
+function Y(r) {
   let e = r.next();
   for (; !e.done; ) {
     const t = I(e.value);
     if (t.status === u.Failure)
-      return v(r, t), t;
+      return K(r, t), t;
     e = r.next(t.data);
   }
-  return _(e.value);
+  return P(e.value);
 }
-async function Y(r) {
+async function q(r) {
   let e = await r.next();
   for (; !e.done; ) {
-    const t = await j(e.value);
+    const t = await L(e.value);
     if (t.kind === "rejection")
-      throw await V(r), t.rejection;
+      throw await J(r), t.rejection;
     const n = t.source;
     if (n.status === u.Failure)
-      return await K(r, n), n;
+      return await H(r, n), n;
     e = await r.next(n.data);
   }
-  return _(e.value);
+  return P(e.value);
 }
-function ir(r) {
-  const e = r(z);
-  return H(e) ? Y(e) : W(e);
+function lr(r) {
+  const e = r(D);
+  return W(e) ? q(e) : Y(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 dr(r, e) {
+  return i(r) ? o(r, e) : w(r) ? o(g(r), e) : E(r) ? $(r, e) : v(r, e);
 }
-function S(r) {
-  return r.status === u.Success ? a(r.data) : E(r.error);
+function g(r) {
+  return r.status === u.Success ? f(r.data) : d(r.error);
 }
-function q() {
+function Q() {
   const r = new Error(
     U
   );
-  return Object.defineProperty(r, R, {
+  return Object.defineProperty(r, j, {
     value: !0,
     enumerable: !1,
     configurable: !1,
     writable: !1
   }), r;
 }
-function J(r) {
+function X(r) {
   return r instanceof Error ? Object.getOwnPropertyDescriptor(
     r,
-    R
+    j
   )?.value === !0 : !1;
 }
-function Q(r) {
+function Z(r) {
   Promise.resolve(r).catch(() => {
   });
 }
-function X(r, e) {
+function $(r, e) {
   try {
     const t = r();
-    return O(t) ? (Q(t), o(
-      E(q()),
+    return R(t) ? (Z(t), o(
+      d(Q()),
       e
-    )) : c(t) ? o(t, e) : w(t) ? o(S(t), e) : a(t);
+    )) : i(t) ? o(t, e) : w(t) ? o(g(t), e) : f(t);
   } catch (t) {
-    return o(E(t), e);
+    return o(d(t), e);
   }
 }
-function Z(r, e) {
+function v(r, e) {
   return Promise.resolve(r).then(
-    (t) => c(t) ? o(t, e) : w(t) ? o(S(t), e) : a(t),
-    (t) => o(E(t), e)
+    (t) => i(t) ? o(t, e) : w(t) ? o(g(t), e) : f(t),
+    (t) => o(d(t), e)
   );
 }
 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 $(r) {
-  return r === void 0 ? null : L(r) ? er : rr(r) ? r.normalizeError : null;
-}
-function L(r) {
-  return !l(r) || Object.keys(r).length !== 1 ? !1 : Object.getOwnPropertyDescriptor(r, "mode")?.value === k.mode;
+  if (r.status === u.Success || X(r.error)) return r;
+  const t = rr(e);
+  return t === null || r.error instanceof Error && e !== void 0 && _(e) ? r : d(t(r.error));
 }
 function rr(r) {
-  return l(r) ? d(r.normalizeError) : !1;
+  return r === void 0 ? null : _(r) ? ur : er(r) ? r.normalizeError : null;
+}
+function _(r) {
+  return !c(r) || Object.keys(r).length !== 1 ? !1 : Object.getOwnPropertyDescriptor(r, "mode")?.value === k.mode;
 }
 function er(r) {
-  return r instanceof Error ? r : Array.isArray(r) ? new AggregateError(r, "Multiple errors", { cause: r }) : new Error(String(r), { cause: r });
+  return c(r) ? E(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 ur(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 {
   u as FailableStatus,
   k as NormalizedErrors,
-  ar as createFailable,
-  E as failure,
-  c as isFailable,
+  dr as failable,
+  d as failure,
+  i as isFailable,
   w as isFailableLike,
-  or as isFailure,
-  ur as isSuccess,
-  ir as run,
-  a as success,
-  cr as throwIfError,
-  sr as toFailableLike
+  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,10 +6,10 @@ 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> & {
     readonly match: Match<T, E>;
@@ -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.
  */
@@ -50,7 +50,7 @@ export declare function isFailableLike(value: unknown): value is FailableLike<un
 export type Success<T> = {
     readonly status: typeof FailableStatus.Success;
     readonly isSuccess: true;
-    readonly isError: false;
+    readonly isFailure: false;
     readonly data: T;
     readonly error: null;
     readonly or: <U>(value: U) => Success<T>;
@@ -63,7 +63,7 @@ export type Success<T> = {
 export type Failure<E> = {
     readonly status: typeof FailableStatus.Failure;
     readonly isSuccess: false;
-    readonly isError: true;
+    readonly isFailure: true;
     readonly error: E;
     readonly data: null;
     readonly or: <U>(value: U) => Success<U>;
@@ -83,20 +83,20 @@ export declare function failure<E = void>(error: E): Failure<E>;
  *
  * 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(...)`.
+ * 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 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 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 CreateFailableSyncOnlyCallback<F extends () => unknown> = F & (HasKnownPromiseLikeReturn<ReturnType<F>> extends true ? {
-    readonly __createFailablePassPromiseDirectly: never;
+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>;
+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;
@@ -104,42 +104,64 @@ declare class RunGet<T, E, TSource = Failable<T, E>> {
     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 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>;
-        <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>;
+        <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>;
+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 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>>;
+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 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 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:
- * - `createFailable(() => value)` for synchronous callbacks that may throw
- * - `await createFailable(promise)` for promise-based code that may reject
+ * - `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
@@ -148,9 +170,9 @@ export declare function createFailable<T, E>(value: FailableLike<T, E>, normaliz
  * 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 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