brass-runtime 1.16.0 → 1.16.1

package/dist/{chunk-MWXMNYJS.cjs → chunk-Q2I37RP3.cjs}

@@ -1,11 +1,12 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6;
 
-var _chunkJX3LZQJHcjs = require('./chunk-JX3LZQJH.cjs');
+var _chunk62AZW6UTcjs = require('./chunk-62AZW6UT.cjs');
 
 
+var _chunkAGR5B2BCcjs = require('./chunk-AGR5B2BC.cjs');
 
-var _chunkWQ5QNU5Rcjs = require('./chunk-WQ5QNU5R.cjs');
 
+var _chunk52PPNNI4cjs = require('./chunk-52PPNNI4.cjs');
 
 
 
@@ -13,8 +14,19 @@ var _chunkWQ5QNU5Rcjs = require('./chunk-WQ5QNU5R.cjs');
 
 
 
+var _chunkGLE2WY7Zcjs = require('./chunk-GLE2WY7Z.cjs');
 
-var _chunkDJQ7OMMBcjs = require('./chunk-DJQ7OMMB.cjs');
+
+
+
+
+
+
+
+
+
+
+var _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
 
 // src/core/types/cancel.ts
 function makeCancelToken() {
@@ -49,6 +61,25 @@ function linkAbortController(token, ac) {
   return token.onCancel(() => ac.abort());
 }
 
+// src/core/runtime/dx.ts
+function makeRuntime(env = {}, options = {}) {
+  return new (0, _chunkGLE2WY7Zcjs.Runtime)({ ...options, env });
+}
+function runPromise(effect, envOrRuntime) {
+  if (envOrRuntime instanceof _chunkGLE2WY7Zcjs.Runtime) return envOrRuntime.toPromise(effect);
+  return _chunkGLE2WY7Zcjs.toPromise.call(void 0, effect, envOrRuntime);
+}
+function runExit(effect, envOrRuntime) {
+  return new Promise((resolve) => {
+    if (envOrRuntime instanceof _chunkGLE2WY7Zcjs.Runtime) {
+      envOrRuntime.unsafeRunAsync(effect, resolve);
+      return;
+    }
+    _chunkGLE2WY7Zcjs.unsafeRunAsync.call(void 0, effect, envOrRuntime, resolve);
+  });
+}
+var runEffect = runPromise;
+
 // src/core/runtime/linkedQueue.ts
 var LinkedQueue = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this); }
   __init() {this.head = null}
@@ -99,7 +130,7 @@ function makeSemaphore(n) {
   let totalReleased = 0;
   const waiters = new LinkedQueue();
   const acquire = () => {
-    return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (_env, cb) => {
+    return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (_env, cb) => {
       if (available > 0) {
         available--;
         totalAcquired++;
@@ -122,33 +153,33 @@ function makeSemaphore(n) {
     }
     available++;
   };
-  const acquirePermit = () => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, 
+  const acquirePermit = () => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
     acquire(),
-    () => _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (_env, cb) => {
+    () => _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (_env, cb) => {
       let released = false;
       const releaseOnce = () => {
         if (released) return;
         released = true;
         release();
       };
-      const fiber = _chunkWQ5QNU5Rcjs.getCurrentFiber.call(void 0, );
+      const fiber = _chunkGLE2WY7Zcjs.getCurrentFiber.call(void 0, );
       _optionalChain([fiber, 'optionalAccess', _2 => _2.addFinalizer, 'call', _3 => _3(() => {
         releaseOnce();
       })]);
       cb({ _tag: "Success", value: releaseOnce });
     })
   );
-  const withPermit = (effect) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, 
+  const withPermit = (effect) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
     acquirePermit(),
-    (releaseOnce) => _chunkDJQ7OMMBcjs.asyncFold.call(void 0, 
+    (releaseOnce) => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
       effect,
       (error) => {
         releaseOnce();
-        return _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error);
+        return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error);
       },
       (value) => {
         releaseOnce();
-        return _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, value);
+        return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, value);
       }
     )
   );
@@ -166,15 +197,15 @@ function makeSemaphore(n) {
 function makeRef(initial) {
   let value = initial;
   return {
-    get: () => _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => value),
-    set: (v) => _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => {
+    get: () => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => value),
+    set: (v) => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
       value = v;
     }),
-    update: (f) => _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => {
+    update: (f) => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
       value = f(value);
       return value;
     }),
