@unthrown/effect 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Benoit Travers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# @unthrown/effect
+
+> [Effect](https://effect.website) interop for
+> [unthrown](https://github.com/btravstack/unthrown)'s `Result`.
+
+📖 **[Documentation](https://btravstack.github.io/unthrown/guide/interop)** ·
+[API Reference](https://btravstack.github.io/unthrown/api/effect/)
+
+```sh
+pnpm add @unthrown/effect effect
+```
+
+Effect is the one neighbour that shares unthrown's three-channel shape: an
+`Exit<A, E>` is a success or a `Cause`, and a `Cause` distinguishes a modeled
+failure (`Cause.fail` ↔ `Err`) from an unexpected one (`Cause.die` ↔ `Defect`).
+So `Result ↔ Exit` is a genuine **bijection**.
+
+```ts
+import { ok, err } from "unthrown";
+import { toExit, fromEffect, toEither } from "@unthrown/effect";
+import { Effect } from "effect";
+
+toExit(ok(1)); // Exit.succeed(1)
+toExit(err("e")); // Exit.fail("e")        — a modeled Cause.fail
+
+// Run an Effect and collect its outcome (die/interrupt become a Defect):
+await fromEffect(Effect.succeed(1)).match({ ok, err, defect: String });
+```
+
+- `toExit` / `fromExit` — the bijection: `Ok↔succeed`, `Err↔Cause.fail`,
+  `Defect↔Cause.die`. On the way back a die/interruption becomes a `Defect`, and
+  a `Defect` **dominates** a modeled failure in a composite cause (same rule as
+  `all`).
+- `toEither` / `fromEither` — `Either` has no defect channel, so `toEither(r,
+onDefect)` **forces** you to triage the defect into `E` (Thesis #3). `fromEither`
+  never yields a `Defect`.
+- `toEffect` / `fromEffect` — `toEffect` lifts a `Result` **or** `AsyncResult`
+  into an `Effect<T, E>` (`Defect → Effect.die`); `fromEffect` runs an
+  environment-free `Effect<T, E>` to an `AsyncResult<T, E>`.
+
+`effect` is a peer dependency.
+
+## License
+
+[MIT](../../LICENSE) © Benoit TRAVERS

package/dist/index.cjs

@@ -0,0 +1,145 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let effect = require("effect");
+let unthrown = require("unthrown");
+//#region src/index.ts
+/**
+* Convert a `Result` into an Effect `Exit` — a **bijection**, since both
+* carry three channels.
+*
+* @remarks
+* `Ok → Exit.succeed`, `Err → Exit.fail` (a modeled `Cause.fail`), and
+* `Defect → Exit.die` (an unexpected `Cause.die`). Round-trips with
+* {@link fromExit}.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param result - the result to convert.
+*
+* @example
+* ```ts
+* import { ok } from "unthrown";
+* import { toExit } from "@unthrown/effect";
+* toExit(ok(1)); // Exit.succeed(1)
+* ```
+*/
+function toExit(result) {
+	return result.match({
+		ok: (value) => effect.Exit.succeed(value),
+		err: (error) => effect.Exit.fail(error),
+		defect: (cause) => effect.Exit.die(cause)
+	});
+}
+/**
+* Convert an Effect `Exit` into a `Result` — the inverse of
+* {@link toExit}.
+*
+* @remarks
+* `Exit.Success → Ok`. For a failure, the enclosing `Cause` is reduced:
+*
+* - a `Cause.die` becomes a `Defect`,
+* - otherwise a `Cause.fail` becomes the modeled `Err`,
+* - a pure interruption (or empty cause) becomes a `Defect`.
+*
+* A `Defect` **dominates** a modeled failure in a composite cause — the same
+* rule unthrown's `all` uses, on the principle that an unexpected failure is the
+* more severe signal.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param exit - the exit to convert.
+*/
+function fromExit(exit) {
+	return effect.Exit.match(exit, {
+		onSuccess: (value) => (0, unthrown.ok)(value),
+		onFailure: (cause) => {
+			const die = effect.Cause.dieOption(cause);
+			if (effect.Option.isSome(die)) return dieToResult(die.value);
+			const failure = effect.Cause.failureOption(cause);
+			if (effect.Option.isSome(failure)) return (0, unthrown.err)(failure.value);
+			return dieToResult(effect.Cause.squash(cause));
+		}
+	});
+}
+/**
+* Convert a `Result` into an Effect `Either`, triaging any defect.
+*
+* @remarks
+* `Either` has no defect channel, so a `Defect` cannot pass through silently —
+* `onDefect` **must** fold its cause into a modeled error `E` (a `Left`). This
+* is the boundary-qualification rule (Thesis #3) applied on the way out:
+* `Ok → Right`, `Err → Left`, `Defect → Left(onDefect(cause))`.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param result - the result to convert.
+* @param onDefect - folds a defect's unknown cause into a modeled `E`.
+*/
+function toEither(result, onDefect) {
+	return result.match({
+		ok: (value) => effect.Either.right(value),
+		err: (error) => effect.Either.left(error),
+		defect: (cause) => effect.Either.left(onDefect(cause))
+	});
+}
+/**
+* Convert an Effect `Either` into a `Result`.
+*
+* @remarks
+* `Right → Ok`, `Left → Err`. An `Either` carries no defect, so the result is
+* never a `Defect`.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param either - the either to convert.
+*/
+function fromEither(either) {
+	return effect.Either.match(either, {
+		onLeft: (error) => (0, unthrown.err)(error),
+		onRight: (value) => (0, unthrown.ok)(value)
+	});
+}
+function toEffect(source) {
+	if (isAsyncResult(source)) return effect.Effect.flatMap(effect.Effect.promise(() => settle(source)), (result) => resultToEffect(result));
+	return resultToEffect(source);
+}
+/**
+* Run an `Effect` and collect its outcome as an `AsyncResult`.
+*
+* @remarks
+* The effect must need no environment (`R = never`). It is run to an `Exit`
+* (which never rejects), then folded with {@link fromExit}: success → `Ok`, a
+* modeled failure → `Err`, a die/interruption → `Defect`. The returned
+* `AsyncResult` never throws when awaited.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param effect - the effect to run.
+*/
+function fromEffect(effect$1) {
+	return (0, unthrown.fromSafePromise)(effect.Effect.runPromiseExit(effect$1)).flatMap((exit) => fromExit(exit));
+}
+function resultToEffect(result) {
+	return result.match({
+		ok: (value) => effect.Effect.succeed(value),
+		err: (error) => effect.Effect.fail(error),
+		defect: (cause) => effect.Effect.die(cause)
+	});
+}
+function dieToResult(cause) {
+	return (0, unthrown.fromThrowable)(() => {
+		throw cause;
+	}, unthrown.defect)();
+}
+function settle(asyncResult) {
+	return (async () => await asyncResult)();
+}
+function isAsyncResult(source) {
+	return typeof source.then === "function";
+}
+//#endregion
+exports.fromEffect = fromEffect;
+exports.fromEither = fromEither;
+exports.fromExit = fromExit;
+exports.toEffect = toEffect;
+exports.toEither = toEither;
+exports.toExit = toExit;

package/dist/index.d.cts

@@ -0,0 +1,104 @@
+import { Effect, Either, Exit } from "effect";
+import { AsyncResult, Result } from "unthrown";
+
+//#region src/index.d.ts
+/**
+ * Convert a `Result` into an Effect `Exit` — a **bijection**, since both
+ * carry three channels.
+ *
+ * @remarks
+ * `Ok → Exit.succeed`, `Err → Exit.fail` (a modeled `Cause.fail`), and
+ * `Defect → Exit.die` (an unexpected `Cause.die`). Round-trips with
+ * {@link fromExit}.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param result - the result to convert.
+ *
+ * @example
+ * ```ts
+ * import { ok } from "unthrown";
+ * import { toExit } from "@unthrown/effect";
+ * toExit(ok(1)); // Exit.succeed(1)
+ * ```
+ */
+declare function toExit<T, E>(result: Result<T, E>): Exit.Exit<T, E>;
+/**
+ * Convert an Effect `Exit` into a `Result` — the inverse of
+ * {@link toExit}.
+ *
+ * @remarks
+ * `Exit.Success → Ok`. For a failure, the enclosing `Cause` is reduced:
+ *
+ * - a `Cause.die` becomes a `Defect`,
+ * - otherwise a `Cause.fail` becomes the modeled `Err`,
+ * - a pure interruption (or empty cause) becomes a `Defect`.
+ *
+ * A `Defect` **dominates** a modeled failure in a composite cause — the same
+ * rule unthrown's `all` uses, on the principle that an unexpected failure is the
+ * more severe signal.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param exit - the exit to convert.
+ */
+declare function fromExit<T, E>(exit: Exit.Exit<T, E>): Result<T, E>;
+/**
+ * Convert a `Result` into an Effect `Either`, triaging any defect.
+ *
+ * @remarks
+ * `Either` has no defect channel, so a `Defect` cannot pass through silently —
+ * `onDefect` **must** fold its cause into a modeled error `E` (a `Left`). This
+ * is the boundary-qualification rule (Thesis #3) applied on the way out:
+ * `Ok → Right`, `Err → Left`, `Defect → Left(onDefect(cause))`.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param result - the result to convert.
+ * @param onDefect - folds a defect's unknown cause into a modeled `E`.
+ */
+declare function toEither<T, E>(result: Result<T, E>, onDefect: (cause: unknown) => E): Either.Either<T, E>;
+/**
+ * Convert an Effect `Either` into a `Result`.
+ *
+ * @remarks
+ * `Right → Ok`, `Left → Err`. An `Either` carries no defect, so the result is
+ * never a `Defect`.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param either - the either to convert.
+ */
+declare function fromEither<T, E>(either: Either.Either<T, E>): Result<T, E>;
+/**
+ * Lift a `Result` or `AsyncResult` into an `Effect`.
+ *
+ * @remarks
+ * `Ok → Effect.succeed`, `Err → Effect.fail`, `Defect → Effect.die`. The
+ * resulting `Effect` needs no environment (`R = never`). An `AsyncResult` is
+ * awaited inside the effect (it never rejects), so this is the `AsyncResult →
+ * Effect` direction too.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param source - the result, or async result, to lift.
+ */
+declare function toEffect<T, E>(source: Result<T, E>): Effect.Effect<T, E>;
+declare function toEffect<T, E>(source: AsyncResult<T, E>): Effect.Effect<T, E>;
+/**
+ * Run an `Effect` and collect its outcome as an `AsyncResult`.
+ *
+ * @remarks
+ * The effect must need no environment (`R = never`). It is run to an `Exit`
+ * (which never rejects), then folded with {@link fromExit}: success → `Ok`, a
+ * modeled failure → `Err`, a die/interruption → `Defect`. The returned
+ * `AsyncResult` never throws when awaited.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param effect - the effect to run.
+ */
+declare function fromEffect<T, E>(effect: Effect.Effect<T, E>): AsyncResult<T, E>;
+//#endregion
+export { fromEffect, fromEither, fromExit, toEffect, toEither, toExit };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;AA0CA;;;;;;;;;;;;;;;;;;iBAAgB,MAAA,OAAa,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,IAAA,CAAK,IAAA,CAAK,CAAA,EAAG,CAAA;;;;AAAC;AA2BlE;;;;;;;;;;;;;;;iBAAgB,QAAA,OAAe,IAAA,EAAM,IAAA,CAAK,IAAA,CAAK,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,CAAA,EAAG,CAAA;;;;;;;AAAC;AA4BlE;;;;;;;iBAAgB,QAAA,OACd,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,GAClB,QAAA,GAAW,KAAA,cAAmB,CAAA,GAC7B,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA;;;;;;;;;;;;iBAmBJ,UAAA,OAAiB,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,CAAA,EAAG,CAAA;;;;;;;AAnBpD;AAmBrB;;;;;;iBAoBgB,QAAA,OAAe,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA;AAAA,iBACvD,QAAA,OAAe,MAAA,EAAQ,WAAA,CAAY,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA;;;;;;;;;;;;;;iBAwB5D,UAAA,OAAiB,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,WAAA,CAAY,CAAA,EAAG,CAAA"}

package/dist/index.d.mts

@@ -0,0 +1,104 @@
+import { Effect, Either, Exit } from "effect";
+import { AsyncResult, Result } from "unthrown";
+
+//#region src/index.d.ts
+/**
+ * Convert a `Result` into an Effect `Exit` — a **bijection**, since both
+ * carry three channels.
+ *
+ * @remarks
+ * `Ok → Exit.succeed`, `Err → Exit.fail` (a modeled `Cause.fail`), and
+ * `Defect → Exit.die` (an unexpected `Cause.die`). Round-trips with
+ * {@link fromExit}.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param result - the result to convert.
+ *
+ * @example
+ * ```ts
+ * import { ok } from "unthrown";
+ * import { toExit } from "@unthrown/effect";
+ * toExit(ok(1)); // Exit.succeed(1)
+ * ```
+ */
+declare function toExit<T, E>(result: Result<T, E>): Exit.Exit<T, E>;
+/**
+ * Convert an Effect `Exit` into a `Result` — the inverse of
+ * {@link toExit}.
+ *
+ * @remarks
+ * `Exit.Success → Ok`. For a failure, the enclosing `Cause` is reduced:
+ *
+ * - a `Cause.die` becomes a `Defect`,
+ * - otherwise a `Cause.fail` becomes the modeled `Err`,
+ * - a pure interruption (or empty cause) becomes a `Defect`.
+ *
+ * A `Defect` **dominates** a modeled failure in a composite cause — the same
+ * rule unthrown's `all` uses, on the principle that an unexpected failure is the
+ * more severe signal.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param exit - the exit to convert.
+ */
+declare function fromExit<T, E>(exit: Exit.Exit<T, E>): Result<T, E>;
+/**
+ * Convert a `Result` into an Effect `Either`, triaging any defect.
+ *
+ * @remarks
+ * `Either` has no defect channel, so a `Defect` cannot pass through silently —
+ * `onDefect` **must** fold its cause into a modeled error `E` (a `Left`). This
+ * is the boundary-qualification rule (Thesis #3) applied on the way out:
+ * `Ok → Right`, `Err → Left`, `Defect → Left(onDefect(cause))`.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param result - the result to convert.
+ * @param onDefect - folds a defect's unknown cause into a modeled `E`.
+ */
+declare function toEither<T, E>(result: Result<T, E>, onDefect: (cause: unknown) => E): Either.Either<T, E>;
+/**
+ * Convert an Effect `Either` into a `Result`.
+ *
+ * @remarks
+ * `Right → Ok`, `Left → Err`. An `Either` carries no defect, so the result is
+ * never a `Defect`.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param either - the either to convert.
+ */
+declare function fromEither<T, E>(either: Either.Either<T, E>): Result<T, E>;
+/**
+ * Lift a `Result` or `AsyncResult` into an `Effect`.
+ *
+ * @remarks
+ * `Ok → Effect.succeed`, `Err → Effect.fail`, `Defect → Effect.die`. The
+ * resulting `Effect` needs no environment (`R = never`). An `AsyncResult` is
+ * awaited inside the effect (it never rejects), so this is the `AsyncResult →
+ * Effect` direction too.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param source - the result, or async result, to lift.
+ */
+declare function toEffect<T, E>(source: Result<T, E>): Effect.Effect<T, E>;
+declare function toEffect<T, E>(source: AsyncResult<T, E>): Effect.Effect<T, E>;
+/**
+ * Run an `Effect` and collect its outcome as an `AsyncResult`.
+ *
+ * @remarks
+ * The effect must need no environment (`R = never`). It is run to an `Exit`
+ * (which never rejects), then folded with {@link fromExit}: success → `Ok`, a
+ * modeled failure → `Err`, a die/interruption → `Defect`. The returned
+ * `AsyncResult` never throws when awaited.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param effect - the effect to run.
+ */
+declare function fromEffect<T, E>(effect: Effect.Effect<T, E>): AsyncResult<T, E>;
+//#endregion
+export { fromEffect, fromEither, fromExit, toEffect, toEither, toExit };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;AA0CA;;;;;;;;;;;;;;;;;;iBAAgB,MAAA,OAAa,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,IAAA,CAAK,IAAA,CAAK,CAAA,EAAG,CAAA;;;;AAAC;AA2BlE;;;;;;;;;;;;;;;iBAAgB,QAAA,OAAe,IAAA,EAAM,IAAA,CAAK,IAAA,CAAK,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,CAAA,EAAG,CAAA;;;;;;;AAAC;AA4BlE;;;;;;;iBAAgB,QAAA,OACd,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,GAClB,QAAA,GAAW,KAAA,cAAmB,CAAA,GAC7B,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA;;;;;;;;;;;;iBAmBJ,UAAA,OAAiB,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,CAAA,EAAG,CAAA;;;;;;;AAnBpD;AAmBrB;;;;;;iBAoBgB,QAAA,OAAe,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA;AAAA,iBACvD,QAAA,OAAe,MAAA,EAAQ,WAAA,CAAY,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA;;;;;;;;;;;;;;iBAwB5D,UAAA,OAAiB,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,WAAA,CAAY,CAAA,EAAG,CAAA"}

package/dist/index.mjs

@@ -0,0 +1,141 @@
+import { Cause, Effect, Either, Exit, Option } from "effect";
+import { defect, err, fromSafePromise, fromThrowable, ok } from "unthrown";
+//#region src/index.ts
+/**
+* Convert a `Result` into an Effect `Exit` — a **bijection**, since both
+* carry three channels.
+*
+* @remarks
+* `Ok → Exit.succeed`, `Err → Exit.fail` (a modeled `Cause.fail`), and
+* `Defect → Exit.die` (an unexpected `Cause.die`). Round-trips with
+* {@link fromExit}.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param result - the result to convert.
+*
+* @example
+* ```ts
+* import { ok } from "unthrown";
+* import { toExit } from "@unthrown/effect";
+* toExit(ok(1)); // Exit.succeed(1)
+* ```
+*/
+function toExit(result) {
+	return result.match({
+		ok: (value) => Exit.succeed(value),
+		err: (error) => Exit.fail(error),
+		defect: (cause) => Exit.die(cause)
+	});
+}
+/**
+* Convert an Effect `Exit` into a `Result` — the inverse of
+* {@link toExit}.
+*
+* @remarks
+* `Exit.Success → Ok`. For a failure, the enclosing `Cause` is reduced:
+*
+* - a `Cause.die` becomes a `Defect`,
+* - otherwise a `Cause.fail` becomes the modeled `Err`,
+* - a pure interruption (or empty cause) becomes a `Defect`.
+*
+* A `Defect` **dominates** a modeled failure in a composite cause — the same
+* rule unthrown's `all` uses, on the principle that an unexpected failure is the
+* more severe signal.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param exit - the exit to convert.
+*/
+function fromExit(exit) {
+	return Exit.match(exit, {
+		onSuccess: (value) => ok(value),
+		onFailure: (cause) => {
+			const die = Cause.dieOption(cause);
+			if (Option.isSome(die)) return dieToResult(die.value);
+			const failure = Cause.failureOption(cause);
+			if (Option.isSome(failure)) return err(failure.value);
+			return dieToResult(Cause.squash(cause));
+		}
+	});
+}
+/**
+* Convert a `Result` into an Effect `Either`, triaging any defect.
+*
+* @remarks
+* `Either` has no defect channel, so a `Defect` cannot pass through silently —
+* `onDefect` **must** fold its cause into a modeled error `E` (a `Left`). This
+* is the boundary-qualification rule (Thesis #3) applied on the way out:
+* `Ok → Right`, `Err → Left`, `Defect → Left(onDefect(cause))`.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param result - the result to convert.
+* @param onDefect - folds a defect's unknown cause into a modeled `E`.
+*/
+function toEither(result, onDefect) {
+	return result.match({
+		ok: (value) => Either.right(value),
+		err: (error) => Either.left(error),
+		defect: (cause) => Either.left(onDefect(cause))
+	});
+}
+/**
+* Convert an Effect `Either` into a `Result`.
+*
+* @remarks
+* `Right → Ok`, `Left → Err`. An `Either` carries no defect, so the result is
+* never a `Defect`.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param either - the either to convert.
+*/
+function fromEither(either) {
+	return Either.match(either, {
+		onLeft: (error) => err(error),
+		onRight: (value) => ok(value)
+	});
+}
+function toEffect(source) {
+	if (isAsyncResult(source)) return Effect.flatMap(Effect.promise(() => settle(source)), (result) => resultToEffect(result));
+	return resultToEffect(source);
+}
+/**
+* Run an `Effect` and collect its outcome as an `AsyncResult`.
+*
+* @remarks
+* The effect must need no environment (`R = never`). It is run to an `Exit`
+* (which never rejects), then folded with {@link fromExit}: success → `Ok`, a
+* modeled failure → `Err`, a die/interruption → `Defect`. The returned
+* `AsyncResult` never throws when awaited.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param effect - the effect to run.
+*/
+function fromEffect(effect) {
+	return fromSafePromise(Effect.runPromiseExit(effect)).flatMap((exit) => fromExit(exit));
+}
+function resultToEffect(result) {
+	return result.match({
+		ok: (value) => Effect.succeed(value),
+		err: (error) => Effect.fail(error),
+		defect: (cause) => Effect.die(cause)
+	});
+}
+function dieToResult(cause) {
+	return fromThrowable(() => {
+		throw cause;
+	}, defect)();
+}
+function settle(asyncResult) {
+	return (async () => await asyncResult)();
+}
+function isAsyncResult(source) {
+	return typeof source.then === "function";
+}
+//#endregion
+export { fromEffect, fromEither, fromExit, toEffect, toEither, toExit };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["// @unthrown/effect — interop between unthrown's `Result`/`AsyncResult` and\n// Effect's `Exit`, `Either`, and `Effect`.\n//\n// Effect is the one neighbour that shares unthrown's three-channel shape: an\n// `Exit<A, E>` is `Success` | `Failure(Cause)`, and a `Cause` distinguishes a\n// modeled failure (`Cause.fail`, ↔ `Err`) from an unexpected one (`Cause.die`,\n// ↔ `Defect`). So `Result ↔ Exit` is a genuine bijection — the showcase here.\n//\n//   import { ok } from \"unthrown\";\n//   import { toExit, fromEffect } from \"@unthrown/effect\";\n//\n//   toExit(ok(1));                 // Exit.succeed(1)\n//   await fromEffect(Effect.succeed(1)).match({ ok, err, defect });\n//\n// `Either` has only two channels, so converting a `Result` *into* an `Either`\n// forces you to triage the defect with `onDefect` (Thesis #3): there is no\n// silent path that drops it.\n\nimport { Cause, Effect, Either, Exit, Option } from \"effect\";\nimport { defect, err, fromSafePromise, fromThrowable, ok } from \"unthrown\";\nimport type { AsyncResult, Result } from \"unthrown\";\n\n/**\n * Convert a `Result` into an Effect `Exit` — a **bijection**, since both\n * carry three channels.\n *\n * @remarks\n * `Ok → Exit.succeed`, `Err → Exit.fail` (a modeled `Cause.fail`), and\n * `Defect → Exit.die` (an unexpected `Cause.die`). Round-trips with\n * {@link fromExit}.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param result - the result to convert.\n *\n * @example\n * ```ts\n * import { ok } from \"unthrown\";\n * import { toExit } from \"@unthrown/effect\";\n * toExit(ok(1)); // Exit.succeed(1)\n * ```\n */\nexport function toExit<T, E>(result: Result<T, E>): Exit.Exit<T, E> {\n  return result.match<Exit.Exit<T, E>>({\n    ok: (value) => Exit.succeed(value),\n    err: (error) => Exit.fail(error),\n    defect: (cause) => Exit.die(cause),\n  });\n}\n\n/**\n * Convert an Effect `Exit` into a `Result` — the inverse of\n * {@link toExit}.\n *\n * @remarks\n * `Exit.Success → Ok`. For a failure, the enclosing `Cause` is reduced:\n *\n * - a `Cause.die` becomes a `Defect`,\n * - otherwise a `Cause.fail` becomes the modeled `Err`,\n * - a pure interruption (or empty cause) becomes a `Defect`.\n *\n * A `Defect` **dominates** a modeled failure in a composite cause — the same\n * rule unthrown's `all` uses, on the principle that an unexpected failure is the\n * more severe signal.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param exit - the exit to convert.\n */\nexport function fromExit<T, E>(exit: Exit.Exit<T, E>): Result<T, E> {\n  return Exit.match(exit, {\n    onSuccess: (value) => ok(value),\n    onFailure: (cause) => {\n      const die = Cause.dieOption(cause);\n      if (Option.isSome(die)) return dieToResult<T, E>(die.value);\n      const failure = Cause.failureOption(cause);\n      if (Option.isSome(failure)) return err(failure.value);\n      // No modeled failure and no die: a pure interruption (or empty cause).\n      return dieToResult<T, E>(Cause.squash(cause));\n    },\n  });\n}\n\n/**\n * Convert a `Result` into an Effect `Either`, triaging any defect.\n *\n * @remarks\n * `Either` has no defect channel, so a `Defect` cannot pass through silently —\n * `onDefect` **must** fold its cause into a modeled error `E` (a `Left`). This\n * is the boundary-qualification rule (Thesis #3) applied on the way out:\n * `Ok → Right`, `Err → Left`, `Defect → Left(onDefect(cause))`.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param result - the result to convert.\n * @param onDefect - folds a defect's unknown cause into a modeled `E`.\n */\nexport function toEither<T, E>(\n  result: Result<T, E>,\n  onDefect: (cause: unknown) => E,\n): Either.Either<T, E> {\n  return result.match<Either.Either<T, E>>({\n    ok: (value) => Either.right(value),\n    err: (error) => Either.left(error),\n    defect: (cause) => Either.left(onDefect(cause)),\n  });\n}\n\n/**\n * Convert an Effect `Either` into a `Result`.\n *\n * @remarks\n * `Right → Ok`, `Left → Err`. An `Either` carries no defect, so the result is\n * never a `Defect`.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param either - the either to convert.\n */\nexport function fromEither<T, E>(either: Either.Either<T, E>): Result<T, E> {\n  return Either.match(either, {\n    onLeft: (error) => err(error),\n    onRight: (value) => ok(value),\n  });\n}\n\n/**\n * Lift a `Result` or `AsyncResult` into an `Effect`.\n *\n * @remarks\n * `Ok → Effect.succeed`, `Err → Effect.fail`, `Defect → Effect.die`. The\n * resulting `Effect` needs no environment (`R = never`). An `AsyncResult` is\n * awaited inside the effect (it never rejects), so this is the `AsyncResult →\n * Effect` direction too.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param source - the result, or async result, to lift.\n */\nexport function toEffect<T, E>(source: Result<T, E>): Effect.Effect<T, E>;\nexport function toEffect<T, E>(source: AsyncResult<T, E>): Effect.Effect<T, E>;\nexport function toEffect<T, E>(source: Result<T, E> | AsyncResult<T, E>): Effect.Effect<T, E> {\n  if (isAsyncResult(source)) {\n    return Effect.flatMap(\n      Effect.promise(() => settle(source)),\n      (result) => resultToEffect(result),\n    );\n  }\n  return resultToEffect(source);\n}\n\n/**\n * Run an `Effect` and collect its outcome as an `AsyncResult`.\n *\n * @remarks\n * The effect must need no environment (`R = never`). It is run to an `Exit`\n * (which never rejects), then folded with {@link fromExit}: success → `Ok`, a\n * modeled failure → `Err`, a die/interruption → `Defect`. The returned\n * `AsyncResult` never throws when awaited.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param effect - the effect to run.\n */\nexport function fromEffect<T, E>(effect: Effect.Effect<T, E>): AsyncResult<T, E> {\n  return fromSafePromise(Effect.runPromiseExit(effect)).flatMap((exit) => fromExit(exit));\n}\n\nfunction resultToEffect<T, E>(result: Result<T, E>): Effect.Effect<T, E> {\n  return result.match<Effect.Effect<T, E>>({\n    ok: (value) => Effect.succeed(value),\n    err: (error) => Effect.fail(error),\n    defect: (cause) => Effect.die(cause),\n  });\n}\n\n// Effect's `die`/interruption channel is an un-triaged failure crossing into\n// unthrown; replaying it through the throwable boundary lands it in the `Defect`\n// state — the sanctioned (boundary-only) way to mint a defect `Result`.\nfunction dieToResult<T, E>(cause: unknown): Result<T, E> {\n  return fromThrowable<[], never, never>((): never => {\n    throw cause;\n  }, defect)();\n}\n\nfunction settle<T, E>(asyncResult: AsyncResult<T, E>): Promise<Result<T, E>> {\n  return (async () => await asyncResult)();\n}\n\nfunction isAsyncResult<T, E>(\n  source: Result<T, E> | AsyncResult<T, E>,\n): source is AsyncResult<T, E> {\n  return typeof (source as { then?: unknown }).then === \"function\";\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,OAAa,QAAuC;CAClE,OAAO,OAAO,MAAuB;EACnC,KAAK,UAAU,KAAK,QAAQ,KAAK;EACjC,MAAM,UAAU,KAAK,KAAK,KAAK;EAC/B,SAAS,UAAU,KAAK,IAAI,KAAK;CACnC,CAAC;AACH;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,SAAe,MAAqC;CAClE,OAAO,KAAK,MAAM,MAAM;EACtB,YAAY,UAAU,GAAG,KAAK;EAC9B,YAAY,UAAU;GACpB,MAAM,MAAM,MAAM,UAAU,KAAK;GACjC,IAAI,OAAO,OAAO,GAAG,GAAG,OAAO,YAAkB,IAAI,KAAK;GAC1D,MAAM,UAAU,MAAM,cAAc,KAAK;GACzC,IAAI,OAAO,OAAO,OAAO,GAAG,OAAO,IAAI,QAAQ,KAAK;GAEpD,OAAO,YAAkB,MAAM,OAAO,KAAK,CAAC;EAC9C;CACF,CAAC;AACH;;;;;;;;;;;;;;;AAgBA,SAAgB,SACd,QACA,UACqB;CACrB,OAAO,OAAO,MAA2B;EACvC,KAAK,UAAU,OAAO,MAAM,KAAK;EACjC,MAAM,UAAU,OAAO,KAAK,KAAK;EACjC,SAAS,UAAU,OAAO,KAAK,SAAS,KAAK,CAAC;CAChD,CAAC;AACH;;;;;;;;;;;;AAaA,SAAgB,WAAiB,QAA2C;CAC1E,OAAO,OAAO,MAAM,QAAQ;EAC1B,SAAS,UAAU,IAAI,KAAK;EAC5B,UAAU,UAAU,GAAG,KAAK;CAC9B,CAAC;AACH;AAiBA,SAAgB,SAAe,QAA+D;CAC5F,IAAI,cAAc,MAAM,GACtB,OAAO,OAAO,QACZ,OAAO,cAAc,OAAO,MAAM,CAAC,IAClC,WAAW,eAAe,MAAM,CACnC;CAEF,OAAO,eAAe,MAAM;AAC9B;;;;;;;;;;;;;;AAeA,SAAgB,WAAiB,QAAgD;CAC/E,OAAO,gBAAgB,OAAO,eAAe,MAAM,CAAC,CAAC,CAAC,SAAS,SAAS,SAAS,IAAI,CAAC;AACxF;AAEA,SAAS,eAAqB,QAA2C;CACvE,OAAO,OAAO,MAA2B;EACvC,KAAK,UAAU,OAAO,QAAQ,KAAK;EACnC,MAAM,UAAU,OAAO,KAAK,KAAK;EACjC,SAAS,UAAU,OAAO,IAAI,KAAK;CACrC,CAAC;AACH;AAKA,SAAS,YAAkB,OAA8B;CACvD,OAAO,oBAA6C;EAClD,MAAM;CACR,GAAG,MAAM,CAAC,CAAC;AACb;AAEA,SAAS,OAAa,aAAuD;CAC3E,QAAQ,YAAY,MAAM,YAAA,CAAa;AACzC;AAEA,SAAS,cACP,QAC6B;CAC7B,OAAO,OAAQ,OAA8B,SAAS;AACxD"}

package/docs/index.md

@@ -0,0 +1,270 @@
+**@unthrown/effect**
+
+***
+
+# @unthrown/effect
+
+## Functions
+
+### fromEffect()
+
+```ts
+function fromEffect<T, E>(effect): AsyncResult<T, E>;
+```
+
+Defined in: index.ts:165
+
+Run an `Effect` and collect its outcome as an `AsyncResult`.
+
+#### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `T` | the success value type. |
+| `E` | the modeled error type. |
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `effect` | `Effect`&lt;`T`, `E`&gt; | the effect to run. |
+
+#### Returns
+
+`AsyncResult`&lt;`T`, `E`&gt;
+
+#### Remarks
+
+The effect must need no environment (`R = never`). It is run to an `Exit`
+(which never rejects), then folded with [fromExit](#fromexit): success → `Ok`, a
+modeled failure → `Err`, a die/interruption → `Defect`. The returned
+`AsyncResult` never throws when awaited.
+
+***
+
+### fromEither()
+
+```ts
+function fromEither<T, E>(either): Result<T, E>;
+```
+
+Defined in: index.ts:120
+
+Convert an Effect `Either` into a `Result`.
+
+#### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `T` | the success value type. |
+| `E` | the modeled error type. |
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `either` | `Either`&lt;`T`, `E`&gt; | the either to convert. |
+
+#### Returns
+
+`Result`&lt;`T`, `E`&gt;
+
+#### Remarks
+
+`Right → Ok`, `Left → Err`. An `Either` carries no defect, so the result is
+never a `Defect`.
+
+***
+
+### fromExit()
+
+```ts
+function fromExit<T, E>(exit): Result<T, E>;
+```
+
+Defined in: index.ts:70
+
+Convert an Effect `Exit` into a `Result` — the inverse of
+[toExit](#toexit).
+
+#### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `T` | the success value type. |
+| `E` | the modeled error type. |
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `exit` | `Exit`&lt;`T`, `E`&gt; | the exit to convert. |
+
+#### Returns
+
+`Result`&lt;`T`, `E`&gt;
+
+#### Remarks
+
+`Exit.Success → Ok`. For a failure, the enclosing `Cause` is reduced:
+
+- a `Cause.die` becomes a `Defect`,
+- otherwise a `Cause.fail` becomes the modeled `Err`,
+- a pure interruption (or empty cause) becomes a `Defect`.
+
+A `Defect` **dominates** a modeled failure in a composite cause — the same
+rule unthrown's `all` uses, on the principle that an unexpected failure is the
+more severe signal.
+
+***
+
+### toEffect()
+
+#### Call Signature
+
+```ts
+function toEffect<T, E>(source): Effect<T, E>;
+```
+
+Defined in: index.ts:140
+
+Lift a `Result` or `AsyncResult` into an `Effect`.
+
+##### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `T` | the success value type. |
+| `E` | the modeled error type. |
+
+##### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `source` | `Result`&lt;`T`, `E`&gt; | the result, or async result, to lift. |
+
+##### Returns
+
+`Effect`&lt;`T`, `E`&gt;
+
+##### Remarks
+
+`Ok → Effect.succeed`, `Err → Effect.fail`, `Defect → Effect.die`. The
+resulting `Effect` needs no environment (`R = never`). An `AsyncResult` is
+awaited inside the effect (it never rejects), so this is the `AsyncResult →
+Effect` direction too.
+
+#### Call Signature
+
+```ts
+function toEffect<T, E>(source): Effect<T, E>;
+```
+
+Defined in: index.ts:141
+
+Lift a `Result` or `AsyncResult` into an `Effect`.
+
+##### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `T` | the success value type. |
+| `E` | the modeled error type. |
+
+##### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `source` | `AsyncResult`&lt;`T`, `E`&gt; | the result, or async result, to lift. |
+
+##### Returns
+
+`Effect`&lt;`T`, `E`&gt;
+
+##### Remarks
+
+`Ok → Effect.succeed`, `Err → Effect.fail`, `Defect → Effect.die`. The
+resulting `Effect` needs no environment (`R = never`). An `AsyncResult` is
+awaited inside the effect (it never rejects), so this is the `AsyncResult →
+Effect` direction too.
+
+***
+
+### toEither()
+
+```ts
+function toEither<T, E>(result, onDefect): Either<T, E>;
+```
+
+Defined in: index.ts:98
+
+Convert a `Result` into an Effect `Either`, triaging any defect.
+
+#### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `T` | the success value type. |
+| `E` | the modeled error type. |
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `result` | `Result`&lt;`T`, `E`&gt; | the result to convert. |
+| `onDefect` | (`cause`) => `E` | folds a defect's unknown cause into a modeled `E`. |
+
+#### Returns
+
+`Either`&lt;`T`, `E`&gt;
+
+#### Remarks
+
+`Either` has no defect channel, so a `Defect` cannot pass through silently —
+`onDefect` **must** fold its cause into a modeled error `E` (a `Left`). This
+is the boundary-qualification rule (Thesis #3) applied on the way out:
+`Ok → Right`, `Err → Left`, `Defect → Left(onDefect(cause))`.
+
+***
+
+### toExit()
+
+```ts
+function toExit<T, E>(result): Exit<T, E>;
+```
+
+Defined in: index.ts:43
+
+Convert a `Result` into an Effect `Exit` — a **bijection**, since both
+carry three channels.
+
+#### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `T` | the success value type. |
+| `E` | the modeled error type. |
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `result` | `Result`&lt;`T`, `E`&gt; | the result to convert. |
+
+#### Returns
+
+`Exit`&lt;`T`, `E`&gt;
+
+#### Remarks
+
+`Ok → Exit.succeed`, `Err → Exit.fail` (a modeled `Cause.fail`), and
+`Defect → Exit.die` (an unexpected `Cause.die`). Round-trips with
+[fromExit](#fromexit).
+
+#### Example
+
+```ts
+import { ok } from "unthrown";
+import { toExit } from "@unthrown/effect";
+toExit(ok(1)); // Exit.succeed(1)
+```

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@unthrown/effect",
+  "version": "0.1.0",
+  "description": "Effect interop for unthrown",
+  "keywords": [
+    "effect",
+    "either",
+    "errors-as-values",
+    "exit",
+    "result",
+    "typescript",
+    "unthrown"
+  ],
+  "homepage": "https://github.com/btravstack/unthrown#readme",
+  "bugs": {
+    "url": "https://github.com/btravstack/unthrown/issues"
+  },
+  "license": "MIT",
+  "author": "Benoit TRAVERS <benoit.travers.fr@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/btravstack/unthrown.git",
+    "directory": "packages/effect"
+  },
+  "files": [
+    "dist",
+    "docs"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "unthrown": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.2",
+    "@vitest/coverage-v8": "4.1.8",
+    "effect": "3.21.4",
+    "tsdown": "0.22.2",
+    "typedoc": "0.28.19",
+    "typedoc-plugin-markdown": "4.12.0",
+    "typescript": "6.0.3",
+    "vitest": "4.1.8",
+    "@unthrown/typedoc": "0.1.0",
+    "@unthrown/tsconfig": "0.1.0"
+  },
+  "peerDependencies": {
+    "effect": "^3"
+  },
+  "engines": {
+    "node": ">=22.19"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --format cjs,esm --dts --clean",
+    "build:docs": "typedoc",
+    "dev": "tsdown src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}