@onrails/result 0.4.2 → 0.5.0

package/DESIGN.md

@@ -29,6 +29,17 @@ type Result<T, E> =
 - Optional dot-chaining via `fluent(r)` in `@onrails/result/fluent`. Mirrors every instance-appropriate core transform; `test/parity.spec.ts` enforces the mirror (both directions) across core, fluent, and the neverthrow compat shim. `ResultAsync` is already fluent (its methods return `ResultAsync`) — no `fluentAsync` wrapper; wrapping it would just be a one-line delegate to itself.
 - The fluent wrapper stays local: `fluent(r)` opens and a terminal (`toResult`/`toString`/`match`/`unwrapOr`) closes within one expression — it's a closure over data, not data, so it must never be a return type, an exported binding, a stored field, or an argument to a serialize/`postMessage`/cache call. `@onrails/eslint-plugin` and `@onrails/biome-plugin` enforce this via `fluent-stays-local` (RFC 0002 §9).
 
+## Prototype carriers (breaking)
+
+`ok` / `err` return live carriers: `_tag` plus `value` / `error` as own enumerable properties, with `map`, `mapErr`, `flatMap`/`andThen`, `recover`, `tap`, `tapErr`, `match` and `unwrapOr` on a shared non-enumerable prototype (`src/internal/proto.ts`). `r.map(f).flatMap(g)` works on any core `Result`, with core semantics (`tap` propagates throws, `recover` keeps `T`). The neverthrow-semantics names (`andTee`, `orElse`, ...) stay in compat.
+
+- **Serialization:** `JSON.stringify` output is unchanged (same keys, same order). `JSON.parse`, `structuredClone`, spread and `postMessage` return plain data without the methods, while the type still claims them. Lift at every such sink with `Result.from`. `ResultData<T, E>` is the plain shape `from` accepts. Suite `test/prototype-core.spec.ts` covers all four routes.
+- **Literals:** a hand-written `{ _tag: "Ok", value }` is no longer a `Result` (it lacks the methods). `onrails-codemod --literals` rewrites them to `ok` / `err`.
+- **Narrowed branches:** `Err<T, E>` now carries `T` through its methods, so returning a narrowed `Err` as a `Result` with a different `T` needs `err(r.error)` (the same as neverthrow).
+- **Redux, immer:** carriers are not plain objects (prototype is not `Object.prototype`). Redux Toolkit's serializability check flags them, and immer will not draft them. Store `ResultData` (or call `Result.from` on read) and convert at the edge.
+- **Compat shim:** `CompatResult` still wraps a core carrier (`inner`) and now delegates `map`, `mapErr`, `andThen` and `unwrapOr` to the prototype methods. It cannot collapse into the core carrier: its semantics differ by design (`orElse` widens, `andTee` swallows throws, `value` / `error` getters throw), and the differential suite (`neverthrow-diff.spec.ts`) pins exactly that.
+- **Packages:** `result` does not know `maybe`. `Maybe` has the mirrored prototype and `Maybe.from`; `toResult` / `fromResult` stay in `@onrails/maybe/interop`.
+
 ## Sync / async interop
 
 Two distinct lift paths:
@@ -102,7 +113,7 @@ Use `flatMap` for dependent checks where later checks need earlier successful va
 
 ## v1.0 gate
 
-- bun tests: core ops, FL functor/monad laws (sync), neverthrow-compat fixtures.
+- bun tests: core ops, functor/monad/error-functor laws on `Result` and `ResultAsync` (`test/result.laws.spec.ts`), JSON and `structuredClone` round-trips, and a neverthrow differential (`test/neverthrow-diff.spec.ts`): a surface diff against the installed package plus randomised op chains run through both libraries.
 - README with tagged-error guidance.
 - **Not** in v1.0: npm publish.
 

package/README.md

@@ -356,6 +356,25 @@ Both cap at **12 steps**. That cap is deliberate: a single recursive variadic si
 
 ## Breaking changes
 