-    modify: (f) => _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => {
+    modify: (f) => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
       const [result, next] = f(value);
       value = next;
       return result;
@@ -184,15 +215,15 @@ function makeRef(initial) {
 }
 function derivedRef(parent, get, set) {
   return {
-    get: () => _chunkDJQ7OMMBcjs.asyncSync.call(void 0, () => get(parent.unsafeGet())),
-    set: (b) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, parent.get(), (current) => parent.set(set(current, b))),
-    update: (f) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, parent.get(), (parentVal) => {
+    get: () => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => get(parent.unsafeGet())),
+    set: (b) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, parent.get(), (current) => parent.set(set(current, b))),
+    update: (f) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, parent.get(), (parentVal) => {
       const newB = f(get(parentVal));
-      return _chunkDJQ7OMMBcjs.asyncMap.call(void 0, parent.set(set(parentVal, newB)), () => newB);
+      return _chunkMVGUEJ5Zcjs.asyncMap.call(void 0, parent.set(set(parentVal, newB)), () => newB);
     }),
-    modify: (f) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, parent.get(), (parentVal) => {
+    modify: (f) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, parent.get(), (parentVal) => {
       const [result, newB] = f(get(parentVal));
-      return _chunkDJQ7OMMBcjs.asyncMap.call(void 0, parent.set(set(parentVal, newB)), () => result);
+      return _chunkMVGUEJ5Zcjs.asyncMap.call(void 0, parent.set(set(parentVal, newB)), () => result);
     }),
     unsafeGet: () => get(parent.unsafeGet())
   };
@@ -267,57 +298,314 @@ function registerShutdownHooks(runtime, config = {}) {
 }
 
 // src/core/runtime/testing.ts
