reylo-effect-tooling 0.0.0-stage → 0.5.0

package/dist/host.d.ts

@@ -0,0 +1,17 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Context, Effect, Layer, ManagedRuntime, Semaphore } from "effect";
+declare const EngineLock_base: Context.ServiceClass<EngineLock, "reylo-effect/EngineLock", Semaphore.Semaphore>;
+/**
+ * The wasm engine is one mutable memory, so analysis holds this one-permit lock. This module
+ * stays external in every bundle, so a process has one lock and one runtime.
+ */
+export declare class EngineLock extends EngineLock_base {
+    static readonly layer: Layer.Layer<EngineLock>;
+}
+/** Run `effect` while holding the engine. Sections do not nest: the lock is not reentrant. */
+export declare const exclusive: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | EngineLock>;
+export type HostServices = EngineLock | NodeServices.NodeServices;
+export declare const HostLayer: Layer.Layer<HostServices>;
+/** The process-wide runtime that bundler hooks, the loader, and the content mapper run on. */
+export declare const host: ManagedRuntime.ManagedRuntime<HostServices, never>;
+export {};

package/dist/host.js

@@ -0,0 +1,20 @@
+// src/host.ts
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Context, Layer, ManagedRuntime, Semaphore } from "effect";
+var EngineLock = class _EngineLock extends Context.Service()(
+  "reylo-effect/EngineLock"
+) {
+  static layer = Layer.effect(_EngineLock, Semaphore.make(1));
+};
+var exclusive = (effect) => EngineLock.use((lock) => lock.withPermits(1)(effect));
+var HostLayer = Layer.mergeAll(
+  EngineLock.layer,
+  NodeServices.layer
+);
+var host = ManagedRuntime.make(HostLayer);
+export {
+  EngineLock,
+  HostLayer,
+  exclusive,
+  host
+};