@effectionx/effect-ts 0.1.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright 2024 The Frontside Software, Inc
+
+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,266 @@
+# Effect-TS
+
+Bidirectional interop between [Effect-TS](https://effect.website/) and [Effection](https://frontside.com/effection).
+
+## Why?
+
+Effect and Effection are both powerful libraries for managing side effects in TypeScript,
+but they have different philosophies and strengths:
+
+| Feature | Effect | Effection |
+|---------|--------|-----------|
+| **Concurrency Model** | Fiber-based with supervision | Structured concurrency with scopes |
+| **Error Handling** | Type-safe errors in signature | JavaScript throw/catch |
+| **Dependencies** | Context/Layer system | Context API |
+| **Syntax** | Generator or pipe-based | Generator-based |
+| **Resource Management** | Scope with finalizers | Automatic cleanup on scope exit |
+
+This package lets you use both together:
+
+- **Use Effect inside Effection** when you want Effect's type-safe error handling
+  or need to use Effect-based libraries within Effection's structured concurrency
+- **Use Effection inside Effect** when you want Effection's simple generator syntax
+  or need to use Effection-based libraries within an Effect application
+
+## Installation
+
+```bash
+npm install @effectionx/effect-ts
+```
+
+**Peer dependencies:** Both `effect` (^3) and `effection` (^3 || ^4) must be installed.
+
+## Effection Host - Effect Guest
+
+Use `makeEffectRuntime()` to run Effect programs inside Effection operations.
+
+### Basic Usage
+
+```ts
+import { main } from "effection";
+import { Effect } from "effect";
+import { makeEffectRuntime } from "@effectionx/effect-ts";
+
+await main(function* () {
+  // Create the Effect runtime (automatically disposed when scope ends)
+  const runtime = yield* makeEffectRuntime();
+
+  // Run Effect programs
+  const result = yield* runtime.run(
+    Effect.succeed(42).pipe(Effect.map(n => n * 2))
+  );
+
+  console.log(result); // 84
+});
+```
+
+### Error Handling
+
+Effect failures are thrown as JavaScript errors when using `run()`:
+
+```ts
+import { main } from "effection";
+import { Effect } from "effect";
+import { makeEffectRuntime } from "@effectionx/effect-ts";
+
+await main(function* () {
+  const runtime = yield* makeEffectRuntime();
+
+  try {
+    yield* runtime.run(Effect.fail(new Error("boom")));
+  } catch (error) {
+    console.log(error.message); // "boom"
+  }
+});
+```
+
+For type-safe error handling, use `runExit()` which returns an `Exit<A, E>`:
+
+```ts
+import { main } from "effection";
+import { Effect, Exit } from "effect";
+import { makeEffectRuntime } from "@effectionx/effect-ts";
+
+await main(function* () {
+  const runtime = yield* makeEffectRuntime();
+
+  const exit = yield* runtime.runExit(Effect.fail(new Error("boom")));
+
+  if (Exit.isFailure(exit)) {
+    // Access the full Cause<E> with error details
+    console.log(exit.cause);
+  } else {
+    // Access the success value
+    console.log(exit.value);
+  }
+});
+```
+
+### With Effect Services
+
+You can provide an Effect Layer to pre-configure services:
+
+```ts
+import { main } from "effection";
+import { Effect, Context, Layer } from "effect";
+import { makeEffectRuntime } from "@effectionx/effect-ts";
+
+// Define a service
+class Logger extends Context.Tag("Logger")<Logger, {
+  log: (msg: string) => Effect.Effect<void>
+}>() {}
+
+const LoggerLive = Layer.succeed(Logger, {
+  log: (msg) => Effect.sync(() => console.log(msg))
+});
+
+await main(function* () {
+  // Provide layer to the runtime
+  const runtime = yield* makeEffectRuntime(LoggerLive);
+
+  // Effects can now use Logger without explicit provide
+  yield* runtime.run(
+    Effect.gen(function* () {
+      const logger = yield* Logger;
+      yield* logger.log("Hello!");
+    })
+  );
+});
+```
+
+Compose multiple layers using Effect's primitives:
+
+```ts
+const AppLayer = Layer.mergeAll(DatabaseLive, LoggerLive, CacheLive);
+const runtime = yield* makeEffectRuntime(AppLayer);
+```
+
+### Cancellation
+
+When an Effection scope is halted, any running Effect programs are interrupted:
+
+```ts
+import { main, spawn, sleep } from "effection";
+import { Effect } from "effect";
+import { makeEffectRuntime } from "@effectionx/effect-ts";
+
+await main(function* () {
+  const runtime = yield* makeEffectRuntime();
+
+  const task = yield* spawn(function* () {
+    yield* runtime.run(
+      Effect.gen(function* () {
+        yield* Effect.addFinalizer(() => Effect.log("Effect interrupted!"));
+        yield* Effect.sleep("10 seconds");
+      }).pipe(Effect.scoped)
+    );
+  });
+
+  yield* sleep(100);
+  // Task is automatically halted when main scope ends
+  // Effect finalizer runs: "Effect interrupted!"
+});
+```
+
+## Effect Host - Effection Guest
+
+Use `makeEffectionRuntime()` to run Effection operations inside Effect programs.
+
+### Basic Usage
+
+```ts
+import { Effect } from "effect";
+import { sleep } from "effection";
+import { makeEffectionRuntime, EffectionRuntime } from "@effectionx/effect-ts";
+
+const program = Effect.gen(function* () {
+  const runtime = yield* EffectionRuntime;
+
+  const result = yield* runtime.run(function* () {
+    yield* sleep(100);
+    return "hello from effection";
+  });
+
+  return result.toUpperCase();
+});
+
+const result = await Effect.runPromise(
+  program.pipe(
+    Effect.provide(makeEffectionRuntime()),
+    Effect.scoped
+  )
+);
+
+console.log(result); // "HELLO FROM EFFECTION"
+```
+
+### Error Handling
+
+Errors thrown in Effection operations become `UnknownException` in Effect:
+
+```ts
+import { Effect, Exit } from "effect";
+import { makeEffectionRuntime, EffectionRuntime } from "@effectionx/effect-ts";
+
+const program = Effect.gen(function* () {
+  const runtime = yield* EffectionRuntime;
+
+  return yield* runtime.run(function* () {
+    throw new Error("boom");
+  });
+});
+
+const exit = await Effect.runPromiseExit(
+  program.pipe(
+    Effect.provide(makeEffectionRuntime()),
+    Effect.scoped
+  )
+);
+
+// exit is Exit.Failure with UnknownException containing the error
+if (Exit.isFailure(exit)) {
+  console.log("Failed:", exit.cause);
+}
+```
+
+### Cancellation
+
+When the Effect scope ends or is interrupted, the Effection scope is closed:
+
+```ts
+import { Effect, Fiber } from "effect";
+import { suspend } from "effection";
+import { makeEffectionRuntime, EffectionRuntime } from "@effectionx/effect-ts";
+
+const program = Effect.gen(function* () {
+  const runtime = yield* EffectionRuntime;
+
+  const fiber = yield* runtime.run(function* () {
+    try {
+      yield* suspend();
+    } finally {
+      console.log("Effection cleanup!");
+    }
+  }).pipe(Effect.fork);
+
+  yield* Effect.sleep("100 millis");
+  yield* Fiber.interrupt(fiber);
+  // Logs: "Effection cleanup!"
+});
+
+await Effect.runPromise(
+  program.pipe(
+    Effect.provide(makeEffectionRuntime()),
+    Effect.scoped
+  )
+);
+```
+
+## Comparison
+
+| Aspect | Effection Host | | Effect Host |
+|--------|----------------|---|-------------|
+| **Method** | `EffectRuntime.run()` | `EffectRuntime.runExit()` | `EffectionRuntime.run()` |
+| **Error Handling** | Throws JS error | Returns `Exit<A, E>` | Returns `UnknownException` |
+| **Use When** | Simple cases | Need typed errors | Using Effection in Effect |
+| **Cancellation** | Effection halt → Effect interrupt | Same | Effect interrupt → Effection halt |

package/dist/effect-runtime.d.ts

@@ -0,0 +1,96 @@
+import { type Effect, type Exit, Layer } from "effect";
+import { type Operation } from "effection";
+/**
+ * A runtime for executing Effect programs inside Effection operations.
+ *
+ * @typeParam R - The services/context provided by this runtime (from the layer)
+ */
+export interface EffectRuntime<R = never> {
+    /**
+     * Run an Effect program and return its result as an Effection Operation.
+     *
+     * Effect failures will be thrown as JavaScript errors.
+     *
+     * @param effect - The Effect program to run
+     * @returns An Operation that yields the Effect's success value
+     * @throws The Effect's error `E` if it fails
+     *
+     * @example
+     * ```ts
+     * const runtime = yield* makeEffectRuntime();
+     * const result = yield* runtime.run(Effect.succeed(42));
+     * // result = 42
+     * ```
+     */
+    run<A, E>(effect: Effect.Effect<A, E, R>): Operation<A>;
+    /**
+     * Run an Effect program and return its Exit (success or failure).
+     *
+     * Unlike `run()`, this does not throw on failure. Instead, it returns
+     * an `Exit<A, E>` that you can inspect to determine success or failure.
+     * This preserves Effect's full error model including the Cause.
+     *
+     * @param effect - The Effect program to run
+     * @returns An Operation that yields the Effect's Exit
+     *
+     * @example
+     * ```ts
+     * const runtime = yield* makeEffectRuntime();
+     * const exit = yield* runtime.runExit(Effect.fail(new Error("boom")));
+     * if (Exit.isFailure(exit)) {
+     *   console.log(exit.cause); // Full Cause<E> with error details
+     * } else {
+     *   console.log(exit.value); // Success value
+     * }
+     * ```
+     */
+    runExit<A, E>(effect: Effect.Effect<A, E, R>): Operation<Exit.Exit<A, E>>;
+}
+/**
+ * Create an EffectRuntime resource that manages an Effect ManagedRuntime.
+ *
+ * The ManagedRuntime is automatically disposed when the Effection scope ends,
+ * ensuring proper cleanup of Effect resources.
+ *
+ * @param layer - Optional Effect Layer to provide services. Defaults to `Layer.empty`.
+ *                Users can compose multiple layers using Effect's `Layer.merge()`,
+ *                `Layer.mergeAll()`, or `Layer.provide()` before passing.
+ * @returns An Operation that yields the EffectRuntime
+ *
+ * @example Basic usage
+ * ```ts
+ * import { run } from "effection";
+ * import { Effect } from "effect";
+ * import { makeEffectRuntime } from "@effectionx/effect";
+ *
+ * await run(function* () {
+ *   const runtime = yield* makeEffectRuntime();
+ *   const result = yield* runtime.run(Effect.succeed(42));
+ *   console.log(result); // 42
+ * });
+ * ```
+ *
+ * @example With services
+ * ```ts
+ * import { Layer, Context, Effect } from "effect";
+ *
+ * class Logger extends Context.Tag("Logger")<Logger, { log: (msg: string) => Effect.Effect<void> }>() {}
+ * const LoggerLive = Layer.succeed(Logger, { log: (msg) => Effect.log(msg) });
+ *
+ * await run(function* () {
+ *   const runtime = yield* makeEffectRuntime(LoggerLive);
+ *   yield* runtime.run(Effect.gen(function* () {
+ *     const logger = yield* Logger;
+ *     yield* logger.log("Hello!");
+ *   }));
+ * });
+ * ```
+ *
+ * @example Composing multiple layers
+ * ```ts
+ * const AppLayer = Layer.mergeAll(DatabaseLive, LoggerLive, CacheLive);
+ * const runtime = yield* makeEffectRuntime(AppLayer);
+ * ```
+ */
+export declare function makeEffectRuntime<R = never>(layer?: Layer.Layer<R, never, never>): Operation<EffectRuntime<R>>;
+//# sourceMappingURL=effect-runtime.d.ts.map

package/dist/effect-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-runtime.d.ts","sourceRoot":"","sources":["../effect-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,IAAI,EAAE,KAAK,EAAkB,MAAM,QAAQ,CAAC;AACvE,OAAO,EAAE,KAAK,SAAS,EAA0B,MAAM,WAAW,CAAC;AAEnE;;;;GAIG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,KAAK;IACtC;;;;;;;;;;;;;;;OAeG;IACH,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;IAExD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;CAC3E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,GAAG,KAAK,EACzC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,GACnC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAoC7B"}

package/dist/effect-runtime.js

@@ -0,0 +1,77 @@
+import { Layer, ManagedRuntime } from "effect";
+import { action, call, resource } from "effection";
+/**
+ * Create an EffectRuntime resource that manages an Effect ManagedRuntime.
+ *
+ * The ManagedRuntime is automatically disposed when the Effection scope ends,
+ * ensuring proper cleanup of Effect resources.
+ *
+ * @param layer - Optional Effect Layer to provide services. Defaults to `Layer.empty`.
+ *                Users can compose multiple layers using Effect's `Layer.merge()`,
+ *                `Layer.mergeAll()`, or `Layer.provide()` before passing.
+ * @returns An Operation that yields the EffectRuntime
+ *
+ * @example Basic usage
+ * ```ts
+ * import { run } from "effection";
+ * import { Effect } from "effect";
+ * import { makeEffectRuntime } from "@effectionx/effect";
+ *
+ * await run(function* () {
+ *   const runtime = yield* makeEffectRuntime();
+ *   const result = yield* runtime.run(Effect.succeed(42));
+ *   console.log(result); // 42
+ * });
+ * ```
+ *
+ * @example With services
+ * ```ts
+ * import { Layer, Context, Effect } from "effect";
+ *
+ * class Logger extends Context.Tag("Logger")<Logger, { log: (msg: string) => Effect.Effect<void> }>() {}
+ * const LoggerLive = Layer.succeed(Logger, { log: (msg) => Effect.log(msg) });
+ *
+ * await run(function* () {
+ *   const runtime = yield* makeEffectRuntime(LoggerLive);
+ *   yield* runtime.run(Effect.gen(function* () {
+ *     const logger = yield* Logger;
+ *     yield* logger.log("Hello!");
+ *   }));
+ * });
+ * ```
+ *
+ * @example Composing multiple layers
+ * ```ts
+ * const AppLayer = Layer.mergeAll(DatabaseLive, LoggerLive, CacheLive);
+ * const runtime = yield* makeEffectRuntime(AppLayer);
+ * ```
+ */
+export function makeEffectRuntime(layer) {
+    return resource(function* (provide) {
+        const managedRuntime = ManagedRuntime.make(layer ?? Layer.empty);
+        const run = (effect) => {
+            return action((resolve, reject) => {
+                const controller = new AbortController();
+                managedRuntime
+                    .runPromise(effect, { signal: controller.signal })
+                    .then(resolve, reject);
+                return () => controller.abort();
+            });
+        };
+        const runExit = (effect) => {
+            return action((resolve, reject) => {
+                const controller = new AbortController();
+                managedRuntime
+                    .runPromiseExit(effect, { signal: controller.signal })
+                    .then(resolve, reject);
+                return () => controller.abort();
+            });
+        };
+        try {
+            yield* provide({ run, runExit });
+        }
+        finally {
+            yield* call(() => managedRuntime.dispose());
+        }
+    });
+}

package/dist/effection-runtime.d.ts

@@ -0,0 +1,100 @@
+import { Context, Effect, Layer } from "effect";
+import type { UnknownException } from "effect/Cause";
+import { type Operation, type Scope } from "effection";
+/**
+ * A runtime for executing Effection operations inside Effect programs.
+ */
+export interface EffectionRuntime {
+    /**
+     * Run an Effection operation and return its result as an Effect.
+     *
+     * Errors thrown in the operation become `UnknownException` in Effect.
+     * The Effection scope is automatically cleaned up when the Effect completes
+     * or is interrupted.
+     *
+     * @param operation - The Effection operation (generator function) to run
+     * @returns An Effect that yields the operation's result
+     *
+     * @example
+     * ```ts
+     * const program = Effect.gen(function* () {
+     *   const runtime = yield* EffectionRuntime;
+     *   return yield* runtime.run(function* () {
+     *     yield* sleep(100);
+     *     return "hello";
+     *   });
+     * });
+     * ```
+     */
+    run<T>(operation: () => Operation<T>): Effect.Effect<T, UnknownException>;
+}
+/**
+ * Effect Context Tag for accessing the EffectionRuntime.
+ *
+ * @example
+ * ```ts
+ * const program = Effect.gen(function* () {
+ *   const runtime = yield* EffectionRuntime;
+ *   // use runtime.run(...)
+ * });
+ * ```
+ */
+export declare const EffectionRuntime: Context.Tag<EffectionRuntime, EffectionRuntime>;
+/**
+ * Create an Effect Layer that provides an EffectionRuntime.
+ *
+ * The Effection scope is automatically closed when the Effect scope ends,
+ * ensuring proper cleanup of Effection resources.
+ *
+ * @param parent - Optional parent Effection scope. If provided, the runtime's
+ *                 scope will inherit all contexts from the parent scope.
+ * @returns An Effect Layer providing EffectionRuntime
+ *
+ * @example Basic usage
+ * ```ts
+ * import { Effect } from "effect";
+ * import { sleep } from "effection";
+ * import { makeEffectionRuntime, EffectionRuntime } from "@effectionx/effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const runtime = yield* EffectionRuntime;
+ *   const result = yield* runtime.run(function* () {
+ *     yield* sleep(100);
+ *     return "hello from effection";
+ *   });
+ *   return result;
+ * });
+ *
+ * await Effect.runPromise(
+ *   program.pipe(
+ *     Effect.provide(makeEffectionRuntime()),
+ *     Effect.scoped
+ *   )
+ * );
+ * ```
+ *
+ * @example With parent scope (to inherit Effection contexts)
+ * ```ts
+ * import { Effect } from "effect";
+ * import { useScope } from "effection";
+ * import { makeEffectionRuntime, EffectionRuntime } from "@effectionx/effect";
+ *
+ * function* myOperation() {
+ *   const scope = yield* useScope();
+ *   const result = yield* call(() =>
+ *     Effect.runPromise(
+ *       Effect.gen(function* () {
+ *         const runtime = yield* EffectionRuntime;
+ *         return yield* runtime.run(function* () {
+ *           // Can access Effection contexts from parent scope
+ *           return "hello";
+ *         });
+ *       }).pipe(Effect.provide(makeEffectionRuntime(scope)), Effect.scoped)
+ *     )
+ *   );
+ *   return result;
+ * }
+ * ```
+ */
+export declare function makeEffectionRuntime(parent?: Scope): Layer.Layer<EffectionRuntime>;
+//# sourceMappingURL=effection-runtime.d.ts.map

package/dist/effection-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effection-runtime.d.ts","sourceRoot":"","sources":["../effection-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,KAAK,EAAe,MAAM,WAAW,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;CAC3E;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,iDAC6B,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,CAAC,EAAE,KAAK,GACb,KAAK,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAqB/B"}

package/dist/effection-runtime.js

@@ -0,0 +1,82 @@
+import { Context, Effect, Layer } from "effect";
+import { createScope } from "effection";
+/**
+ * Effect Context Tag for accessing the EffectionRuntime.
+ *
+ * @example
+ * ```ts
+ * const program = Effect.gen(function* () {
+ *   const runtime = yield* EffectionRuntime;
+ *   // use runtime.run(...)
+ * });
+ * ```
+ */
+export const EffectionRuntime = Context.GenericTag("EffectionRuntime");
+/**
+ * Create an Effect Layer that provides an EffectionRuntime.
+ *
+ * The Effection scope is automatically closed when the Effect scope ends,
+ * ensuring proper cleanup of Effection resources.
+ *
+ * @param parent - Optional parent Effection scope. If provided, the runtime's
+ *                 scope will inherit all contexts from the parent scope.
+ * @returns An Effect Layer providing EffectionRuntime
+ *
+ * @example Basic usage
+ * ```ts
+ * import { Effect } from "effect";
+ * import { sleep } from "effection";
+ * import { makeEffectionRuntime, EffectionRuntime } from "@effectionx/effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const runtime = yield* EffectionRuntime;
+ *   const result = yield* runtime.run(function* () {
+ *     yield* sleep(100);
+ *     return "hello from effection";
+ *   });
+ *   return result;
+ * });
+ *
+ * await Effect.runPromise(
+ *   program.pipe(
+ *     Effect.provide(makeEffectionRuntime()),
+ *     Effect.scoped
+ *   )
+ * );
+ * ```
+ *
+ * @example With parent scope (to inherit Effection contexts)
+ * ```ts
+ * import { Effect } from "effect";
+ * import { useScope } from "effection";
+ * import { makeEffectionRuntime, EffectionRuntime } from "@effectionx/effect";
+ *
+ * function* myOperation() {
+ *   const scope = yield* useScope();
+ *   const result = yield* call(() =>
+ *     Effect.runPromise(
+ *       Effect.gen(function* () {
+ *         const runtime = yield* EffectionRuntime;
+ *         return yield* runtime.run(function* () {
+ *           // Can access Effection contexts from parent scope
+ *           return "hello";
+ *         });
+ *       }).pipe(Effect.provide(makeEffectionRuntime(scope)), Effect.scoped)
+ *     )
+ *   );
+ *   return result;
+ * }
+ * ```
+ */
+export function makeEffectionRuntime(parent) {
+    return Layer.scoped(EffectionRuntime, Effect.gen(function* () {
+        const [scope, close] = createScope(parent);
+        const run = (operation) => {
+            return Effect.tryPromise(() => scope.run(operation));
+        };
+        yield* Effect.addFinalizer(() => Effect.gen(function* () {
+            yield* Effect.tryPromise(() => close()).pipe(Effect.exit);
+        }));
+        return { run };
+    }));
+}

package/dist/mod.d.ts

@@ -0,0 +1,5 @@
+export { makeEffectRuntime } from "./effect-runtime.ts";
+export type { EffectRuntime } from "./effect-runtime.ts";
+export { EffectionRuntime, makeEffectionRuntime } from "./effection-runtime.ts";
+export type { EffectionRuntime as EffectionRuntimeType } from "./effection-runtime.ts";
+//# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../mod.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAChF,YAAY,EAAE,gBAAgB,IAAI,oBAAoB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/mod.js

@@ -0,0 +1,4 @@
+// Effect -> Effection
+export { makeEffectRuntime } from "./effect-runtime.js";
+// Effection -> Effect
+export { EffectionRuntime, makeEffectionRuntime } from "./effection-runtime.js";