-function makeTestRuntime(env, options) {
-  const runtime = _chunkWQ5QNU5Rcjs.Runtime.make(_nullishCoalesce(env, () => ( {})));
-  const run = (effect) => runtime.toPromise(effect);
-  const runExit = (effect) => new Promise((resolve) => {
+var TestScheduler = (_class2 = class {
+  constructor(options = {}) {;_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);_class2.prototype.__init11.call(this);
+    this.options = options;
+    this.maxSteps = _nullishCoalesce(options.maxSteps, () => ( 1e4));
+  }
+  
+  __init4() {this.queue = []}
+  
+  __init5() {this.autoFlushScheduled = false}
+  __init6() {this.flushing = false}
+  __init7() {this.enqueuedTasks = 0}
+  __init8() {this.executedTasks = 0}
+  __init9() {this.droppedTasks = 0}
+  __init10() {this.scheduledFlushes = 0}
+  __init11() {this.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 = _nullishCoalesce(_nullishCoalesce(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();
+    });
+  }
+}, _class2);
+var TestClock = (_class3 = class {
+  constructor(initialTimeMs = 0, flushScheduler = () => void 0, maxSteps = 1e4) {;_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);
+    this.flushScheduler = flushScheduler;
+    this.maxSteps = maxSteps;
+    this.nowMs = Math.max(0, Math.floor(initialTimeMs));
+  }
+  
+  
+  
+  __init12() {this.nextId = 1}
+  __init13() {this.nextSeq = 1}
+  __init14() {this.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;
+  }
+}, _class3);
+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(_nullishCoalesce(env, () => ( {})), clock);
+  const runtime = _chunkGLE2WY7Zcjs.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: {
+      ..._nullishCoalesce(current.brass, () => ( {})),
+      clock
+    }
+  };
+}
+function exitToPromise(exit) {
+  if (exit._tag === "Success") return exit.value;
+  const failure = _chunkMVGUEJ5Zcjs.Cause.firstFailure(exit.cause);
+  if (failure._tag === "Some") throw failure.value;
+  const defect = _chunkMVGUEJ5Zcjs.Cause.firstDefect(exit.cause);
+  if (defect._tag === "Some") {
+    throw defect.value instanceof Error ? defect.value : new Error(String(defect.value));
+  }
+  if (_chunkMVGUEJ5Zcjs.Cause.containsInterrupt(exit.cause)) throw new Error("Interrupted");
+  throw _chunkMVGUEJ5Zcjs.Cause.toError(exit.cause);
+}
+function runExitWithRuntime(runtime, effect) {
+  return new Promise((resolve) => {
     runtime.unsafeRunAsync(effect, resolve);
   });
-  return { runtime, run, runExit };
+}
+function stableJson(value) {
+  return JSON.stringify(value);
+}
+function firstFailureValue(exit) {
+  if (exit._tag !== "Failure") return void 0;
+  const failure = _chunkMVGUEJ5Zcjs.Cause.firstFailure(exit.cause);
+  return failure._tag === "Some" ? failure.value : void 0;
+}
+function makeAssertionRuntime(runtime) {
+  return _nullishCoalesce(runtime, () => ( _chunkGLE2WY7Zcjs.Runtime.make({})));
 }
 async function assertSucceeds(effect, expected, runtime) {
-  const rt = _nullishCoalesce(runtime, () => ( _chunkWQ5QNU5Rcjs.Runtime.make({})));
-  const exit = await new Promise((resolve) => {
-    rt.unsafeRunAsync(effect, resolve);
-  });
+  const rt = makeAssertionRuntime(runtime);
+  const exit = await runExitWithRuntime(rt, effect);
   if (exit._tag !== "Success") {
-    throw new Error(`Expected success with ${JSON.stringify(expected)}, got failure: ${JSON.stringify(exit.cause)}`);
+    throw new Error(`Expected success with ${stableJson(expected)}, got failure: ${stableJson(exit.cause)}`);
   }
-  if (JSON.stringify(exit.value) !== JSON.stringify(expected)) {
-    throw new Error(`Expected ${JSON.stringify(expected)}, got ${JSON.stringify(exit.value)}`);
+  if (stableJson(exit.value) !== stableJson(expected)) {
+    throw new Error(`Expected ${stableJson(expected)}, got ${stableJson(exit.value)}`);
   }
 }
 async function assertFails(effect, expectedError, runtime) {
-  const rt = _nullishCoalesce(runtime, () => ( _chunkWQ5QNU5Rcjs.Runtime.make({})));
-  const exit = await new Promise((resolve) => {
-    rt.unsafeRunAsync(effect, resolve);
-  });
+  const rt = makeAssertionRuntime(runtime);
+  const exit = await runExitWithRuntime(rt, effect);
   if (exit._tag !== "Failure") {
-    throw new Error(`Expected failure with ${JSON.stringify(expectedError)}, got success: ${JSON.stringify(exit.value)}`);
+    throw new Error(`Expected failure with ${stableJson(expectedError)}, got success: ${stableJson(exit.value)}`);
   }
-  const error = exit.cause.error;
-  if (JSON.stringify(error) !== JSON.stringify(expectedError)) {
-    throw new Error(`Expected error ${JSON.stringify(expectedError)}, got ${JSON.stringify(error)}`);
+  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 = _nullishCoalesce(runtime, () => ( _chunkWQ5QNU5Rcjs.Runtime.make({})));
-  const exit = await new Promise((resolve) => {
-    rt.unsafeRunAsync(effect, resolve);
-  });
+  const rt = makeAssertionRuntime(runtime);
+  const exit = await runExitWithRuntime(rt, effect);
   if (exit._tag !== "Failure") {
-    throw new Error(`Expected failure, got success: ${JSON.stringify(exit.value)}`);
+    throw new Error(`Expected failure, got success: ${stableJson(exit.value)}`);
   }
-  const error = exit.cause.error;
-  if (!predicate(error)) {
-    throw new Error(`Error did not match predicate: ${JSON.stringify(error)}`);
+  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 = _nullishCoalesce(runtime, () => ( _chunkWQ5QNU5Rcjs.Runtime.make({})));
-  const start = performance.now();
+  const rt = makeAssertionRuntime(runtime);
+  const start = _chunkGLE2WY7Zcjs.runtimeClockFromEnv.call(void 0, rt.env).now();
   const result = await rt.toPromise(effect);
-  const elapsed = performance.now() - start;
+  const elapsed = _chunkGLE2WY7Zcjs.runtimeClockFromEnv.call(void 0, rt.env).now() - start;
   if (elapsed > maxMs) {
     throw new Error(`Effect took ${elapsed.toFixed(1)}ms, expected < ${maxMs}ms`);
   }
@@ -325,70 +613,210 @@ async function assertCompletesWithin(effect, maxMs, runtime) {
 }
 function flakyEffect(failCount, successValue, errorValue) {
   let calls = 0;
-  return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (_env, cb) => {
+  return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (_env, cb) => {
     calls++;
     if (calls <= failCount) {
-      cb({ _tag: "Failure", cause: { _tag: "Fail", error: errorValue } });
+      cb(_chunkMVGUEJ5Zcjs.Exit.failCause(_chunkMVGUEJ5Zcjs.Cause.fail(errorValue)));
     } else {
-      cb({ _tag: "Success", value: successValue });
+      cb(_chunkMVGUEJ5Zcjs.Exit.succeed(successValue));
     }
   });
 }
 function delayedEffect(ms, value) {
-  return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (_env, cb) => {
-    const id = setTimeout(() => cb({ _tag: "Success", value }), ms);
-    return () => clearTimeout(id);
+  return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
+    const clock = _chunkGLE2WY7Zcjs.runtimeClockFromEnv.call(void 0, env);
+    const id = clock.setTimeout(() => cb(_chunkMVGUEJ5Zcjs.Exit.succeed(value)), ms);
+    return () => clock.clearTimeout(id);
   });
 }
 function neverEffect() {
-  return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, () => {
+  return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, () => {
     return () => {
     };
   });
 }
 
 // src/core/runtime/layer.ts
+var MissingLayerServiceError = (_class4 = class extends Error {
+  __init15() {this._tag = "MissingLayerService"}
+  
+  constructor(serviceName) {
+    super(`Missing layer service '${serviceName}'. Add a layer that provides this ServiceTag or pass a LayerContext containing it.`);_class4.prototype.__init15.call(this);;
+    this.name = "MissingLayerServiceError";
+    this.serviceName = serviceName;
+  }
+}, _class4);
+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 {
+  
+  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 _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, new Error("LayerScope is closed"));
+      if (cache.has(l)) return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, cache.get(l));
+      const built = l.buildScoped ? l.buildScoped(deps, scope) : _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+        l.build(deps),
+        ({ service, release }) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, scope.addFinalizer(release), () => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, service))
+      );
+      return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+        built,
+        (service) => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+          cache.set(l, service);
+          return service;
+        })
+      );
+    },
+    close: () => {
+      if (closed) return _chunkMVGUEJ5Zcjs.unit.call(void 0, );
+      closed = true;
+      return releaseAll(finalizers);
+    },
+    size: () => finalizers.length,
+    addFinalizer: (release) => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+      if (!closed) finalizers.push(release);
+    })
+  };
+  return scope;
+}
+function releaseAll(finalizers) {
+  const next = finalizers.pop();
+  if (!next) return _chunkMVGUEJ5Zcjs.unit.call(void 0, );
+  return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+    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) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, acquire(), (service) => _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, {
+    build: (_deps) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, acquire(), (service) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, {
       service,
-      release: release ? () => release(service) : () => _chunkDJQ7OMMBcjs.unit.call(void 0, )
+      release: release ? () => release(service) : () => _chunkMVGUEJ5Zcjs.unit.call(void 0, )
+    }))
+  };
+}
+function layerValue(tag, value) {
+  return layerEffect(tag, () => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, value));
+}
+function layerEffect(tag, acquire, release) {
+  return {
+    _tag: "Layer",
+    build: (deps = LayerContext.empty()) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, acquire(deps), (service) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, {
+      service: deps.add(tag, service),
+      release: release ? () => release(service) : () => _chunkMVGUEJ5Zcjs.unit.call(void 0, )
     }))
   };
 }