+### Carriers have methods; plain data needs `Result.from`
+
+`ok` / `err` (and `some` / `none` in `@onrails/maybe`) now return carriers with `map`, `mapErr`, `flatMap` / `andThen`, `recover`, `tap`, `tapErr`, `match` and `unwrapOr` on a non-enumerable prototype, so `ok(2).map(f).flatMap(g)` works with no wrapper. `_tag` and `value` / `error` are still the only own keys, and `JSON.stringify` output is byte-identical. The module functions (`map(r, f)`, `map(f)(r)`) are unchanged.
+
+| Before | After |
+|---|---|
+| `{ _tag: "Ok", value: x }` | `ok(x)` — run `onrails-codemod <dir> --literals` |
+| `{ _tag: "Err", error: e }` | `err(e)` |
+| `{ _tag: "Some", value: x }` / `{ _tag: "None" }` | `some(x)` / `none()` |
+| `JSON.parse(raw) as Result<T, E>` | `Result.from<T, E>(JSON.parse(raw))` |
+| `structuredClone(r)` used as a `Result` | `Result.from(structuredClone(r))` |
+| `if (isErr(r)) return r;` returning a different `T` | `if (isErr(r)) return err(r.error);` |
+
+`JSON.parse`, `structuredClone`, object spread, `postMessage` and IndexedDB hand back plain data without the methods, while the type still claims them. `Result.from` (and `Maybe.from`) lift it back; `ResultData<T, E>` / `MaybeData<T>` name the plain shape. `@onrails/eslint-plugin` and `@onrails/biome-plugin` ship `carrier-sinks-need-from` to flag the cast forms.
+
+**Redux Toolkit.** Carriers are not plain objects (their prototype is not `Object.prototype`), so the serializability middleware warns on them in actions and state. Keep `ResultData` / `MaybeData` in the store and call `Result.from` / `Maybe.from` in selectors,. Both are cheap: `from` is one allocation.
+
+**immer.** `produce` only drafts plain objects and arrays, so a carrier inside state is treated as an opaque value: replace it wholesale (`draft.user = ok(next)`), do not mutate through it. Carriers are never mutated by the library, so sharing them across drafts is safe.
+
 ### `ok` / `err` lock inline literals
 
 Inline literals no longer widen: `ok("a")` is `Result<"a", never>` and `err({ kind: "io" })` carries `{ readonly kind: "io" }`. Annotated values and generic type parameters are unaffected. One call shape needs a change:
@@ -405,7 +424,28 @@ import { ResultAsync, Result, ok, err, okAsync, errAsync } from "@onrails/result
 - `Result` / `ResultAsync` are class-shaped (`CompatResult` / `CompatResultAsync`).
 - `await ra` resolves to a `CompatResult<T, E>` (thenable), so `.isOk()`, `.value`, `.error`, `.match()`, `.unwrapOr()` all work without an extra `.resolve()` call.
 - `andThen` / `chain` / `flatMap` / `orElse` accept any of `CompatResultAsync` / `ResultAsync` / `CompatResult` / tagged `Result` returns and union the error type.
-- Supported: `andThen`, `asyncAndThen`, `chain`, `flatMap`, `map`, `mapErr`, `orElse`, `match`, `unwrapOr`, `isOk`, `isErr`, `andTee`, `orTee`, `Result.combine`, `Result.fromThrowable`, `ResultAsync.combine`, `ResultAsync.fromPromise`, `ResultAsync.fromSafePromise`, `ResultAsync.fromThrowable`, `_unsafeUnwrap` / `_unsafeUnwrapErr`.
+- Supported: every public member of neverthrow 8.x. `bun test` diffs the shim's surface against the real package (`test/neverthrow-diff.spec.ts`), so a new neverthrow member fails CI until it is covered.
+- Guards: `isOk()` / `isErr()` are type guards; `.value` / `.error` are visible only after narrowing, as in neverthrow. The `else` branch of an `isOk()` check is not narrowed to the error side (the shim is one class, not an `Ok | Err` union) — use `match` or `isErr()`.
+- `Ok` / `Err` support `new` and `instanceof`; `safeTry` accepts sync and async generators using `.safeUnwrap()`.
+
+#### Compat name to core name
+
+| neverthrow / compat | core (`@onrails/result`) | Notes |
+|---|---|---|
+| `r.map(f)` / `r.mapErr(f)` | `map(r, f)` / `mapErr(r, f)` | same |
+| `r.andThen(f)` / `chain` / `flatMap` | `flatMap(r, f)` | `flatMap` is canonical |
+| `r.orElse(f)` | `recover(r, f)` | |
+| `r.andTee(f)` / `r.orTee(f)` | `tap(r, f)` / `tapErr(r, f)` | `tap` takes a pure side effect; compat also swallows a throwing callback, core does not |
+| `r.andThrough(f)` | `flatMap(r, (v) => map(f(v), () => v))` | keeps the original `Ok` value, surfaces the callback's `Err` |
+| `r.asyncMap(f)` | `ResultAsync.fromResult(r).map(f)` | |
+| `r.match(ok, err)` | `match(r, ok, err)` | |
+| `r.unwrapOr(d)` | `unwrapOr(r, d)` | |
+| `r._unsafeUnwrap()` | `unwrapOk(r)` | assertion tier |
+| `Result.fromThrowable(f, h)` | `fromThrowable(f, h)` | |
+| `Result.combine` / `combineWithAllErrors` | `combineTuple` / `validateTuple` | |
+| `safeTry(function* () { ... })` | `tryGen(() => { ... })` | `yield* r.safeUnwrap()` becomes `$(r)`; `tryGen` is sync, use `ResultAsync` chains for async bodies |
+| `ok(1) instanceof Ok` | `isOk(r)` | |
+
 - Treat the compat surface as a migration step, not the destination — once a package migrates, switch its imports to `@onrails/result` and `@onrails/result/fluent`.
 
 ## Subpaths
