brass-runtime 1.15.0 → 1.16.0

package/dist/{chunk-AR22SXML.js → chunk-CY33PGEX.mjs}

@@ -1,11 +1,11 @@
 import {
-  sleep
-} from "./chunk-BDYEENHT.js";
+  makeRuntimeEventRecord
+} from "./chunk-VFIUZG7J.mjs";
 import {
-  Cause,
-  Exit,
   Runtime,
-  Scope,
+  getCurrentFiber
+} from "./chunk-G6IQOE4P.mjs";
+import {
   asyncEffect,
   asyncFail,
   asyncFlatMap,
@@ -13,9 +13,8 @@ import {
   asyncMap,
   asyncSucceed,
   asyncSync,
-  unit,
-  unsafeGetCurrentRuntime
-} from "./chunk-BMH5AV44.js";
+  unit
+} from "./chunk-NOYZIMUJ.mjs";
 
 // src/core/types/cancel.ts
 function makeCancelToken() {
@@ -50,135 +49,6 @@ function linkAbortController(token, ac) {
   return token.onCancel(() => ac.abort());
 }
 
-// src/core/runtime/resource.ts
-function bracket(acquire, use, release) {
-  return asyncEffect((env, cb) => {
-    const runtime = unsafeGetCurrentRuntime();
-    const scope = new Scope(runtime);
-    const acquireFiber = scope.fork(acquire);
-    acquireFiber.join((acquireExit) => {
-      if (acquireExit._tag === "Failure") {
-        scope.close(acquireExit);
-        cb(acquireExit);
-        return;
-      }
-      const resource = acquireExit.value;
-      const useFiber = scope.fork(use(resource));
-      useFiber.join((useExit) => {
-        const releaseEffect = safeRelease(release, resource, useExit);
-        const releaseFiber = runtime.fork(releaseEffect);
-        releaseFiber.join(() => {
-          scope.close(useExit);
-          cb(useExit);
-        });
-      });
-    });
-    return () => {
-      scope.close(Exit.failCause(Cause.interrupt()));
-    };
-  });
-}
-function safeRelease(release, resource, exit) {
-  return asyncFold(
-    (() => {
-      try {
-        return release(resource, exit);
-      } catch {
-        return unit();
-      }
-    })(),
-    () => unit(),
-    () => unit()
-  );
-}
-function ensuring(effect, finalizer) {
-  return asyncEffect((env, cb) => {
-    const runtime = unsafeGetCurrentRuntime();
-    const fiber = runtime.fork(effect);
-    fiber.join((exit) => {
-      const fin = asyncFold(
-        (() => {
-          try {
-            return finalizer(exit);
-          } catch {
-            return unit();
-          }
-        })(),
-        () => unit(),
-        () => unit()
-      );
-      runtime.fork(fin).join(() => {
-        cb(exit);
-      });
-    });
-    return () => {
-      fiber.interrupt();
-    };
-  });
-}
-function managed(acquire, release) {
-  return {
-    _tag: "Managed",
-    acquire,
-    release: (resource, exit) => release(resource, exit)
-  };
-}
-function useManaged(m, body) {
-  return bracket(m.acquire, body, m.release);
-}
-function managedAll(manageds) {
-  const acquire = asyncEffect((env, cb) => {
-    const runtime = unsafeGetCurrentRuntime();
-    const resources = [];
-    let i = 0;
-    const acquireNext = () => {
-      if (i >= manageds.length) {
-        cb({ _tag: "Success", value: resources });
-        return;
-      }
-      const m = manageds[i];
-      const fiber = runtime.fork(m.acquire);
-      fiber.join((exit) => {
-        if (exit._tag === "Failure") {
-          releaseAcquired(runtime, manageds, resources, exit).then(() => {
-            cb(exit);
-          });
-          return;
-        }
-        resources.push(exit.value);
-        i++;
-        acquireNext();
-      });
-    };
-    acquireNext();
-  });
-  const release = (resources, exit) => {
-    return asyncEffect((_env, cb) => {
-      const runtime = unsafeGetCurrentRuntime();
-      releaseAcquired(runtime, manageds, resources, exit).then(() => {
-        cb({ _tag: "Success", value: void 0 });
-      });
-    });
-  };
-  return { _tag: "Managed", acquire, release };
-}
-async function releaseAcquired(runtime, manageds, resources, exit) {
-  for (let i = resources.length - 1; i >= 0; i--) {
-    try {
-      const m = manageds[i];
-      await new Promise((resolve) => {
-        const releaseEff = asyncFold(
-          m.release(resources[i], exit),
-          () => unit(),
-          () => unit()
-        );
-        runtime.fork(releaseEff).join(() => resolve());
-      });
-    } catch {
-    }
-  }
-}
-
 // src/core/runtime/linkedQueue.ts
 var LinkedQueue = class {
   head = null;
@@ -252,29 +122,36 @@ function makeSemaphore(n) {
     }
     available++;
   };
-  const withPermit = (effect) => {
-    return asyncFlatMap(
-      acquire(),
-      () => asyncEffect((_env, cb) => {
-        const runtime = unsafeGetCurrentRuntime();
-        const fiber = runtime.fork(effect);
-        let released = false;
-        const releaseOnce = () => {
-          if (released) return;
-          released = true;
-          release();
-        };
-        fiber.join((exit) => {
-          releaseOnce();
-          cb(exit);
-        });
-        return () => {
-          fiber.interrupt();
-          releaseOnce();
-        };
-      })
-    );
-  };
+  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,
@@ -321,161 +198,6 @@ function derivedRef(parent, get, set) {
   };
 }
 