+var layerFromContext = layerEffect;
+var defineLayer = layerEffect;
+function getService(tag) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, (context) => context.unsafeGet(tag));
+}
 function layerFrom() {
   return (acquire, release) => ({
     _tag: "Layer",
-    build: (deps) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, acquire(deps), (service) => _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, {
+    build: (deps) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, acquire(deps), (service) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, {
       service,
-      release: release ? () => release(service) : () => _chunkDJQ7OMMBcjs.unit.call(void 0, )
+      release: release ? () => release(service) : () => _chunkMVGUEJ5Zcjs.unit.call(void 0, )
     }))
   });
 }
 function layerSucceed(value) {
   return {
     _tag: "Layer",
-    build: () => _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, { service: value, release: () => _chunkDJQ7OMMBcjs.unit.call(void 0, ) })
+    build: () => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, { service: value, release: () => _chunkMVGUEJ5Zcjs.unit.call(void 0, ) })
   };
 }
 function layerFail(error) {
   return {
     _tag: "Layer",
-    build: () => _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error)
+    build: () => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error)
   };
 }
 function compose(from, to) {
   return {
     _tag: "Layer",
-    build: (deps) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, 
+    buildScoped: (deps, scope) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+      scope.get(from, deps),
+      (mid) => scope.get(to, mid)
+    ),
+    build: (deps) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
       from.build(deps),
-      ({ service: mid, release: releaseMid }) => _chunkDJQ7OMMBcjs.asyncFold.call(void 0, 
+      ({ service: mid, release: releaseMid }) => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
         to.build(mid),
-        (error) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, releaseMid(), () => _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error)),
-        ({ service: out, release: releaseOut }) => _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, {
+        (error) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, releaseMid(), () => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error)),
+        ({ service: out, release: releaseOut }) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, {
           service: out,
-          release: () => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, releaseOut(), () => releaseMid())
+          release: () => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, releaseOut(), () => releaseMid())
         })
       )
     )