@@ -421,4 +461,8 @@ import { ResultAsync, Result, ok, err, okAsync, errAsync } from "@onrails/result
 | `@onrails/result/try-gen` | `tryGen`, `yieldResult`, `$` |
 | `@onrails/result/compat/neverthrow` | Migration shim |
 
+## Benchmarks
+
+Runtime + fair import-graph size vs `neverthrow`: see [`../bench/RESULTS.md`](../bench/RESULTS.md). Regenerated with `bun run bench:md` from the repo root.
+
 See [DESIGN.md](./DESIGN.md).

package/dist/compat/neverthrow.cjs

@@ -1,14 +1,88 @@
 'use strict';
 
-// src/internal/ctor.ts
-var mkOk = (value) => ({
-  _tag: "Ok",
-  value
-});
-var mkErr = (error) => ({
-  _tag: "Err",
-  error
-});
+// src/internal/proto.ts
+var INSPECT = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var OkImpl = class _OkImpl {
+  _tag;
+  value;
+  // explicit assignment order keeps `_tag` first, so JSON key order matches the plain-data shape
+  constructor(value) {
+    this._tag = "Ok";
+    this.value = value;
+  }
+  [INSPECT](_depth, options, inspect) {
+    return `Ok(${inspect(this.value, options)})`;
+  }
+  map(fn) {
+    return new _OkImpl(fn(this.value));
+  }
+  mapErr(_fn) {
+    return new _OkImpl(this.value);
+  }
+  flatMap(fn) {
+    return fn(this.value);
+  }
+  andThen(fn) {
+    return fn(this.value);
+  }
+  recover(_fn) {
+    return new _OkImpl(this.value);
+  }
+  tap(fn) {
+    fn(this.value);
+    return this;
+  }
+  tapErr(_fn) {
+    return this;
+  }
+  match(onOk, _onErr) {
+    return onOk(this.value);
+  }
+  unwrapOr(_defaultValue) {
+    return this.value;
+  }
+};
+var ErrImpl = class _ErrImpl {
+  _tag;
+  error;
+  constructor(error) {
+    this._tag = "Err";
+    this.error = error;
+  }
+  [INSPECT](_depth, options, inspect) {
+    return `Err(${inspect(this.error, options)})`;
+  }
+  map(_fn) {
+    return new _ErrImpl(this.error);
+  }
+  mapErr(fn) {
+    return new _ErrImpl(fn(this.error));
+  }
+  flatMap(_fn) {
+    return new _ErrImpl(this.error);
+  }
+  andThen(_fn) {
+    return new _ErrImpl(this.error);
+  }
+  recover(fn) {
+    return fn(this.error);
+  }
+  tap(_fn) {
+    return this;
+  }
+  tapErr(fn) {
+    fn(this.error);
+    return this;
+  }
+  match(_onOk, onErr) {
+    return onErr(this.error);
+  }
+  unwrapOr(defaultValue) {
+    return defaultValue;
+  }
+};
+var newOk = (value) => new OkImpl(value);
+var newErr = (error) => new ErrImpl(error);
 
 // src/internal/dual.ts
 var dual = (arity, body) => {
@@ -22,30 +96,22 @@ var isOk = (result) => result._tag === "Ok";
 var isErr = (result) => result._tag === "Err";
 var map = dual(
   2,
-  (result, fn) => isOk(result) ? mkOk(fn(result.value)) : mkErr(result.error)
+  (result, fn) => isOk(result) ? newOk(fn(result.value)) : newErr(result.error)
 );
 var mapErr = dual(
   2,
-  (result, fn) => isErr(result) ? mkErr(fn(result.error)) : mkOk(result.value)
+  (result, fn) => isErr(result) ? newErr(fn(result.error)) : newOk(result.value)
 );
 var bimap = dual(
   3,
-  (result, onOk, onErr) => isOk(result) ? mkOk(onOk(result.value)) : mkErr(onErr(result.error))
-);
-var flatMap = dual(
-  2,
-  (result, fn) => isOk(result) ? fn(result.value) : mkErr(result.error)
-);
-var unwrapOr = dual(
-  2,
-  (result, defaultValue) => isOk(result) ? result.value : defaultValue
+  (result, onOk, onErr) => isOk(result) ? newOk(onOk(result.value)) : newErr(onErr(result.error))
 );
 function fromThrowable(fn, onThrow) {
   return (...args) => {
     try {
-      return mkOk(fn(...args));
+      return newOk(fn(...args));
     } catch (error) {
-      return mkErr(onThrow(error));
+      return newErr(onThrow(error));
     }
   };
 }
@@ -65,11 +131,11 @@ var sequenceSettled = (settled) => {
   const values = [];
   for (const result of settled) {
     if (isErr(result)) {
-      return mkErr(result.error);
+      return newErr(result.error);
     }
     values.push(result.value);
   }
-  return mkOk(values);
+  return newOk(values);
 };
 var ResultAsync = class _ResultAsync {
   constructor(run) {
@@ -106,9 +172,9 @@ var ResultAsync = class _ResultAsync {
   static fromPromise(promise, onReject) {
     return new _ResultAsync(async () => {
       try {
-        return mkOk(await promise);
+        return newOk(await promise);
       } catch (error) {
-        return mkErr(onReject(error));
+        return newErr(onReject(error));
       }
     });
   }
@@ -122,7 +188,7 @@ var ResultAsync = class _ResultAsync {
    * ```
    */
   static fromSafePromise(promise) {
-    return new _ResultAsync(async () => mkOk(await promise));
+    return new _ResultAsync(async () => newOk(await promise));
   }
   /**
    * Defers work until {@link resolve}. Unlike {@link fromPromise}, the factory
@@ -140,13 +206,13 @@ var ResultAsync = class _ResultAsync {
     return new _ResultAsync(fn);
   }
   static ok(value) {
-    return new _ResultAsync(async () => mkOk(value));
+    return new _ResultAsync(async () => newOk(value));
   }
   static of(value) {
     return _ResultAsync.ok(value);
   }
   static err(error) {
-    return new _ResultAsync(async () => mkErr(error));
+    return new _ResultAsync(async () => newErr(error));
   }
   /**
    * Lifts an existing `Promise<Result<T, E>>` (e.g. from interop code) into a
@@ -164,7 +230,7 @@ var ResultAsync = class _ResultAsync {
       try {
         return await promise;
       } catch (error) {
-        return mkErr(mapDefect(error));
+        return newErr(mapDefect(error));
       }
     });
   }
@@ -186,11 +252,11 @@ var ResultAsync = class _ResultAsync {
       for (const ra of results) {
         const result = await ra.resolve();
         if (isErr(result)) {
-          return mkErr(result.error);
+          return newErr(result.error);
         }
         values.push(result.value);
       }
-      return mkOk(values);
+      return newOk(values);
     });
   }
   /**
@@ -285,7 +351,7 @@ var ResultAsync = class _ResultAsync {
     return new _ResultAsync(async () => {
       const first = await this.resolve();
       if (isErr(first)) {
-        return first;
+        return newErr(first.error);
       }
       const next = fn(first.value);
       return next instanceof _ResultAsync ? next.resolve() : next;
@@ -317,7 +383,7 @@ var ResultAsync = class _ResultAsync {
     return new _ResultAsync(async () => {
       const first = await this.resolve();
       if (!isErr(first)) {
-        return first;
+        return newOk(first.value);
       }
       const next = fn(first.error);
       return next instanceof _ResultAsync ? next.resolve() : next;
@@ -438,15 +504,29 @@ var ResultAsync = class _ResultAsync {
 var combine = (results) => {
   const values = [];
   for (const result of results) {
-    if (isErr(result)) return mkErr(result.error);
+    if (isErr(result)) return newErr(result.error);
     values.push(result.value);
   }
-  return mkOk(values);
+  return newOk(values);
 };
 var combineTuple = (results, ..._guard) => (
   // Runtime identical to combine; the cast restores per-index tuple types.
+  // `unknown` hop: the tuple type is computed from R, which TS cannot relate to the runtime array.
   combine(results)
 );
+function validateAll(results, combineErrors) {
+  const values = [];
+  const errors = [];
+  for (const result of results) {
+    if (isErr(result)) {
+      errors.push(result.error);
+    } else {
+      values.push(result.value);
+    }
+  }
+  if (errors.length === 0) return newOk(values);
+  return newErr(errors);
+}
 
 // src/compat/neverthrow.ts
 var CompatResult = class _CompatResult {
@@ -463,11 +543,12 @@ var CompatResult = class _CompatResult {
       combineTuple(results.map((r) => r.inner))
     );
   }
-  get value() {
-    return this._unsafeUnwrap();
-  }
-  get error() {
-    return this._unsafeUnwrapErr();
+  // The `as unknown as` casts below restore per-index tuple types computed from R, which TS cannot
+  // relate to the runtime arrays.
+  static combineWithAllErrors(results) {
+    return new _CompatResult(
+      validateAll(results.map((r) => r.inner))
+    );
   }
   isOk() {
     return isOk(this.inner);
@@ -476,25 +557,68 @@ var CompatResult = class _CompatResult {
     return isErr(this.inner);
   }
   map(fn) {
-    return new _CompatResult(map(this.inner, fn));
+    return new _CompatResult(this.inner.map(fn));
   }
   mapErr(fn) {
-    return new _CompatResult(mapErr(this.inner, fn));
+    return new _CompatResult(this.inner.mapErr(fn));
   }
   andThen(fn) {
-    return new _CompatResult(flatMap(this.inner, (value) => fn(value).inner));
+    return new _CompatResult(this.inner.flatMap((value) => fn(value).inner));
   }
   asyncAndThen(fn) {
     return isErr(this.inner) ? CompatResultAsync.err(this.inner.error) : CompatResultAsync.fromInner(coerceToCoreAsync(fn(this.inner.value)));
   }
   orElse(fn) {
-    return isOk(this.inner) ? new _CompatResult(this.inner) : fn(this.inner.error);
+    return isOk(this.inner) ? new _CompatResult(newOk(this.inner.value)) : fn(this.inner.error);
   }
   match(onOk, onErr) {
     return isOk(this.inner) ? onOk(this.inner.value) : onErr(this.inner.error);
   }
   unwrapOr(defaultValue) {
-    return unwrapOr(this.inner, defaultValue);
+    return this.inner.unwrapOr(defaultValue);
+  }
+  andTee(fn) {
+    if (isOk(this.inner)) {
+      try {
+        fn(this.inner.value);
+      } catch {
+      }
+    }
+    return this;
+  }
+  orTee(fn) {
+    if (isErr(this.inner)) {
+      try {
+        fn(this.inner.error);
+      } catch {
+      }
+    }
+    return this;
+  }
+  andThrough(fn) {
+    if (isErr(this.inner)) return this;
+    const through = fn(this.inner.value).inner;
+    return isErr(through) ? new _CompatResult(newErr(through.error)) : this;
+  }
+  asyncAndThrough(fn) {
+    const inner = this.inner;
+    return CompatResultAsync.fromInner(
+      ResultAsync.defer(async () => {
+        if (isErr(inner)) return inner;
+        const through = await coerceToCoreAsync(fn(inner.value)).resolve();
+        return isErr(through) ? newErr(through.error) : inner;
+      })
+    );
+  }
+  asyncMap(fn) {
+    return isErr(this.inner) ? CompatResultAsync.err(this.inner.error) : CompatResultAsync.fromSafePromise(fn(this.inner.value));
+  }
+  /** Yields the `Err` to {@link safeTry} on failure; returns the `Ok` value otherwise. */
+  *safeUnwrap() {
+    if (isErr(this.inner)) {
+      yield new _CompatResult(newErr(this.inner.error));
+    }
+    return this._unsafeUnwrap();
   }
   _unsafeUnwrap() {
     if (isErr(this.inner)) {
@@ -510,8 +634,34 @@ var CompatResult = class _CompatResult {
   }
 };
 var Result = CompatResult;
-var ok = (value) => new CompatResult(mkOk(value));
-var err = (error) => new CompatResult(mkErr(error));
+var ok = (value) => new CompatResult(newOk(value));
+var err = (error) => new CompatResult(newErr(error));
+Object.defineProperty(CompatResult.prototype, "value", {
+  get() {
+    return this._unsafeUnwrap();
+  }
+});
+Object.defineProperty(CompatResult.prototype, "error", {
+  get() {
+    return this._unsafeUnwrapErr();
+  }
+});
+var Ok = class extends CompatResult {
+  constructor(value) {
+    super(newOk(value));
+  }
+  static [Symbol.hasInstance](candidate) {
+    return candidate instanceof CompatResult && isOk(candidate.inner);
+  }
+};
+var Err = class extends CompatResult {
+  constructor(error) {
+    super(newErr(error));
+  }
+  static [Symbol.hasInstance](candidate) {
+    return candidate instanceof CompatResult && isErr(candidate.inner);
+  }
+};
 var CompatResultAsync = class _CompatResultAsync {
   constructor(inner) {
     this.inner = inner;
@@ -543,6 +693,13 @@ var CompatResultAsync = class _CompatResultAsync {
       ResultAsync.combine(results.map((r) => r.inner))
     );
   }
+  static combineWithAllErrors(results) {
+    return new _CompatResultAsync(
+      ResultAsync.defer(
+        async () => validateAll(await Promise.all(results.map((r) => r.resolve())))
+      )
+    );
+  }
   // biome-ignore lint/suspicious/noThenProperty: thenable shim for `await ra` -> CompatResult
   then(onfulfilled, onrejected) {
     return this.inner.resolve().then((r) => {
@@ -607,6 +764,21 @@ var CompatResultAsync = class _CompatResultAsync {
       })
     );
   }
+  andThrough(fn) {
+    return new _CompatResultAsync(
+      ResultAsync.defer(async () => {
+        const r = await this.inner.resolve();
+        if (isErr(r)) return r;
+        const next = coerceToCore(fn(r.value));
+        const through = next instanceof ResultAsync ? await next.resolve() : next;
+        return isErr(through) ? newErr(through.error) : r;
+      })
+    );
+  }
+  /** Async twin of {@link CompatResult.safeUnwrap}. */
+  async *safeUnwrap() {
+    return yield* new CompatResult(await this.inner.resolve()).safeUnwrap();
+  }
   orTee(fn) {
     return new _CompatResultAsync(
       ResultAsync.defer(async () => {
@@ -629,20 +801,34 @@ function coerceToCore(next) {
   return next;
 }
 var coerceToCoreAsync = (next) => next instanceof CompatResultAsync ? next.toCore() : next;
+function safeTry(body) {
+  const step = body().next();
+  if (step instanceof Promise) {
+    return CompatResultAsync.fromInner(ResultAsync.defer(async () => (await step).value.inner));
+  }
+  return step.value;
+}
 var okAsync = CompatResultAsync.ok;
 var errAsync = CompatResultAsync.err;
 var fromPromise = CompatResultAsync.fromPromise;
 var fromSafePromise = CompatResultAsync.fromSafePromise;
+var fromThrowable2 = CompatResult.fromThrowable;
+var fromAsyncThrowable = CompatResultAsync.fromThrowable;
 
 exports.CompatResult = CompatResult;
 exports.CompatResultAsync = CompatResultAsync;
+exports.Err = Err;
+exports.Ok = Ok;
 exports.Result = Result;
 exports.ResultAsync = CompatResultAsync;
 exports.err = err;
 exports.errAsync = errAsync;
+exports.fromAsyncThrowable = fromAsyncThrowable;
 exports.fromPromise = fromPromise;
 exports.fromSafePromise = fromSafePromise;
+exports.fromThrowable = fromThrowable2;
 exports.ok = ok;
 exports.okAsync = okAsync;
+exports.safeTry = safeTry;
 //# sourceMappingURL=neverthrow.cjs.map
 //# sourceMappingURL=neverthrow.cjs.map