brass-runtime 1.16.0 → 1.16.1

package/dist/{chunk-CY33PGEX.mjs → chunk-KH4SYAOS.mjs}

@@ -1,11 +1,23 @@
+import {
+  ensuring
+} from "./chunk-KN32XNTH.mjs";
+import {
+  makeScheduleDriver
+} from "./chunk-2HQTDLHF.mjs";
 import {
   makeRuntimeEventRecord
-} from "./chunk-VFIUZG7J.mjs";
+} from "./chunk-EJ6BPYVR.mjs";
 import {
   Runtime,
-  getCurrentFiber
-} from "./chunk-G6IQOE4P.mjs";
+  getCurrentFiber,
+  liveClock,
+  runtimeClockFromEnv,
+  toPromise,
+  unsafeRunAsync
+} from "./chunk-GYM3LLGS.mjs";
 import {
+  Cause,
+  Exit,
   asyncEffect,
   asyncFail,
   asyncFlatMap,
@@ -14,7 +26,7 @@ import {
   asyncSucceed,
   asyncSync,
   unit
-} from "./chunk-NOYZIMUJ.mjs";
+} from "./chunk-36I3M4UC.mjs";
 
 // 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 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;
@@ -267,57 +298,314 @@ function registerShutdownHooks(runtime, config = {}) {
 }
 
 // src/core/runtime/testing.ts
-function makeTestRuntime(env, options) {
-  const runtime = Runtime.make(env ?? {});
-  const run = (effect) => runtime.toPromise(effect);
-  const runExit = (effect) => new Promise((resolve) => {
+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);
   });
-  return { runtime, run, runExit };
+}
+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 = runtime ?? 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 = runtime ?? 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 = runtime ?? 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 = runtime ?? Runtime.make({});
-  const start = performance.now();
+  const rt = makeAssertionRuntime(runtime);
+  const start = runtimeClockFromEnv(rt.env).now();
   const result = await rt.toPromise(effect);
-  const elapsed = performance.now() - start;
+  const elapsed = runtimeClockFromEnv(rt.env).now() - start;
   if (elapsed > maxMs) {
     throw new Error(`Effect took ${elapsed.toFixed(1)}ms, expected < ${maxMs}ms`);
   }
@@ -328,16 +616,17 @@ function flakyEffect(failCount, successValue, errorValue) {
   return asyncEffect((_env, cb) => {
     calls++;
     if (calls <= failCount) {
-      cb({ _tag: "Failure", cause: { _tag: "Fail", error: errorValue } });
+      cb(Exit.failCause(Cause.fail(errorValue)));
     } else {
-      cb({ _tag: "Success", value: successValue });
+      cb(Exit.succeed(successValue));
     }
   });
 }
 function delayedEffect(ms, value) {
-  return asyncEffect((_env, cb) => {
-    const id = setTimeout(() => cb({ _tag: "Success", value }), ms);
-    return () => clearTimeout(id);
+  return asyncEffect((env, cb) => {
+    const clock = runtimeClockFromEnv(env);
+    const id = clock.setTimeout(() => cb(Exit.succeed(value)), ms);
+    return () => clock.clearTimeout(id);
   });
 }
 function neverEffect() {
@@ -348,6 +637,124 @@ function neverEffect() {
 }
 
 // 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",
@@ -357,6 +764,23 @@ function layer(acquire, release) {
     }))
   };
 }
+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",
@@ -381,6 +805,10 @@ function layerFail(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(
@@ -397,13 +825,20 @@ function compose(from, to) {
 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: { ...a, ...b },
+          service: mergeServices(a, b),
           release: () => asyncFlatMap(releaseB(), () => releaseA())
         })
       )
@@ -413,22 +848,63 @@ function merge(left, right) {
 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(
-    l.build(deps ?? {}),
-    ({ service, release }) => asyncFold(
+    buildLayer(l, deps ?? {}),
+    ({ service, close }) => ensuring(
       use(service),
-      (error) => asyncFlatMap(release(), () => asyncFail(error)),
-      (value) => asyncFlatMap(release(), () => asyncSucceed(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 = {}) {
@@ -653,7 +1129,7 @@ var RuntimeRegistry = class {
           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;
       }
@@ -679,6 +1155,17 @@ var RuntimeRegistry = class {
     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) {
@@ -943,9 +1430,11 @@ var Supervisor = class {
     }
     record.restartTimes.push(now);
     if (record.restart.schedule) {
-      const state = record.scheduleState ?? record.restart.schedule.initial();
-      const [decision, nextState] = record.restart.schedule.step(state, context);
-      record.scheduleState = nextState;
+      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;
@@ -988,6 +1477,13 @@ var Supervisor = class {
     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);
@@ -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" && 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 Cause.isInterruptedOnly(exit.cause) ? "interrupted" : "failed";
 }
 function toRuntimeEvent(event) {
   switch (event.type) {
@@ -1070,12 +1566,18 @@ function interruptExit() {
 export {
   makeCancelToken,
   linkAbortController,
+  makeRuntime,
+  runPromise,
+  runExit,
+  runEffect,
   LinkedQueue,
   makeSemaphore,
   makeRef,
   derivedRef,
   gracefulShutdown,
   registerShutdownHooks,
+  TestScheduler,
+  TestClock,
   makeTestRuntime,
   assertSucceeds,
   assertFails,
@@ -1084,14 +1586,31 @@ export {
   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,