@@ -397,14 +825,21 @@ function compose(from, to) {
 function merge(left, right) {
   return {
     _tag: "Layer",
-    build: (deps) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, 
+    buildScoped: (deps, scope) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+      scope.get(left, deps),
+      (a) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+        scope.get(right, deps),
+        (b) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, mergeServices(a, b))
+      )
+    ),
+    build: (deps) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
       left.build(deps),
-      ({ service: a, release: releaseA }) => _chunkDJQ7OMMBcjs.asyncFold.call(void 0, 
+      ({ service: a, release: releaseA }) => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
         right.build(deps),
-        (error) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, releaseA(), () => _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error)),
-        ({ service: b, release: releaseB }) => _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, {
-          service: { ...a, ...b },
-          release: () => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, releaseB(), () => releaseA())
+        (error) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, releaseA(), () => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error)),
+        ({ service: b, release: releaseB }) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, {
+          service: mergeServices(a, b),
+          release: () => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, releaseB(), () => releaseA())
         })
       )
     )
@@ -413,22 +848,63 @@ function merge(left, right) {
 function mapLayer(l, f) {
   return {
     _tag: "Layer",
-    build: (deps) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, 
+    buildScoped: (deps, scope) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+      scope.get(l, deps),
+      (service) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, f(service))
+    ),
+    build: (deps) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
       l.build(deps),
-      ({ service, release }) => _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, { service: f(service), release })
+      ({ service, release }) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, { service: f(service), release })
     )
   };
 }
+function buildLayer(l, deps) {
+  const scope = makeLayerScope();
+  return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+    scope.get(l, deps),
+    (error) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, scope.close(), () => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error)),
+    (service) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, {
+      service,
+      scope,
+      close: scope.close,
+      use: (body) => body(service)
+    })
+  );
+}
 function provideLayer(l, use, deps) {
-  return _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, 
-    l.build(_nullishCoalesce(deps, () => ( {}))),
-    ({ service, release }) => _chunkDJQ7OMMBcjs.asyncFold.call(void 0, 
+  return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+    buildLayer(l, _nullishCoalesce(deps, () => ( {}))),
+    ({ service, close }) => _chunk62AZW6UTcjs.ensuring.call(void 0, 
       use(service),
-      (error) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, release(), () => _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error)),
-      (value) => _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, release(), () => _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, value))
+      () => 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 = {}) {
@@ -462,11 +938,11 @@ function makeWorkerPool(config = {}) {
     });
   };
   const execute = (fn) => {
-    if (closed) return _chunkDJQ7OMMBcjs.asyncFail.call(void 0, { _tag: "WorkerPoolClosed" });
+    if (closed) return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, { _tag: "WorkerPoolClosed" });
     if (queue.length >= maxQueue) {
-      return _chunkDJQ7OMMBcjs.asyncFail.call(void 0, { _tag: "WorkerPoolFull", queued: queue.length });
+      return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, { _tag: "WorkerPoolFull", queued: queue.length });
     }
-    return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (_env, cb) => {
+    return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (_env, cb) => {
       const task = {
         fn,
         resolve: (value) => cb({ _tag: "Success", value }),
@@ -546,7 +1022,7 @@ function makeTracer(config) {
       attributes: { "service.name": config.serviceName, ...attributes },
       events: []
     };
-    return _chunkDJQ7OMMBcjs.asyncFold.call(void 0, 
+    return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
       effect,
       (error) => {
         spanObj.endTime = performance.now();
@@ -558,14 +1034,14 @@ function makeTracer(config) {
         });
         completedSpans.push(spanObj);
         _optionalChain([config, 'access', _14 => _14.onSpanEnd, 'optionalCall', _15 => _15(spanObj)]);
-        return _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error);
+        return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error);
       },
       (value) => {
         spanObj.endTime = performance.now();
         spanObj.status = "ok";
         completedSpans.push(spanObj);
         _optionalChain([config, 'access', _16 => _16.onSpanEnd, 'optionalCall', _17 => _17(spanObj)]);
-        return _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, value);
+        return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, value);
       }
     );
   };