-// src/core/runtime/schedule.ts
-function recurs(n) {
-  return {
-    _tag: "Schedule",
-    initial: () => 0,
-    step: (count, _input) => {
-      const next = count + 1;
-      return [{ continue: next < n, delayMs: 0 }, next, next];
-    }
-  };
-}
-function fixed(delayMs) {
-  return {
-    _tag: "Schedule",
-    initial: () => 0,
-    step: (count, _input) => {
-      return [{ continue: true, delayMs }, count + 1, count + 1];
-    }
-  };
-}
-function exponential(baseMs, maxMs = Infinity) {
-  return {
-    _tag: "Schedule",
-    initial: () => 0,
-    step: (count, _input) => {
-      const delay = Math.min(baseMs * Math.pow(2, count), maxMs);
-      return [{ continue: true, delayMs: delay }, count + 1, count + 1];
-    }
-  };
-}
-function jittered(baseMs, maxMs = Infinity) {
-  return {
-    _tag: "Schedule",
-    initial: () => 0,
-    step: (count, _input) => {
-      const cap = Math.min(baseMs * Math.pow(2, count), maxMs);
-      const delay = Math.floor(Math.random() * cap);
-      return [{ continue: true, delayMs: delay }, count + 1, count + 1];
-    }
-  };
-}
-function elapsed(maxMs) {
-  return {
-    _tag: "Schedule",
-    initial: () => performance.now(),
-    step: (startedAt, _input) => {
-      const el = performance.now() - startedAt;
-      return [{ continue: el < maxMs, delayMs: 0 }, startedAt, el];
-    }
-  };
-}
-function whileInput(pred) {
-  return {
-    _tag: "Schedule",
-    initial: () => void 0,
-    step: (_state, input) => {
-      return [{ continue: pred(input), delayMs: 0 }, void 0, input];
-    }
-  };
-}
-function take(schedule, n) {
-  return {
-    _tag: "Schedule",
-    initial: () => ({ inner: schedule.initial(), count: 0 }),
-    step: (state, input) => {
-      if (state.count >= n) return [{ continue: false, delayMs: 0 }, state, void 0];
-      const [decision, nextInner, output] = schedule.step(state.inner, input);
-      const nextState = { inner: nextInner, count: state.count + 1 };
-      return [{ continue: decision.continue && state.count + 1 < n, delayMs: decision.delayMs }, nextState, output];
-    }
-  };
-}
-function andThen(first, second) {
-  return {
-    _tag: "Schedule",
-    initial: () => ({ phase: "first", inner: first.initial() }),
-    step: (state, input) => {
-      if (state.phase === "first") {
-        const [decision2, nextInner2, output2] = first.step(state.inner, input);
-        if (decision2.continue) {
-          return [decision2, { phase: "first", inner: nextInner2 }, output2];
-        }
-        return [{ continue: true, delayMs: decision2.delayMs }, { phase: "second", inner: second.initial() }, output2];
-      }
-      const [decision, nextInner, output] = second.step(state.inner, input);
-      return [decision, { phase: "second", inner: nextInner }, output];
-    }
-  };
-}
-function intersect(left, right) {
-  return {
-    _tag: "Schedule",
-    initial: () => ({ left: left.initial(), right: right.initial() }),
-    step: (state, input) => {
-      const [ld, ls, lo] = left.step(state.left, input);
-      const [rd, rs, ro] = right.step(state.right, input);
-      const cont = ld.continue && rd.continue;
-      const delay = Math.max(ld.delayMs, rd.delayMs);
-      return [{ continue: cont, delayMs: delay }, { left: ls, right: rs }, [lo, ro]];
-    }
-  };
-}
-function union(left, right) {
-  return {
-    _tag: "Schedule",
-    initial: () => ({ left: left.initial(), right: right.initial() }),
-    step: (state, input) => {
-      const [ld, ls, lo] = left.step(state.left, input);
-      const [rd, rs, ro] = right.step(state.right, input);
-      const cont = ld.continue || rd.continue;
-      const delay = Math.min(ld.delayMs, rd.delayMs);
-      return [{ continue: cont, delayMs: delay }, { left: ls, right: rs }, [lo, ro]];
-    }
-  };
-}
-function retryWithSchedule(effect, schedule) {
-  const loop = (state) => asyncFold(
-    effect,
-    (error) => {
-      const [decision, nextState, _output] = schedule.step(state, error);
-      if (!decision.continue) return asyncFail(error);
-      if (decision.delayMs <= 0) return loop(nextState);
-      return asyncFlatMap(sleep(decision.delayMs), () => loop(nextState));
-    },
-    (value) => asyncSucceed(value)
-  );
-  return loop(schedule.initial());
-}
-function repeatWithSchedule(effect, schedule) {
-  const loop = (state, lastValue) => {
-    const [decision, nextState, _output] = schedule.step(state, lastValue);
-    if (!decision.continue) return asyncSucceed(lastValue);
-    if (decision.delayMs <= 0) {
-      return asyncFold(
-        effect,
-        (error) => asyncFail(error),
-        (value) => loop(nextState, value)
-      );
-    }
-    return asyncFlatMap(
-      sleep(decision.delayMs),
-      () => asyncFold(
-        effect,
-        (error) => asyncFail(error),
-        (value) => loop(nextState, value)
-      )
-    );
-  };
-  return asyncFold(
-    effect,
-    (error) => asyncFail(error),
-    (value) => loop(schedule.initial(), value)
-  );
-}
-
 // src/core/runtime/shutdown.ts
 async function gracefulShutdown(runtime, config = {}) {
   const timeoutMs = config.timeoutMs ?? 3e4;
@@ -595,9 +317,9 @@ async function assertCompletesWithin(effect, maxMs, runtime) {
   const rt = runtime ?? Runtime.make({});
   const start = performance.now();
   const result = await rt.toPromise(effect);
-  const elapsed2 = performance.now() - start;
-  if (elapsed2 > maxMs) {
-    throw new Error(`Effect took ${elapsed2.toFixed(1)}ms, expected < ${maxMs}ms`);
+  const elapsed = performance.now() - start;
+  if (elapsed > maxMs) {
+    throw new Error(`Effect took ${elapsed.toFixed(1)}ms, expected < ${maxMs}ms`);
   }
   return result;
 }
@@ -856,97 +578,136 @@ function makeTracer(config) {
   };
 }
 
-// src/core/runtime/metrics.ts
-var DEFAULT_BOUNDARIES = [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 5e3, 1e4];
-function makeMetrics() {
-  const counters = /* @__PURE__ */ new Map();
-  const gauges = /* @__PURE__ */ new Map();
-  const histograms = /* @__PURE__ */ new Map();
-  const key = (name, labels) => labels ? `${name}|${Object.entries(labels).sort().map(([k, v]) => `${k}=${v}`).join(",")}` : name;
-  const counter = (name, labels = {}) => {
-    const k = key(name, labels);
-    if (!counters.has(k)) counters.set(k, { labels, value: 0 });
-    const entry = counters.get(k);
-    return {
-      increment: (n = 1) => {
-        entry.value += Math.max(0, n);
-      },
-      value: () => entry.value
-    };
-  };
-  const gauge = (name, labels = {}) => {
-    const k = key(name, labels);
-    if (!gauges.has(k)) gauges.set(k, { labels, value: 0 });
-    const entry = gauges.get(k);
-    return {
-      set: (v) => {
-        entry.value = v;
-      },
-      increment: (n = 1) => {
-        entry.value += n;
-      },
-      decrement: (n = 1) => {
-        entry.value -= n;
-      },
-      value: () => entry.value
-    };
-  };
-  const histogram = (name, boundaries = DEFAULT_BOUNDARIES, labels = {}) => {
-    const k = key(name, labels);
-    if (!histograms.has(k)) {
-      const sorted = [...boundaries].sort((a, b) => a - b);
-      histograms.set(k, {
-        labels,
-        boundaries: sorted,
-        data: { boundaries: sorted, counts: new Array(sorted.length + 1).fill(0), sum: 0, count: 0, min: Infinity, max: -Infinity }
-      });
+// 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));
     }
-    const entry = histograms.get(k);
-    return {
-      observe: (value) => {
-        entry.data.sum += value;
-        entry.data.count++;
-        entry.data.min = Math.min(entry.data.min, value);
-        entry.data.max = Math.max(entry.data.max, value);
-        let placed = false;
-        for (let i = 0; i < entry.boundaries.length; i++) {
-          if (value <= entry.boundaries[i]) {
-            entry.data.counts[i]++;
-            placed = true;
-            break;
-          }
+  };
+}
+
+// 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" };
         }
-        if (!placed) entry.data.counts[entry.boundaries.length]++;
-      },
-      buckets: () => ({ ...entry.data }),
-      percentile: (p) => {
-        const target = Math.ceil(entry.data.count * (p / 100));
-        let cumulative = 0;
-        for (let i = 0; i < entry.boundaries.length; i++) {
-          cumulative += entry.data.counts[i];
-          if (cumulative >= target) return entry.boundaries[i];
+        break;
+      }
+      case "fiber.resume": {
+        const f = this.fibers.get(rec.fiberId);
+        if (f) {
+          f.runState = "Running";
+          f.lastActiveAt = rec.wallTs;
+          f.awaiting = void 0;
         }
-        return entry.data.max;
+        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: 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;
       }
-    };
-  };
-  return {
-    counter,
-    gauge,
-    histogram,
-    snapshot: () => ({
-      counters: Array.from(counters.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, value: v.value })),
-      gauges: Array.from(gauges.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, value: v.value })),
-      histograms: Array.from(histograms.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, buckets: v.data }))
-    }),
-    reset: () => {
-      counters.clear();
-      gauges.clear();
-      histograms.clear();
     }
