brass-runtime 1.15.0 → 1.16.1

package/dist/chunk-KH4SYAOS.mjs

@@ -0,0 +1,1629 @@
+import {
+  ensuring
+} from "./chunk-KN32XNTH.mjs";
+import {
+  makeScheduleDriver
+} from "./chunk-2HQTDLHF.mjs";
+import {
+  makeRuntimeEventRecord
+} from "./chunk-EJ6BPYVR.mjs";
+import {
+  Runtime,
+  getCurrentFiber,
+  liveClock,
+  runtimeClockFromEnv,
+  toPromise,
+  unsafeRunAsync
+} from "./chunk-GYM3LLGS.mjs";
+import {
+  Cause,
+  Exit,
+  asyncEffect,
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncMap,
+  asyncSucceed,
+  asyncSync,
+  unit
+} from "./chunk-36I3M4UC.mjs";
+
+// src/core/types/cancel.ts
+function makeCancelToken() {
+  let cancelled = false;
+  const listeners = /* @__PURE__ */ new Set();
+  const cancel = () => {
+    if (cancelled) return;
+    cancelled = true;
+    listeners.forEach((f) => f());
+    listeners.clear();
+  };
+  return {
+    isCancelled: () => cancelled,
+    onCancel: (f) => {
+      if (cancelled) {
+        try {
+          f();
+        } catch {
+        }
+        return () => {
+        };
+      }
+      listeners.add(f);
+      return () => {
+        listeners.delete(f);
+      };
+    },
+    cancel
+  };
+}
+function linkAbortController(token, ac) {
+  return token.onCancel(() => ac.abort());
+}
+
+// src/core/runtime/dx.ts
+function makeRuntime(env = {}, options = {}) {
+  return new Runtime({ ...options, env });
+}
+function runPromise(effect, envOrRuntime) {
+  if (envOrRuntime instanceof Runtime) return envOrRuntime.toPromise(effect);
+  return toPromise(effect, envOrRuntime);
+}
+function runExit(effect, envOrRuntime) {
+  return new Promise((resolve) => {
+    if (envOrRuntime instanceof Runtime) {
+      envOrRuntime.unsafeRunAsync(effect, resolve);
+      return;
+    }
+    unsafeRunAsync(effect, envOrRuntime, resolve);
+  });
+}
+var runEffect = runPromise;
+
+// src/core/runtime/linkedQueue.ts
+var LinkedQueue = class {
+  head = null;
+  tail = null;
+  len = 0;
+  get length() {
+    return this.len;
+  }
+  isEmpty() {
+    return this.len === 0;
+  }
+  push(value) {
+    const node = { value, next: null, prev: this.tail, removed: false };
+    if (this.tail) this.tail.next = node;
+    else this.head = node;
+    this.tail = node;
+    this.len++;
+    return node;
+  }
+  shift() {
+    const h = this.head;
+    if (!h) return void 0;
+    this.unlink(h);
+    return h.value;
+  }
+  remove(node) {
+    if (node.removed) return;
+    this.unlink(node);
+  }
+  unlink(node) {
+    node.removed = true;
+    const { prev, next } = node;
+    if (prev) prev.next = next;
+    else this.head = next;
+    if (next) next.prev = prev;
+    else this.tail = prev;
+    node.next = null;
+    node.prev = null;
+    this.len--;
+  }
+};
+
+// src/core/runtime/semaphore.ts
+function makeSemaphore(n) {
+  const capacity = Math.max(1, Math.floor(n));
+  let available = capacity;
+  let totalAcquired = 0;
+  let totalReleased = 0;
+  const waiters = new LinkedQueue();
+  const acquire = () => {
+    return asyncEffect((_env, cb) => {
+      if (available > 0) {
+        available--;
+        totalAcquired++;
+        cb({ _tag: "Success", value: void 0 });
+        return;
+      }
+      const node = waiters.push(cb);
+      return () => {
+        waiters.remove(node);
+      };
+    });
+  };
+  const release = () => {
+    totalReleased++;
+    if (waiters.length > 0) {
+      const waiter = waiters.shift();
+      totalAcquired++;
+      waiter({ _tag: "Success", value: void 0 });
+      return;
+    }
+    available++;
+  };
+  const acquirePermit = () => asyncFlatMap(
+    acquire(),
+    () => asyncEffect((_env, cb) => {
+      let released = false;
+      const releaseOnce = () => {
+        if (released) return;
+        released = true;
+        release();
+      };
+      const fiber = getCurrentFiber();
+      fiber?.addFinalizer(() => {
+        releaseOnce();
+      });
+      cb({ _tag: "Success", value: releaseOnce });
+    })
+  );
+  const withPermit = (effect) => asyncFlatMap(
+    acquirePermit(),
+    (releaseOnce) => asyncFold(
+      effect,
+      (error) => {
+        releaseOnce();
+        return asyncFail(error);
+      },
+      (value) => {
+        releaseOnce();
+        return asyncSucceed(value);
+      }
+    )
+  );
+  return {
+    capacity,
+    available: () => available,
+    waiting: () => waiters.length,
+    withPermit,
+    acquire,
+    release
+  };
+}
+
+// src/core/runtime/ref.ts
+function makeRef(initial) {
+  let value = initial;
+  return {
+    get: () => asyncSync(() => value),
+    set: (v) => asyncSync(() => {
+      value = v;
+    }),
+    update: (f) => asyncSync(() => {
+      value = f(value);
+      return value;
+    }),
+    modify: (f) => asyncSync(() => {
+      const [result, next] = f(value);
+      value = next;
+      return result;
+    }),
+    unsafeGet: () => value
+  };
+}
+function derivedRef(parent, get, set) {
+  return {
+    get: () => asyncSync(() => get(parent.unsafeGet())),
+    set: (b) => asyncFlatMap(parent.get(), (current) => parent.set(set(current, b))),
+    update: (f) => asyncFlatMap(parent.get(), (parentVal) => {
+      const newB = f(get(parentVal));
+      return asyncMap(parent.set(set(parentVal, newB)), () => newB);
+    }),
+    modify: (f) => asyncFlatMap(parent.get(), (parentVal) => {
+      const [result, newB] = f(get(parentVal));
+      return asyncMap(parent.set(set(parentVal, newB)), () => result);
+    }),
+    unsafeGet: () => get(parent.unsafeGet())
+  };
+}
+
+// src/core/runtime/shutdown.ts
+async function gracefulShutdown(runtime, config = {}) {
+  const timeoutMs = config.timeoutMs ?? 3e4;
+  const startedAt = Date.now();
+  config.onStart?.();
+  let timedOut = false;
+  const shutdownPromise = (async () => {
+    try {
+      await runtime.shutdown();
+    } catch {
+    }
+  })();
+  const timeoutPromise = new Promise((resolve) => {
+    setTimeout(() => {
+      timedOut = true;
+      resolve();
+    }, timeoutMs);
+  });
+  await Promise.race([shutdownPromise, timeoutPromise]);
+  const completedAt = Date.now();
+  const stats = {
+    startedAt,
+    completedAt,
+    elapsedMs: completedAt - startedAt,
+    timedOut
+  };
+  if (timedOut) {
+    config.onTimeout?.(stats);
+  } else {
+    config.onComplete?.(stats);
+  }
+  return stats;
+}
+function registerShutdownHooks(runtime, config = {}) {
+  let shuttingDown = false;
+  const handler = (signal) => {
+    if (shuttingDown) {
+      process.exit(1);
+    }
+    shuttingDown = true;
+    console.log(`
+[brass-runtime] Received ${signal}, shutting down gracefully...`);
+    gracefulShutdown(runtime, {
+      ...config,
+      onComplete: (stats) => {
+        config.onComplete?.(stats);
+        if (!config.onComplete) {
+          console.log(`[brass-runtime] Shutdown complete (${stats.elapsedMs}ms)`);
+          process.exit(0);
+        }
+      },
+      onTimeout: (stats) => {
+        config.onTimeout?.(stats);
+        if (!config.onTimeout) {
+          console.log(`[brass-runtime] Shutdown timed out after ${stats.elapsedMs}ms, forcing exit`);
+          process.exit(1);
+        }
+      }
+    });
+  };
+  process.on("SIGTERM", () => handler("SIGTERM"));
+  process.on("SIGINT", () => handler("SIGINT"));
+  return () => {
+    process.removeAllListeners("SIGTERM");
+    process.removeAllListeners("SIGINT");
+  };
+}
+
+// src/core/runtime/testing.ts
+var TestScheduler = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.maxSteps = options.maxSteps ?? 1e4;
+  }
+  options;
+  queue = [];
+  maxSteps;
+  autoFlushScheduled = false;
+  flushing = false;
+  enqueuedTasks = 0;
+  executedTasks = 0;
+  droppedTasks = 0;
+  scheduledFlushes = 0;
+  completedFlushes = 0;
+  schedule(task, tag = "anonymous") {
+    if (typeof task !== "function") {
+      this.droppedTasks += 1;
+      return "dropped";
+    }
+    this.queue.push({ tag, run: task });
+    this.enqueuedTasks += 1;
+    this.requestAutoFlush();
+    return "accepted";
+  }
+  scheduleBatch(tasks) {
+    return tasks.map(({ fn, tag }) => this.schedule(fn, tag));
+  }
+  stats() {
+    return {
+      engine: "ts",
+      fallbackUsed: false,
+      data: {
+        len: this.queue.length,
+        phase: this.flushing ? "flushing" : this.autoFlushScheduled ? "scheduled" : "idle",
+        scheduledFlushes: this.scheduledFlushes,
+        completedFlushes: this.completedFlushes,
+        enqueuedTasks: this.enqueuedTasks,
+        executedTasks: this.executedTasks,
+        droppedTasks: this.droppedTasks,
+        yieldedByBudget: 0,
+        lanes: [{
+          key: "test",
+          len: this.queue.length,
+          capacity: Number.POSITIVE_INFINITY,
+          enqueuedTasks: this.enqueuedTasks,
+          executedTasks: this.executedTasks,
+          droppedTasks: this.droppedTasks
+        }]
+      }
+    };
+  }
+  pending() {
+    return this.queue.slice();
+  }
+  size() {
+    return this.queue.length;
+  }
+  flush(maxTasks = 1) {
+    if (this.flushing) return 0;
+    this.flushing = true;
+    this.autoFlushScheduled = false;
+    let ran = 0;
+    try {
+      while (ran < maxTasks) {
+        const next = this.queue.shift();
+        if (!next) break;
+        ran += 1;
+        this.executedTasks += 1;
+        try {
+          next.run();
+        } catch (error) {
+          console.error(`[TestScheduler] task threw (tag=${next.tag})`, error);
+        }
+      }
+      return ran;
+    } finally {
+      this.flushing = false;
+      this.completedFlushes += ran > 0 ? 1 : 0;
+      if (this.queue.length > 0) this.requestAutoFlush();
+    }
+  }
+  flushAll(maxSteps = this.maxSteps) {
+    let ran = 0;
+    while (this.queue.length > 0) {
+      if (ran >= maxSteps) {
+        throw new Error(`TestScheduler.flushAll exceeded ${maxSteps} steps; possible runaway fiber loop`);
+      }
+      ran += this.flush(Math.max(1, maxSteps - ran));
+    }
+    return ran;
+  }
+  requestAutoFlush() {
+    const autoFlush = this.options.autoFlush ?? this.options.synchronous ?? true;
+    if (!autoFlush || this.autoFlushScheduled || this.flushing) return;
+    this.autoFlushScheduled = true;
+    this.scheduledFlushes += 1;
+    queueMicrotask(() => {
+      if (!this.autoFlushScheduled) return;
+      this.flushAll();
+    });
+  }
+};
+var TestClock = class {
+  constructor(initialTimeMs = 0, flushScheduler = () => void 0, maxSteps = 1e4) {
+    this.flushScheduler = flushScheduler;
+    this.maxSteps = maxSteps;
+    this.nowMs = Math.max(0, Math.floor(initialTimeMs));
+  }
+  flushScheduler;
+  maxSteps;
+  nowMs;
+  nextId = 1;
+  nextSeq = 1;
+  timers = /* @__PURE__ */ new Map();
+  now() {
+    return this.nowMs;
+  }
+  setTimeout(task, ms) {
+    const id = this.nextId++;
+    const delay = Math.max(0, Math.floor(ms));
+    this.timers.set(id, {
+      id,
+      dueAt: this.nowMs + delay,
+      seq: this.nextSeq++,
+      task
+    });
+    return id;
+  }
+  clearTimeout(timer) {
+    if (typeof timer === "number") this.timers.delete(timer);
+  }
+  pendingTimers() {
+    return Array.from(this.timers.values()).sort(compareTimers).map((timer) => ({
+      id: timer.id,
+      dueAt: timer.dueAt,
+      delayMs: Math.max(0, timer.dueAt - this.nowMs)
+    }));
+  }
+  adjust(ms) {
+    return this.advance(ms);
+  }
+  advance(ms) {
+    return this.advanceTo(this.nowMs + Math.max(0, Math.floor(ms)));
+  }
+  advanceTo(targetMs) {
+    const target = Math.max(this.nowMs, Math.floor(targetMs));
+    let ran = 0;
+    while (true) {
+      if (ran >= this.maxSteps) {
+        throw new Error(`TestClock.advanceTo exceeded ${this.maxSteps} timers; possible runaway timer loop`);
+      }
+      const next = this.nextDueTimer(target);
+      if (!next) break;
+      this.timers.delete(next.id);
+      this.nowMs = next.dueAt;
+      ran += 1;
+      next.task();
+      this.flushScheduler();
+    }
+    this.nowMs = target;
+    this.flushScheduler();
+    return ran;
+  }
+  runDue() {
+    return this.advanceTo(this.nowMs);
+  }
+  runAll(maxSteps = this.maxSteps) {
+    let ran = 0;
+    while (this.timers.size > 0) {
+      if (ran >= maxSteps) {
+        throw new Error(`TestClock.runAll exceeded ${maxSteps} timers; possible runaway timer loop`);
+      }
+      const next = this.nextDueTimer(Number.POSITIVE_INFINITY);
+      if (!next) break;
+      ran += this.advanceTo(next.dueAt);
+    }
+    return ran;
+  }
+  clear() {
+    this.timers.clear();
+  }
+  nextDueTimer(targetMs) {
+    let selected;
+    for (const timer of this.timers.values()) {
+      if (timer.dueAt > targetMs) continue;
+      if (!selected || compareTimers(timer, selected) < 0) selected = timer;
+    }
+    return selected;
+  }
+};
+function compareTimers(a, b) {
+  return a.dueAt === b.dueAt ? a.seq - b.seq : a.dueAt - b.dueAt;
+}
+function makeTestRuntime(env, options = {}) {
+  const scheduler = new TestScheduler(options);
+  const clock = new TestClock(options.initialTimeMs, () => scheduler.flushAll(options.maxSteps), options.maxSteps);
+  const testEnv = withTestClock(env ?? {}, clock);
+  const runtime = Runtime.makeWithEngine(testEnv, "ts", { scheduler });
+  const flush = (maxTasks) => scheduler.flush(maxTasks);
+  const flushAll = (maxSteps) => scheduler.flushAll(maxSteps);
+  const advance = (ms) => clock.advance(ms);
+  const advanceTo = (targetMs) => clock.advanceTo(targetMs);
+  const runDueTimers = () => clock.runDue();
+  const runAllTimers = (maxSteps) => clock.runAll(maxSteps);
+  const runExit2 = (effect) => {
+    const promise = new Promise((resolve) => {
+      runtime.unsafeRunAsync(effect, resolve);
+    });
+    flushAll();
+    return promise;
+  };
+  const run = async (effect) => exitToPromise(await runExit2(effect));
+  const fork = (effect) => {
+    const fiber = runtime.fork(effect);
+    flushAll();
+    return fiber;
+  };
+  return {
+    env: testEnv,
+    runtime,
+    scheduler,
+    clock,
+    run,
+    runExit: runExit2,
+    fork,
+    flush,
+    flushAll,
+    advance,
+    advanceTo,
+    runDueTimers,
+    runAllTimers
+  };
+}
+function withTestClock(env, clock) {
+  const current = env;
+  return {
+    ...env,
+    brass: {
+      ...current.brass ?? {},
+      clock
+    }
+  };
+}
+function exitToPromise(exit) {
+  if (exit._tag === "Success") return exit.value;
+  const failure = Cause.firstFailure(exit.cause);
+  if (failure._tag === "Some") throw failure.value;
+  const defect = Cause.firstDefect(exit.cause);
+  if (defect._tag === "Some") {
+    throw defect.value instanceof Error ? defect.value : new Error(String(defect.value));
+  }
+  if (Cause.containsInterrupt(exit.cause)) throw new Error("Interrupted");
+  throw Cause.toError(exit.cause);
+}
+function runExitWithRuntime(runtime, effect) {
+  return new Promise((resolve) => {
+    runtime.unsafeRunAsync(effect, resolve);
+  });
+}
+function stableJson(value) {
+  return JSON.stringify(value);
+}
+function firstFailureValue(exit) {
+  if (exit._tag !== "Failure") return void 0;
+  const failure = Cause.firstFailure(exit.cause);
+  return failure._tag === "Some" ? failure.value : void 0;
+}
+function makeAssertionRuntime(runtime) {
+  return runtime ?? Runtime.make({});
+}
+async function assertSucceeds(effect, expected, runtime) {
+  const rt = makeAssertionRuntime(runtime);
+  const exit = await runExitWithRuntime(rt, effect);
+  if (exit._tag !== "Success") {
+    throw new Error(`Expected success with ${stableJson(expected)}, got failure: ${stableJson(exit.cause)}`);
+  }
+  if (stableJson(exit.value) !== stableJson(expected)) {
+    throw new Error(`Expected ${stableJson(expected)}, got ${stableJson(exit.value)}`);
+  }
+}
+async function assertFails(effect, expectedError, runtime) {
+  const rt = makeAssertionRuntime(runtime);
+  const exit = await runExitWithRuntime(rt, effect);
+  if (exit._tag !== "Failure") {
+    throw new Error(`Expected failure with ${stableJson(expectedError)}, got success: ${stableJson(exit.value)}`);
+  }
+  const error = firstFailureValue(exit);
+  if (stableJson(error) !== stableJson(expectedError)) {
+    throw new Error(`Expected error ${stableJson(expectedError)}, got ${stableJson(error)}`);
+  }
+}
+async function assertFailsWith(effect, predicate, runtime) {
+  const rt = makeAssertionRuntime(runtime);
+  const exit = await runExitWithRuntime(rt, effect);
+  if (exit._tag !== "Failure") {
+    throw new Error(`Expected failure, got success: ${stableJson(exit.value)}`);
+  }
+  const error = firstFailureValue(exit);
+  if (error === void 0 || !predicate(error)) {
+    throw new Error(`Error did not match predicate: ${stableJson(error)}`);
+  }
+}
+async function assertCompletesWithin(effect, maxMs, runtime) {
+  const rt = makeAssertionRuntime(runtime);
+  const start = runtimeClockFromEnv(rt.env).now();
+  const result = await rt.toPromise(effect);
+  const elapsed = runtimeClockFromEnv(rt.env).now() - start;
+  if (elapsed > maxMs) {
+    throw new Error(`Effect took ${elapsed.toFixed(1)}ms, expected < ${maxMs}ms`);
+  }
+  return result;
+}
+function flakyEffect(failCount, successValue, errorValue) {
+  let calls = 0;
+  return asyncEffect((_env, cb) => {
+    calls++;
+    if (calls <= failCount) {
+      cb(Exit.failCause(Cause.fail(errorValue)));
+    } else {
+      cb(Exit.succeed(successValue));
+    }
+  });
+}
+function delayedEffect(ms, value) {
+  return asyncEffect((env, cb) => {
+    const clock = runtimeClockFromEnv(env);
+    const id = clock.setTimeout(() => cb(Exit.succeed(value)), ms);
+    return () => clock.clearTimeout(id);
+  });
+}
+function neverEffect() {
+  return asyncEffect(() => {
+    return () => {
+    };
+  });
+}
+
+// src/core/runtime/layer.ts
+var MissingLayerServiceError = class extends Error {
+  _tag = "MissingLayerService";
+  serviceName;
+  constructor(serviceName) {
+    super(`Missing layer service '${serviceName}'. Add a layer that provides this ServiceTag or pass a LayerContext containing it.`);
+    this.name = "MissingLayerServiceError";
+    this.serviceName = serviceName;
+  }
+};
+function formatLayerError(error) {
+  if (error instanceof MissingLayerServiceError) return error.message;
+  if (isObjectRecord(error) && error._tag === "MissingLayerService" && typeof error.serviceName === "string") {
+    return `Missing layer service '${error.serviceName}'. Add the provider layer before using the service.`;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function makeServiceTag(name) {
+  return {
+    _tag: "ServiceTag",
+    key: Symbol(name),
+    name
+  };
+}
+var serviceTag = makeServiceTag;
+var defineService = makeServiceTag;
+var LayerContext = class _LayerContext {
+  services;
+  constructor(entries) {
+    if (entries instanceof Map) {
+      this.services = new Map(entries);
+      return;
+    }
+    this.services = /* @__PURE__ */ new Map();
+    if (!entries) return;
+    for (const [tag, service] of entries) this.services.set(tag.key, service);
+  }
+  static empty() {
+    return new _LayerContext();
+  }
+  get(tag) {
+    return this.services.get(tag.key);
+  }
+  unsafeGet(tag) {
+    if (!this.services.has(tag.key)) {
+      throw new MissingLayerServiceError(tag.name);
+    }
+    return this.services.get(tag.key);
+  }
+  has(tag) {
+    return this.services.has(tag.key);
+  }
+  add(tag, service) {
+    const next = new Map(this.services);
+    next.set(tag.key, service);
+    return new _LayerContext(next);
+  }
+  merge(other) {
+    const next = new Map(this.services);
+    for (const [key, service] of other.services) next.set(key, service);
+    return new _LayerContext(next);
+  }
+  size() {
+    return this.services.size;
+  }
+};
+function makeLayerScope() {
+  const cache = /* @__PURE__ */ new WeakMap();
+  const finalizers = [];
+  let closed = false;
+  const scope = {
+    get: (l, deps) => {
+      if (closed) return asyncFail(new Error("LayerScope is closed"));
+      if (cache.has(l)) return asyncSucceed(cache.get(l));
+      const built = l.buildScoped ? l.buildScoped(deps, scope) : asyncFlatMap(
+        l.build(deps),
+        ({ service, release }) => asyncFlatMap(scope.addFinalizer(release), () => asyncSucceed(service))
+      );
+      return asyncFlatMap(
+        built,
+        (service) => asyncSync(() => {
+          cache.set(l, service);
+          return service;
+        })
+      );
+    },
+    close: () => {
+      if (closed) return unit();
+      closed = true;
+      return releaseAll(finalizers);
+    },
+    size: () => finalizers.length,
+    addFinalizer: (release) => asyncSync(() => {
+      if (!closed) finalizers.push(release);
+    })
+  };
+  return scope;
+}
+function releaseAll(finalizers) {
+  const next = finalizers.pop();
+  if (!next) return unit();
+  return asyncFold(
+    next(),
+    () => releaseAll(finalizers),
+    () => releaseAll(finalizers)
+  );
+}
+function mergeServices(a, b) {
+  if (a instanceof LayerContext && b instanceof LayerContext) {
+    return a.merge(b);
+  }
+  if (isObjectRecord(a) && isObjectRecord(b)) {
+    return { ...a, ...b };
+  }
+  return Object.assign({}, a, b);
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function layer(acquire, release) {
+  return {
+    _tag: "Layer",
+    build: (_deps) => asyncFlatMap(acquire(), (service) => asyncSucceed({
+      service,
+      release: release ? () => release(service) : () => unit()
+    }))
+  };
+}
+function layerValue(tag, value) {
+  return layerEffect(tag, () => asyncSucceed(value));
+}
+function layerEffect(tag, acquire, release) {
+  return {
+    _tag: "Layer",
+    build: (deps = LayerContext.empty()) => asyncFlatMap(acquire(deps), (service) => asyncSucceed({
+      service: deps.add(tag, service),
+      release: release ? () => release(service) : () => unit()
+    }))
+  };
+}
+var layerFromContext = layerEffect;
+var defineLayer = layerEffect;
+function getService(tag) {
+  return asyncSync((context) => context.unsafeGet(tag));
+}
+function layerFrom() {
+  return (acquire, release) => ({
+    _tag: "Layer",
+    build: (deps) => asyncFlatMap(acquire(deps), (service) => asyncSucceed({
+      service,
+      release: release ? () => release(service) : () => unit()
+    }))
+  });
+}
+function layerSucceed(value) {
+  return {
+    _tag: "Layer",
+    build: () => asyncSucceed({ service: value, release: () => unit() })
+  };
+}
+function layerFail(error) {
+  return {
+    _tag: "Layer",
+    build: () => asyncFail(error)
+  };
+}
+function compose(from, to) {
+  return {
+    _tag: "Layer",
+    buildScoped: (deps, scope) => asyncFlatMap(
+      scope.get(from, deps),
+      (mid) => scope.get(to, mid)
+    ),
+    build: (deps) => asyncFlatMap(
+      from.build(deps),
+      ({ service: mid, release: releaseMid }) => asyncFold(
+        to.build(mid),
+        (error) => asyncFlatMap(releaseMid(), () => asyncFail(error)),
+        ({ service: out, release: releaseOut }) => asyncSucceed({
+          service: out,
+          release: () => asyncFlatMap(releaseOut(), () => releaseMid())
+        })
+      )
+    )
+  };
+}
+function merge(left, right) {
+  return {
+    _tag: "Layer",
+    buildScoped: (deps, scope) => asyncFlatMap(
+      scope.get(left, deps),
+      (a) => asyncFlatMap(
+        scope.get(right, deps),
+        (b) => asyncSucceed(mergeServices(a, b))
+      )
+    ),
+    build: (deps) => asyncFlatMap(
+      left.build(deps),
+      ({ service: a, release: releaseA }) => asyncFold(
+        right.build(deps),
+        (error) => asyncFlatMap(releaseA(), () => asyncFail(error)),
+        ({ service: b, release: releaseB }) => asyncSucceed({
+          service: mergeServices(a, b),
+          release: () => asyncFlatMap(releaseB(), () => releaseA())
+        })
+      )
+    )
+  };
+}
+function mapLayer(l, f) {
+  return {
+    _tag: "Layer",
+    buildScoped: (deps, scope) => asyncFlatMap(
+      scope.get(l, deps),
+      (service) => asyncSucceed(f(service))
+    ),
+    build: (deps) => asyncFlatMap(
+      l.build(deps),
+      ({ service, release }) => asyncSucceed({ service: f(service), release })
+    )
+  };
+}
+function buildLayer(l, deps) {
+  const scope = makeLayerScope();
+  return asyncFold(
+    scope.get(l, deps),
+    (error) => asyncFlatMap(scope.close(), () => asyncFail(error)),
+    (service) => asyncSucceed({
+      service,
+      scope,
+      close: scope.close,
+      use: (body) => body(service)
+    })
+  );
+}
+function provideLayer(l, use, deps) {
+  return asyncFlatMap(
+    buildLayer(l, deps ?? {}),
+    ({ service, close }) => ensuring(
+      use(service),
+      () => close()
+    )
+  );
+}
+function provideLayerContext(l, use, deps = LayerContext.empty()) {
+  return provideLayer(l, use, deps);
+}
+var provide = provideLayer;
+var provideContext = provideLayerContext;
+var Layer = Object.freeze({
+  make: layer,
+  from: layerFrom,
+  succeed: layerSucceed,
+  fail: layerFail,
+  value: layerValue,
+  effect: layerEffect,
+  define: defineLayer,
+  fromContext: layerFromContext,
+  compose,
+  merge,
+  map: mapLayer,
+  provide: provideLayer,
+  provideContext: provideLayerContext,
+  build: buildLayer,
+  scope: makeLayerScope,
+  context: LayerContext.empty,
+  tag: makeServiceTag,
+  service: getService
+});
+
+// src/core/runtime/workerPool.ts
+function makeWorkerPool(config = {}) {
+  const size = config.size ?? 4;
+  const maxQueue = config.maxQueue ?? 1e3;
+  const taskTimeoutMs = config.taskTimeoutMs ?? 3e4;
+  let closed = false;
+  let busy = 0;
+  let completed = 0;
+  let failed = 0;
+  let timedOut = 0;
+  const queue = [];
+  const processNext = () => {
+    if (queue.length === 0 || busy >= size) return;
+    const task = queue.shift();
+    busy++;
+    setImmediate(() => {
+      if (task.timeoutId) clearTimeout(task.timeoutId);
+      try {
+        const result = task.fn();
+        busy--;
+        completed++;
+        task.resolve(result);
+        processNext();
+      } catch (e) {
+        busy--;
+        failed++;
+        task.reject({ _tag: "WorkerTaskError", message: String(e) });
+        processNext();
+      }
+    });
+  };
+  const execute = (fn) => {
+    if (closed) return asyncFail({ _tag: "WorkerPoolClosed" });
+    if (queue.length >= maxQueue) {
+      return asyncFail({ _tag: "WorkerPoolFull", queued: queue.length });
+    }
+    return asyncEffect((_env, cb) => {
+      const task = {
+        fn,
+        resolve: (value) => cb({ _tag: "Success", value }),
+        reject: (error) => cb({ _tag: "Failure", cause: { _tag: "Fail", error } })
+      };
+      task.timeoutId = setTimeout(() => {
+        const idx = queue.indexOf(task);
+        if (idx >= 0) {
+          queue.splice(idx, 1);
+          timedOut++;
+          task.reject({ _tag: "WorkerTaskTimeout", ms: taskTimeoutMs });
+        }
+      }, taskTimeoutMs);
+      queue.push(task);
+      processNext();
+      return () => {
+        const idx = queue.indexOf(task);
+        if (idx >= 0) {
+          queue.splice(idx, 1);
+          if (task.timeoutId) clearTimeout(task.timeoutId);
+        }
+      };
+    });
+  };
+  const run = (taskSource, args = []) => {
+    return execute(() => {
+      const fn = new Function(...args.map((_, i) => `arg${i}`), taskSource);
+      return fn(...args);
+    });
+  };
+  return {
+    execute,
+    run,
+    stats: () => ({
+      size,
+      busy,
+      idle: size - busy,
+      queued: queue.length,
+      completed,
+      failed,
+      timedOut
+    }),
+    shutdown: async () => {
+      closed = true;
+      while (queue.length > 0) {
+        const task = queue.shift();
+        if (task.timeoutId) clearTimeout(task.timeoutId);
+        task.reject({ _tag: "WorkerPoolClosed" });
+      }
+    }
+  };
+}
+
+// src/core/runtime/tracing.ts
+var idCounter = 0;
+function generateId() {
+  return (++idCounter).toString(16).padStart(16, "0");
+}
+function makeTracer(config) {
+  const completedSpans = [];
+  const sampleRate = config.sampleRate ?? 1;
+  const shouldSample = () => {
+    if (sampleRate >= 1) return true;
+    if (sampleRate <= 0) return false;
+    return Math.random() < sampleRate;
+  };
+  const span = (name, effect, attributes) => {
+    if (!shouldSample()) return effect;
+    const spanObj = {
+      name,
+      context: {
+        traceId: generateId(),
+        spanId: generateId()
+      },
+      startTime: performance.now(),
+      status: "unset",
+      attributes: { "service.name": config.serviceName, ...attributes },
+      events: []
+    };
+    return asyncFold(
+      effect,
+      (error) => {
+        spanObj.endTime = performance.now();
+        spanObj.status = "error";
+        spanObj.events.push({
+          name: "error",
+          time: performance.now(),
+          attributes: { "error.message": String(error) }
+        });
+        completedSpans.push(spanObj);
+        config.onSpanEnd?.(spanObj);
+        return asyncFail(error);
+      },
+      (value) => {
+        spanObj.endTime = performance.now();
+        spanObj.status = "ok";
+        completedSpans.push(spanObj);
+        config.onSpanEnd?.(spanObj);
+        return asyncSucceed(value);
+      }
+    );
+  };
+  return {
+    span,
+    spans: () => completedSpans,
+    clear: () => {
+      completedSpans.length = 0;
+    }
+  };
+}
+
+// src/core/runtime/loggerSink.ts
+function consoleJsonLogger() {
+  return {
+    emit(ev, ctx) {
+      if (ev.type !== "log") return;
+      const wallTs = Date.now();
+      const out = {
+        level: ev.level,
+        msg: ev.message,
+        wallTs,
+        fiberId: ctx.fiberId,
+        scopeId: ctx.scopeId,
+        traceId: ctx.traceId,
+        spanId: ctx.spanId,
+        parentSpanId: ctx.parentSpanId,
+        ...ev.fields ?? {}
+      };
+      if (ev.level === "error") console.error(JSON.stringify(out));
+      else console.log(JSON.stringify(out));
+    }
+  };
+}
+
+// src/core/runtime/registry.ts
+var RuntimeRegistry = class {
+  fibers = /* @__PURE__ */ new Map();
+  scopes = /* @__PURE__ */ new Map();
+  seq = 1;
+  recent = [];
+  recentCap = 2e3;
+  emit(ev, ctx) {
+    const rec = makeRuntimeEventRecord(ev, ctx, this.seq++);
+    this.recent.push(rec);
+    if (this.recent.length > this.recentCap) this.recent.shift();
+    switch (rec.type) {
+      case "fiber.start": {
+        const id = rec.fiberId;
+        this.fibers.set(id, {
+          fiberId: id,
+          parentFiberId: rec.parentFiberId,
+          name: rec.name,
+          runState: "Running",
+          status: "Running",
+          createdAt: rec.wallTs,
+          lastActiveAt: rec.wallTs,
+          scopeId: rec.scopeId,
+          traceId: rec.traceId,
+          spanId: rec.spanId
+        });
+        break;
+      }
+      case "fiber.suspend": {
+        const f = this.fibers.get(rec.fiberId);
+        if (f) {
+          f.runState = "Suspended";
+          f.lastActiveAt = rec.wallTs;
+          f.awaiting = { reason: rec.reason ?? "unknown" };
+        }
+        break;
+      }
+      case "fiber.resume": {
+        const f = this.fibers.get(rec.fiberId);
+        if (f) {
+          f.runState = "Running";
+          f.lastActiveAt = rec.wallTs;
+          f.awaiting = void 0;
+        }
+        break;
+      }
+      case "fiber.end": {
+        const f = this.fibers.get(rec.fiberId);
+        if (f) {
+          f.runState = "Done";
+          f.lastActiveAt = rec.wallTs;
+          f.status = rec.status === "interrupted" ? "Interrupted" : "Done";
+          f.lastEnd = { status: rec.status, error: formatRegistryError(rec.error) };
+        }
+        break;
+      }
+      case "scope.open": {
+        const sid = rec.scopeId;
+        this.scopes.set(sid, {
+          scopeId: sid,
+          parentScopeId: rec.parentScopeId,
+          ownerFiberId: rec.fiberId,
+          openAt: rec.wallTs,
+          finalizers: []
+        });
+        break;
+      }
+      case "scope.close": {
+        const s = this.scopes.get(rec.scopeId);
+        if (s) s.closedAt = rec.wallTs;
+        break;
+      }
+    }
+  }
+  getRecentEvents() {
+    return this.recent.slice();
+  }
+};
+function formatRegistryError(error) {
+  if (error === void 0) return void 0;
+  if (Cause.isCause(error)) return Cause.pretty(error, { singleLine: true });
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+
+// src/core/runtime/dump.ts
+function dumpAllFibers(reg) {
+  const fibers = Array.from(reg.fibers.values());
+  fibers.sort((a, b) => a.runState === b.runState ? b.lastActiveAt - a.lastActiveAt : a.runState.localeCompare(b.runState));
+  const lines = [];
+  lines.push(`=== Fiber Dump (${(/* @__PURE__ */ new Date()).toISOString()}) ===`);
+  for (const f of fibers) {
+    lines.push(
+      `fiber#${f.fiberId} ${f.name ?? ""} run=${f.runState} status=${f.status} scope=${f.scopeId ?? "-"} trace=${f.traceId ?? "-"} span=${f.spanId ?? "-"} last=${new Date(f.lastActiveAt).toISOString()}`
+    );
+    if (f.awaiting) lines.push(`  awaiting: ${f.awaiting.reason}${f.awaiting.detail ? ` (${f.awaiting.detail})` : ""}`);
+    if (f.lastEnd?.error) lines.push(`  end.error: ${f.lastEnd.error}`);
+  }
+  lines.push(`=== Recent Events ===`);
+  for (const ev of reg.getRecentEvents().slice(-80)) {
+    lines.push(
+      `${ev.seq} ${new Date(ev.wallTs).toISOString()} ${ev.type} fiber=${ev.fiberId ?? "-"} scope=${ev.scopeId ?? "-"} trace=${ev.traceId ?? "-"}`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/core/runtime/tracer.ts
+var defaultTracer = {
+  newTraceId: () => crypto.randomUUID(),
+  newSpanId: () => crypto.randomUUID()
+};
+
+// src/core/types/typedError.ts
+function catchTag(effect, tag, handler) {
+  return asyncFold(
+    effect,
+    (error) => {
+      if (typeof error === "object" && error !== null && "_tag" in error && error._tag === tag) {
+        return handler(error);
+      }
+      return asyncFail(error);
+    },
+    (value) => asyncSucceed(value)
+  );
+}
+function catchTags(effect, handlers) {
+  return asyncFold(
+    effect,
+    (error) => {
+      if (typeof error === "object" && error !== null && "_tag" in error) {
+        const handler = handlers[error._tag];
+        if (handler) return handler(error);
+      }
+      return asyncFail(error);
+    },
+    (value) => asyncSucceed(value)
+  );
+}
+function mapError(effect, f) {
+  return asyncFold(effect, (error) => asyncFail(f(error)), asyncSucceed);
+}
+function tagError(effect, tag, enrich) {
+  return asyncFold(
+    effect,
+    (error) => {
+      const fields = enrich ? enrich(error) : {};
+      return asyncFail({ _tag: tag, ...fields });
+    },
+    asyncSucceed
+  );
+}
+function orElse(effect, fallback) {
+  return asyncFold(effect, fallback, asyncSucceed);
+}
+
+// src/core/runtime/supervisor.ts
+var nextSupervisorId = 1;
+var nextChildId = 1;
+var Supervisor = class {
+  constructor(runtime, config = {}) {
+    this.runtime = runtime;
+    this.strategy = config.strategy ?? "one-for-one";
+    this.restart = resolveRestartPolicy(config.restart ?? "on-failure");
+    this.escalation = config.escalation ?? "shutdown";
+    this.clock = config.clock ?? Date.now;
+    this.onEvent = config.onEvent;
+  }
+  runtime;
+  id = nextSupervisorId++;
+  records = /* @__PURE__ */ new Map();
+  strategy;
+  restart;
+  escalation;
+  clock;
+  onEvent;
+  closed = false;
+  start(spec) {
+    if (this.closed) throw new Error("Supervisor is shut down");
+    const record = {
+      id: nextChildId++,
+      name: spec.name,
+      spec,
+      restart: resolveRestartPolicy(spec.restart ?? this.restart),
+      status: "running",
+      restartCount: 0,
+      restartTimes: [],
+      generation: 0,
+      plannedRestart: false,
+      joiners: []
+    };
+    this.records.set(record.id, record);
+    this.launch(record);
+    return this.handle(record);
+  }
+  startAll(specs) {
+    return specs.map((spec) => this.start(spec));
+  }
+  shutdown() {
+    return asyncEffect((_env, cb) => {
+      this.closed = true;
+      this.emit({ type: "shutdown", supervisorId: this.id });
+      const records = [...this.records.values()];
+      let remaining = records.filter((record) => record.current !== void 0).length;
+      for (const record of records) {
+        if (record.timer) {
+          clearTimeout(record.timer);
+          record.timer = void 0;
+        }
+        record.plannedRestart = false;
+        if (record.current) {
+          record.status = "interrupted";
+          record.current.interrupt();
+        } else if (!record.terminalExit) {
+          this.finish(record, interruptExit());
+        }
+      }
+      if (remaining === 0) {
+        cb({ _tag: "Success", value: void 0 });
+        return;
+      }
+      for (const record of records) {
+        record.current?.join(() => {
+          remaining--;
+          if (remaining === 0) cb({ _tag: "Success", value: void 0 });
+        });
+      }
+    });
+  }
+  handle(record) {
+    return {
+      id: record.id,
+      name: record.name,
+      current: () => record.current,
+      status: () => record.status,
+      restartCount: () => record.restartCount,
+      interrupt: () => {
+        record.plannedRestart = false;
+        if (record.timer) {
+          clearTimeout(record.timer);
+          record.timer = void 0;
+        }
+        if (record.current) {
+          record.current.interrupt();
+        } else if (!record.terminalExit) {
+          this.finish(record, interruptExit());
+        }
+      },
+      join: (cb) => {
+        if (record.terminalExit) cb(record.terminalExit);
+        else record.joiners.push(cb);
+      }
+    };
+  }
+  launch(record) {
+    if (this.closed) return;
+    record.generation++;
+    record.status = "running";
+    record.plannedRestart = false;
+    record.terminalExit = void 0;
+    const generation = record.generation;
+    const effect = typeof record.spec.effect === "function" ? record.spec.effect() : record.spec.effect;
+    const fiber = this.runtime.fork(effect);
+    record.current = fiber;
+    this.emit({
+      type: "child-start",
+      supervisorId: this.id,
+      childId: record.id,
+      name: record.name,
+      status: "running",
+      restartCount: record.restartCount
+    });
+    fiber.join((exit) => this.onChildExit(record, generation, exit));
+  }
+  onChildExit(record, generation, exit) {
+    if (generation !== record.generation) return;
+    record.current = void 0;
+    if (this.closed) {
+      this.finish(record, exit);
+      return;
+    }
+    if (record.plannedRestart) {
+      this.scheduleRestart(record, exit, "all-for-one");
+      return;
+    }
+    this.emit({
+      type: "child-end",
+      supervisorId: this.id,
+      childId: record.id,
+      name: record.name,
+      status: statusFromExit(exit),
+      restartCount: record.restartCount,
+      exit
+    });
+    if (!shouldRestart(record.restart.mode, exit)) {
+      this.finish(record, exit);
+      return;
+    }
+    if (this.strategy === "all-for-one") {
+      this.restartAll(record, exit);
+      return;
+    }
+    this.scheduleRestart(record, exit, "one-for-one");
+  }
+  restartAll(failed, exit) {
+    for (const record of this.records.values()) {
+      if (record.id === failed.id) continue;
+      if (!record.current) continue;
+      record.plannedRestart = true;
+      record.status = "restarting";
+      record.current.interrupt();
+    }
+    this.scheduleRestart(failed, exit, "all-for-one");
+  }
+  scheduleRestart(record, exit, reason) {
+    const context = this.restartContext(record, exit);
+    const delay = this.nextDelay(record, context);
+    if (delay === void 0) {
+      this.escalate(record, exit, "restart policy exhausted");
+      return;
+    }
+    record.status = "restarting";
+    record.restartCount++;
+    this.emit({
+      type: "child-restart",
+      supervisorId: this.id,
+      childId: record.id,
+      name: record.name,
+      status: "restarting",
+      restartCount: record.restartCount,
+      delayMs: delay,
+      exit,
+      reason
+    });
+    record.timer = setTimeout(() => {
+      record.timer = void 0;
+      this.launch(record);
+    }, delay);
+  }
+  nextDelay(record, context) {
+    const now = this.clock();
+    const windowStart = record.restart.withinMs === void 0 ? Number.NEGATIVE_INFINITY : now - record.restart.withinMs;
+    record.restartTimes = record.restartTimes.filter((ts) => ts >= windowStart);
+    if (record.restart.maxRestarts !== void 0 && record.restartTimes.length >= record.restart.maxRestarts) {
+      return void 0;
+    }
+    record.restartTimes.push(now);
+    if (record.restart.schedule) {
+      record.scheduleDriver ??= makeScheduleDriver(record.restart.schedule, {
+        name: record.restart.schedule.name ?? "supervisor.restart",
+        clock: this.scheduleClock()
+      });
+      const decision = record.scheduleDriver.next(context);
+      return decision.continue ? Math.max(0, Math.floor(decision.delayMs)) : void 0;
+    }
+    const raw = typeof record.restart.delayMs === "function" ? record.restart.delayMs(context) : record.restart.delayMs ?? 0;
+    return Number.isFinite(raw) ? Math.max(0, Math.floor(raw)) : 0;
+  }
+  escalate(record, exit, reason) {
+    this.emit({
+      type: "child-escalate",
+      supervisorId: this.id,
+      childId: record.id,
+      name: record.name,
+      status: statusFromExit(exit),
+      restartCount: record.restartCount,
+      exit,
+      reason
+    });
+    if (this.escalation === "shutdown") {
+      for (const child of this.records.values()) {
+        if (child.id !== record.id) child.current?.interrupt();
+      }
+    }
+    this.finish(record, exit);
+  }
+  finish(record, exit) {
+    record.status = statusFromExit(exit);
+    record.terminalExit = exit;
+    const joiners = record.joiners.splice(0);
+    for (const joiner of joiners) joiner(exit);
+  }
+  restartContext(record, exit) {
+    return {
+      supervisorId: this.id,
+      childId: record.id,
+      name: record.name,
+      restartCount: record.restartCount,
+      exit
+    };
+  }
+  emit(event) {
+    this.onEvent?.(event);
+    this.runtime.emit(toRuntimeEvent(event));
+  }
+  scheduleClock() {
+    return {
+      now: this.clock,
+      setTimeout: liveClock.setTimeout,
+      clearTimeout: liveClock.clearTimeout
+    };
+  }
+};
+function makeSupervisor(runtime, config = {}) {
+  return new Supervisor(runtime, config);
+}
+function supervise(runtime, spec, config = {}) {
+  return new Supervisor(runtime, config).start(spec);
+}
+function joinSupervised(fiber) {
+  return asyncEffect((_env, cb) => fiber.join(cb));
+}
+function resolveRestartPolicy(policy) {
+  if (typeof policy === "string") return { mode: policy };
+  return {
+    mode: policy.mode ?? "on-failure",
+    maxRestarts: policy.maxRestarts,
+    withinMs: policy.withinMs,
+    delayMs: policy.delayMs,
+    schedule: policy.schedule
+  };
+}
+function shouldRestart(mode, exit) {
+  if (exit._tag === "Failure" && Cause.isInterruptedOnly(exit.cause)) return false;
+  if (mode === "never") return false;
+  if (mode === "always") return true;
+  return exit._tag === "Failure";
+}
+function statusFromExit(exit) {
+  if (exit._tag === "Success") return "succeeded";
+  return Cause.isInterruptedOnly(exit.cause) ? "interrupted" : "failed";
+}
+function toRuntimeEvent(event) {
+  switch (event.type) {
+    case "child-start":
+      return {
+        type: "supervisor.child.start",
+        supervisorId: event.supervisorId,
+        childId: event.childId,
+        name: event.name,
+        restartCount: event.restartCount ?? 0
+      };
+    case "child-end":
+      return {
+        type: "supervisor.child.end",
+        supervisorId: event.supervisorId,
+        childId: event.childId,
+        name: event.name,
+        status: event.status === "succeeded" ? "success" : event.status === "interrupted" ? "interrupted" : "failure",
+        error: event.exit?._tag === "Failure" ? event.exit.cause : void 0
+      };
+    case "child-restart":
+      return {
+        type: "supervisor.child.restart",
+        supervisorId: event.supervisorId,
+        childId: event.childId,
+        name: event.name,
+        restartCount: event.restartCount ?? 0,
+        delayMs: event.delayMs ?? 0,
+        reason: event.reason
+      };
+    case "child-escalate":
+      return {
+        type: "supervisor.child.escalate",
+        supervisorId: event.supervisorId,
+        childId: event.childId,
+        name: event.name,
+        reason: event.reason,
+        error: event.exit?._tag === "Failure" ? event.exit.cause : void 0
+      };
+    case "shutdown":
+      return {
+        type: "supervisor.shutdown",
+        supervisorId: event.supervisorId
+      };
+  }
+}
+function interruptExit() {
+  return { _tag: "Failure", cause: { _tag: "Interrupt" } };
+}
+
+export {
+  makeCancelToken,
+  linkAbortController,
+  makeRuntime,
+  runPromise,
+  runExit,
+  runEffect,
+  LinkedQueue,
+  makeSemaphore,
+  makeRef,
+  derivedRef,
+  gracefulShutdown,
+  registerShutdownHooks,
+  TestScheduler,
+  TestClock,
+  makeTestRuntime,
+  assertSucceeds,
+  assertFails,
+  assertFailsWith,
+  assertCompletesWithin,
+  flakyEffect,
+  delayedEffect,
+  neverEffect,
+  MissingLayerServiceError,
+  formatLayerError,
+  makeServiceTag,
+  serviceTag,
+  defineService,
+  LayerContext,
+  makeLayerScope,
+  layer,
+  layerValue,
+  layerEffect,
+  layerFromContext,
+  defineLayer,
+  getService,
+  layerFrom,
+  layerSucceed,
+  layerFail,
+  compose,
+  merge,
+  mapLayer,
+  buildLayer,
+  provideLayer,
+  provideLayerContext,
+  provide,
+  provideContext,
+  Layer,
+  makeWorkerPool,
+  makeTracer,
+  consoleJsonLogger,
+  RuntimeRegistry,
+  dumpAllFibers,
+  defaultTracer,
+  catchTag,
+  catchTags,
+  mapError,
+  tagError,
+  orElse,
+  Supervisor,
+  makeSupervisor,
+  supervise,
+  joinSupervised
+};