@@ -602,14 +1078,14 @@ function consoleJsonLogger() {
 }
 
 // src/core/runtime/registry.ts
-var RuntimeRegistry = (_class2 = class {constructor() { _class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this); }
-  __init4() {this.fibers = /* @__PURE__ */ new Map()}
-  __init5() {this.scopes = /* @__PURE__ */ new Map()}
-  __init6() {this.seq = 1}
-  __init7() {this.recent = []}
-  __init8() {this.recentCap = 2e3}
+var RuntimeRegistry = (_class5 = class {constructor() { _class5.prototype.__init16.call(this);_class5.prototype.__init17.call(this);_class5.prototype.__init18.call(this);_class5.prototype.__init19.call(this);_class5.prototype.__init20.call(this); }
+  __init16() {this.fibers = /* @__PURE__ */ new Map()}
+  __init17() {this.scopes = /* @__PURE__ */ new Map()}
+  __init18() {this.seq = 1}
+  __init19() {this.recent = []}
+  __init20() {this.recentCap = 2e3}
   emit(ev, ctx) {
-    const rec = _chunkJX3LZQJHcjs.makeRuntimeEventRecord.call(void 0, ev, ctx, this.seq++);
+    const rec = _chunk52PPNNI4cjs.makeRuntimeEventRecord.call(void 0, ev, ctx, this.seq++);
     this.recent.push(rec);
     if (this.recent.length > this.recentCap) this.recent.shift();
     switch (rec.type) {
@@ -653,7 +1129,7 @@ var RuntimeRegistry = (_class2 = class {constructor() { _class2.prototype.__init
           f.runState = "Done";
           f.lastActiveAt = rec.wallTs;
           f.status = rec.status === "interrupted" ? "Interrupted" : "Done";
-          f.lastEnd = { status: rec.status, error: rec.error };
+          f.lastEnd = { status: rec.status, error: formatRegistryError(rec.error) };
         }
         break;
       }
@@ -678,7 +1154,18 @@ var RuntimeRegistry = (_class2 = class {constructor() { _class2.prototype.__init
   getRecentEvents() {
     return this.recent.slice();
   }
-}, _class2);
+}, _class5);
+function formatRegistryError(error) {
+  if (error === void 0) return void 0;
+  if (_chunkMVGUEJ5Zcjs.Cause.isCause(error)) return _chunkMVGUEJ5Zcjs.Cause.pretty(error, { singleLine: true });
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  try {
+    return JSON.stringify(error);
+  } catch (e4) {
+    return String(error);
+  }
+}
 
 // src/core/runtime/dump.ts
 function dumpAllFibers(reg) {
@@ -710,52 +1197,52 @@ var defaultTracer = {
 
 // src/core/types/typedError.ts
 function catchTag(effect, tag, handler) {
-  return _chunkDJQ7OMMBcjs.asyncFold.call(void 0, 
+  return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
     effect,
     (error) => {
       if (typeof error === "object" && error !== null && "_tag" in error && error._tag === tag) {
         return handler(error);
       }
-      return _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error);
+      return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error);
     },
-    (value) => _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, value)
+    (value) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, value)
   );
 }
 function catchTags(effect, handlers) {
-  return _chunkDJQ7OMMBcjs.asyncFold.call(void 0, 
+  return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
     effect,
     (error) => {
       if (typeof error === "object" && error !== null && "_tag" in error) {
         const handler = handlers[error._tag];
         if (handler) return handler(error);
       }
-      return _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error);
+      return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error);
     },
-    (value) => _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, value)
+    (value) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, value)
   );
 }
 function mapError(effect, f) {
-  return _chunkDJQ7OMMBcjs.asyncFold.call(void 0, effect, (error) => _chunkDJQ7OMMBcjs.asyncFail.call(void 0, f(error)), _chunkDJQ7OMMBcjs.asyncSucceed);
+  return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, effect, (error) => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, f(error)), _chunkMVGUEJ5Zcjs.asyncSucceed);
 }
 function tagError(effect, tag, enrich) {
-  return _chunkDJQ7OMMBcjs.asyncFold.call(void 0, 
+  return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
     effect,
     (error) => {
       const fields = enrich ? enrich(error) : {};
-      return _chunkDJQ7OMMBcjs.asyncFail.call(void 0, { _tag: tag, ...fields });
+      return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, { _tag: tag, ...fields });
     },
-    _chunkDJQ7OMMBcjs.asyncSucceed
+    _chunkMVGUEJ5Zcjs.asyncSucceed
   );
 }
 function orElse(effect, fallback) {
-  return _chunkDJQ7OMMBcjs.asyncFold.call(void 0, effect, fallback, _chunkDJQ7OMMBcjs.asyncSucceed);
+  return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, effect, fallback, _chunkMVGUEJ5Zcjs.asyncSucceed);
 }
 
 // src/core/runtime/supervisor.ts
 var nextSupervisorId = 1;
 var nextChildId = 1;