-  };
+  }
+  getRecentEvents() {
+    return this.recent.slice();
+  }
+};
+
+// 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(
@@ -990,30 +751,329 @@ 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) {
+      const state = record.scheduleState ?? record.restart.schedule.initial();
+      const [decision, nextState] = record.restart.schedule.step(state, context);
+      record.scheduleState = nextState;
+      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));
+  }
+};
+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" && exit.cause._tag === "Interrupt") 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";
+}
+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,
-  bracket,
-  ensuring,
-  managed,
-  useManaged,
-  managedAll,
   LinkedQueue,
   makeSemaphore,
   makeRef,
   derivedRef,
-  recurs,
-  fixed,
-  exponential,
-  jittered,
-  elapsed,
-  whileInput,
-  take,
-  andThen,
-  intersect,
-  union,
-  retryWithSchedule,
-  repeatWithSchedule,
   gracefulShutdown,
   registerShutdownHooks,
   makeTestRuntime,
@@ -1034,10 +1094,17 @@ export {
   provideLayer,
   makeWorkerPool,
   makeTracer,
-  makeMetrics,
+  consoleJsonLogger,
+  RuntimeRegistry,
+  dumpAllFibers,
+  defaultTracer,
   catchTag,
   catchTags,
   mapError,
   tagError,
-  orElse
+  orElse,
+  Supervisor,
+  makeSupervisor,
+  supervise,
+  joinSupervised
 };