-var Supervisor = (_class3 = class {
-  constructor(runtime, config = {}) {;_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);
+var Supervisor = (_class6 = class {
+  constructor(runtime, config = {}) {;_class6.prototype.__init21.call(this);_class6.prototype.__init22.call(this);_class6.prototype.__init23.call(this);
     this.runtime = runtime;
     this.strategy = _nullishCoalesce(config.strategy, () => ( "one-for-one"));
     this.restart = resolveRestartPolicy(_nullishCoalesce(config.restart, () => ( "on-failure")));
@@ -764,14 +1251,14 @@ var Supervisor = (_class3 = class {
     this.onEvent = config.onEvent;
   }
   
-  __init9() {this.id = nextSupervisorId++}
-  __init10() {this.records = /* @__PURE__ */ new Map()}
+  __init21() {this.id = nextSupervisorId++}
+  __init22() {this.records = /* @__PURE__ */ new Map()}
   
   
   
   
   
-  __init11() {this.closed = false}
+  __init23() {this.closed = false}
   start(spec) {
     if (this.closed) throw new Error("Supervisor is shut down");
     const record = {
@@ -794,7 +1281,7 @@ var Supervisor = (_class3 = class {
     return specs.map((spec) => this.start(spec));
   }
   shutdown() {
-    return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (_env, cb) => {
+    return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (_env, cb) => {
       this.closed = true;
       this.emit({ type: "shutdown", supervisorId: this.id });
       const records = [...this.records.values()];
@@ -943,9 +1430,11 @@ var Supervisor = (_class3 = class {
     }
     record.restartTimes.push(now);
     if (record.restart.schedule) {
-      const state = _nullishCoalesce(record.scheduleState, () => ( record.restart.schedule.initial()));
-      const [decision, nextState] = record.restart.schedule.step(state, context);
-      record.scheduleState = nextState;
+      record.scheduleDriver ??= _chunkAGR5B2BCcjs.makeScheduleDriver.call(void 0, record.restart.schedule, {
+        name: _nullishCoalesce(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) : _nullishCoalesce(record.restart.delayMs, () => ( 0));
@@ -988,7 +1477,14 @@ var Supervisor = (_class3 = class {
     _optionalChain([this, 'access', _26 => _26.onEvent, 'optionalCall', _27 => _27(event)]);
     this.runtime.emit(toRuntimeEvent(event));
   }
-}, _class3);
+  scheduleClock() {
+    return {
+      now: this.clock,
+      setTimeout: _chunkGLE2WY7Zcjs.liveClock.setTimeout,
+      clearTimeout: _chunkGLE2WY7Zcjs.liveClock.clearTimeout
+    };
+  }
+}, _class6);
 function makeSupervisor(runtime, config = {}) {
   return new Supervisor(runtime, config);
 }
@@ -996,7 +1492,7 @@ function supervise(runtime, spec, config = {}) {
   return new Supervisor(runtime, config).start(spec);
 }
 function joinSupervised(fiber) {
-  return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (_env, cb) => fiber.join(cb));
+  return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (_env, cb) => fiber.join(cb));
 }
 function resolveRestartPolicy(policy) {
   if (typeof policy === "string") return { mode: policy };
@@ -1009,14 +1505,14 @@ function resolveRestartPolicy(policy) {
   };
 }
 function shouldRestart(mode, exit) {
-  if (exit._tag === "Failure" && exit.cause._tag === "Interrupt") return false;
+  if (exit._tag === "Failure" && _chunkMVGUEJ5Zcjs.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 exit.cause._tag === "Interrupt" ? "interrupted" : "failed";
+  return _chunkMVGUEJ5Zcjs.Cause.isInterruptedOnly(exit.cause) ? "interrupted" : "failed";
 }
 function toRuntimeEvent(event) {
   switch (event.type) {
@@ -1107,4 +1603,27 @@ function interruptExit() {
 
 
 
-exports.makeCancelToken = makeCancelToken; exports.linkAbortController = linkAbortController; exports.LinkedQueue = LinkedQueue; exports.makeSemaphore = makeSemaphore; exports.makeRef = makeRef; exports.derivedRef = derivedRef; exports.gracefulShutdown = gracefulShutdown; exports.registerShutdownHooks = registerShutdownHooks; exports.makeTestRuntime = makeTestRuntime; exports.assertSucceeds = assertSucceeds; exports.assertFails = assertFails; exports.assertFailsWith = assertFailsWith; exports.assertCompletesWithin = assertCompletesWithin; exports.flakyEffect = flakyEffect; exports.delayedEffect = delayedEffect; exports.neverEffect = neverEffect; exports.layer = layer; exports.layerFrom = layerFrom; exports.layerSucceed = layerSucceed; exports.layerFail = layerFail; exports.compose = compose; exports.merge = merge; exports.mapLayer = mapLayer; exports.provideLayer = provideLayer; exports.makeWorkerPool = makeWorkerPool; exports.makeTracer = makeTracer; exports.consoleJsonLogger = consoleJsonLogger; exports.RuntimeRegistry = RuntimeRegistry; exports.dumpAllFibers = dumpAllFibers; exports.defaultTracer = defaultTracer; exports.catchTag = catchTag; exports.catchTags = catchTags; exports.mapError = mapError; exports.tagError = tagError; exports.orElse = orElse; exports.Supervisor = Supervisor; exports.makeSupervisor = makeSupervisor; exports.supervise = supervise; exports.joinSupervised = joinSupervised;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.makeCancelToken = makeCancelToken; exports.linkAbortController = linkAbortController; exports.makeRuntime = makeRuntime; exports.runPromise = runPromise; exports.runExit = runExit; exports.runEffect = runEffect; exports.LinkedQueue = LinkedQueue; exports.makeSemaphore = makeSemaphore; exports.makeRef = makeRef; exports.derivedRef = derivedRef; exports.gracefulShutdown = gracefulShutdown; exports.registerShutdownHooks = registerShutdownHooks; exports.TestScheduler = TestScheduler; exports.TestClock = TestClock; exports.makeTestRuntime = makeTestRuntime; exports.assertSucceeds = assertSucceeds; exports.assertFails = assertFails; exports.assertFailsWith = assertFailsWith; exports.assertCompletesWithin = assertCompletesWithin; exports.flakyEffect = flakyEffect; exports.delayedEffect = delayedEffect; exports.neverEffect = neverEffect; exports.MissingLayerServiceError = MissingLayerServiceError; exports.formatLayerError = formatLayerError; exports.makeServiceTag = makeServiceTag; exports.serviceTag = serviceTag; exports.defineService = defineService; exports.LayerContext = LayerContext; exports.makeLayerScope = makeLayerScope; exports.layer = layer; exports.layerValue = layerValue; exports.layerEffect = layerEffect; exports.layerFromContext = layerFromContext; exports.defineLayer = defineLayer; exports.getService = getService; exports.layerFrom = layerFrom; exports.layerSucceed = layerSucceed; exports.layerFail = layerFail; exports.compose = compose; exports.merge = merge; exports.mapLayer = mapLayer; exports.buildLayer = buildLayer; exports.provideLayer = provideLayer; exports.provideLayerContext = provideLayerContext; exports.provide = provide; exports.provideContext = provideContext; exports.Layer = Layer; exports.makeWorkerPool = makeWorkerPool; exports.makeTracer = makeTracer; exports.consoleJsonLogger = consoleJsonLogger; exports.RuntimeRegistry = RuntimeRegistry; exports.dumpAllFibers = dumpAllFibers; exports.defaultTracer = defaultTracer; exports.catchTag = catchTag; exports.catchTags = catchTags; exports.mapError = mapError; exports.tagError = tagError; exports.orElse = orElse; exports.Supervisor = Supervisor; exports.makeSupervisor = makeSupervisor; exports.supervise = supervise; exports.joinSupervised = joinSupervised;