brass-runtime 1.15.0 → 1.16.1

package/dist/chunk-AR22SXML.js

@@ -1,1043 +0,0 @@
-import {
-  sleep
-} from "./chunk-BDYEENHT.js";
-import {
-  Cause,
-  Exit,
-  Runtime,
-  Scope,
-  asyncEffect,
-  asyncFail,
-  asyncFlatMap,
-  asyncFold,
-  asyncMap,
-  asyncSucceed,
-  asyncSync,
-  unit,
-  unsafeGetCurrentRuntime
-} from "./chunk-BMH5AV44.js";
-
-// src/core/types/cancel.ts
-function makeCancelToken() {
-  let cancelled = false;
-  const listeners = /* @__PURE__ */ new Set();
-  const cancel = () => {
-    if (cancelled) return;
-    cancelled = true;
-    listeners.forEach((f) => f());
-    listeners.clear();
-  };
-  return {
-    isCancelled: () => cancelled,
-    onCancel: (f) => {
-      if (cancelled) {
-        try {
-          f();
-        } catch {
-        }
-        return () => {
-        };
-      }
-      listeners.add(f);
-      return () => {
-        listeners.delete(f);
-      };
-    },
-    cancel
-  };
-}
-function linkAbortController(token, ac) {
-  return token.onCancel(() => ac.abort());
-}
-
-// src/core/runtime/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;
-  tail = null;
-  len = 0;
-  get length() {
-    return this.len;
-  }
-  isEmpty() {
-    return this.len === 0;
-  }
-  push(value) {
-    const node = { value, next: null, prev: this.tail, removed: false };
-    if (this.tail) this.tail.next = node;
-    else this.head = node;
-    this.tail = node;
-    this.len++;
-    return node;
-  }
-  shift() {
-    const h = this.head;
-    if (!h) return void 0;
-    this.unlink(h);
-    return h.value;
-  }
-  remove(node) {
-    if (node.removed) return;
-    this.unlink(node);
-  }
-  unlink(node) {
-    node.removed = true;
-    const { prev, next } = node;
-    if (prev) prev.next = next;
-    else this.head = next;
-    if (next) next.prev = prev;
-    else this.tail = prev;
-    node.next = null;
-    node.prev = null;
-    this.len--;
-  }
-};
-
-// src/core/runtime/semaphore.ts
-function makeSemaphore(n) {
-  const capacity = Math.max(1, Math.floor(n));
-  let available = capacity;
-  let totalAcquired = 0;
-  let totalReleased = 0;
-  const waiters = new LinkedQueue();
-  const acquire = () => {
-    return asyncEffect((_env, cb) => {
-      if (available > 0) {
-        available--;
-        totalAcquired++;
-        cb({ _tag: "Success", value: void 0 });
-        return;
-      }
-      const node = waiters.push(cb);
-      return () => {
-        waiters.remove(node);
-      };
-    });
-  };
-  const release = () => {
-    totalReleased++;
-    if (waiters.length > 0) {
-      const waiter = waiters.shift();
-      totalAcquired++;
-      waiter({ _tag: "Success", value: void 0 });
-      return;
-    }
-    available++;
-  };
-  const 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();
-        };
-      })
-    );
-  };
-  return {
-    capacity,
-    available: () => available,
-    waiting: () => waiters.length,
-    withPermit,
-    acquire,
-    release
-  };
-}
-
-// src/core/runtime/ref.ts
-function makeRef(initial) {
-  let value = initial;
-  return {
-    get: () => asyncSync(() => value),
-    set: (v) => asyncSync(() => {
-      value = v;
-    }),
-    update: (f) => asyncSync(() => {
-      value = f(value);
-      return value;
-    }),
-    modify: (f) => asyncSync(() => {
-      const [result, next] = f(value);
-      value = next;
-      return result;
-    }),
-    unsafeGet: () => value
-  };
-}
-function derivedRef(parent, get, set) {
-  return {
-    get: () => asyncSync(() => get(parent.unsafeGet())),
-    set: (b) => asyncFlatMap(parent.get(), (current) => parent.set(set(current, b))),
-    update: (f) => asyncFlatMap(parent.get(), (parentVal) => {
-      const newB = f(get(parentVal));
-      return asyncMap(parent.set(set(parentVal, newB)), () => newB);
-    }),
-    modify: (f) => asyncFlatMap(parent.get(), (parentVal) => {
-      const [result, newB] = f(get(parentVal));
-      return asyncMap(parent.set(set(parentVal, newB)), () => result);
-    }),
-    unsafeGet: () => get(parent.unsafeGet())
-  };
-}
-
-// src/core/runtime/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;
-  const startedAt = Date.now();
-  config.onStart?.();
-  let timedOut = false;
-  const shutdownPromise = (async () => {
-    try {
-      await runtime.shutdown();
-    } catch {
-    }
-  })();
-  const timeoutPromise = new Promise((resolve) => {
-    setTimeout(() => {
-      timedOut = true;
-      resolve();
-    }, timeoutMs);
-  });
-  await Promise.race([shutdownPromise, timeoutPromise]);
-  const completedAt = Date.now();
-  const stats = {
-    startedAt,
-    completedAt,
-    elapsedMs: completedAt - startedAt,
-    timedOut
-  };
-  if (timedOut) {
-    config.onTimeout?.(stats);
-  } else {
-    config.onComplete?.(stats);
-  }
-  return stats;
-}
-function registerShutdownHooks(runtime, config = {}) {
-  let shuttingDown = false;
-  const handler = (signal) => {
-    if (shuttingDown) {
-      process.exit(1);
-    }
-    shuttingDown = true;
-    console.log(`
-[brass-runtime] Received ${signal}, shutting down gracefully...`);
-    gracefulShutdown(runtime, {
-      ...config,
-      onComplete: (stats) => {
-        config.onComplete?.(stats);
-        if (!config.onComplete) {
-          console.log(`[brass-runtime] Shutdown complete (${stats.elapsedMs}ms)`);
-          process.exit(0);
-        }
-      },
-      onTimeout: (stats) => {
-        config.onTimeout?.(stats);
-        if (!config.onTimeout) {
-          console.log(`[brass-runtime] Shutdown timed out after ${stats.elapsedMs}ms, forcing exit`);
-          process.exit(1);
-        }
-      }
-    });
-  };
-  process.on("SIGTERM", () => handler("SIGTERM"));
-  process.on("SIGINT", () => handler("SIGINT"));
-  return () => {
-    process.removeAllListeners("SIGTERM");
-    process.removeAllListeners("SIGINT");
-  };
-}
-
-// src/core/runtime/testing.ts
-function makeTestRuntime(env, options) {
-  const runtime = Runtime.make(env ?? {});
-  const run = (effect) => runtime.toPromise(effect);
-  const runExit = (effect) => new Promise((resolve) => {
-    runtime.unsafeRunAsync(effect, resolve);
-  });
-  return { runtime, run, runExit };
-}
-async function assertSucceeds(effect, expected, runtime) {
-  const rt = runtime ?? Runtime.make({});
-  const exit = await new Promise((resolve) => {
-    rt.unsafeRunAsync(effect, resolve);
-  });
-  if (exit._tag !== "Success") {
-    throw new Error(`Expected success with ${JSON.stringify(expected)}, got failure: ${JSON.stringify(exit.cause)}`);
-  }
-  if (JSON.stringify(exit.value) !== JSON.stringify(expected)) {
-    throw new Error(`Expected ${JSON.stringify(expected)}, got ${JSON.stringify(exit.value)}`);
-  }
-}
-async function assertFails(effect, expectedError, runtime) {
-  const rt = runtime ?? Runtime.make({});
-  const exit = await new Promise((resolve) => {
-    rt.unsafeRunAsync(effect, resolve);
-  });
-  if (exit._tag !== "Failure") {
-    throw new Error(`Expected failure with ${JSON.stringify(expectedError)}, got success: ${JSON.stringify(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)}`);
-  }
-}
-async function assertFailsWith(effect, predicate, runtime) {
-  const rt = runtime ?? Runtime.make({});
-  const exit = await new Promise((resolve) => {
-    rt.unsafeRunAsync(effect, resolve);
-  });
-  if (exit._tag !== "Failure") {
-    throw new Error(`Expected failure, got success: ${JSON.stringify(exit.value)}`);
-  }
-  const error = exit.cause.error;
-  if (!predicate(error)) {
-    throw new Error(`Error did not match predicate: ${JSON.stringify(error)}`);
-  }
-}
-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`);
-  }
-  return result;
-}
-function flakyEffect(failCount, successValue, errorValue) {
-  let calls = 0;
-  return asyncEffect((_env, cb) => {
-    calls++;
-    if (calls <= failCount) {
-      cb({ _tag: "Failure", cause: { _tag: "Fail", error: errorValue } });
-    } else {
-      cb({ _tag: "Success", value: successValue });
-    }
-  });
-}
-function delayedEffect(ms, value) {
-  return asyncEffect((_env, cb) => {
-    const id = setTimeout(() => cb({ _tag: "Success", value }), ms);
-    return () => clearTimeout(id);
-  });
-}
-function neverEffect() {
-  return asyncEffect(() => {
-    return () => {
-    };
-  });
-}
-
-// src/core/runtime/layer.ts
-function layer(acquire, release) {
-  return {
-    _tag: "Layer",
-    build: (_deps) => asyncFlatMap(acquire(), (service) => asyncSucceed({
-      service,
-      release: release ? () => release(service) : () => unit()
-    }))
-  };
-}
-function layerFrom() {
-  return (acquire, release) => ({
-    _tag: "Layer",
-    build: (deps) => asyncFlatMap(acquire(deps), (service) => asyncSucceed({
-      service,
-      release: release ? () => release(service) : () => unit()
-    }))
-  });
-}
-function layerSucceed(value) {
-  return {
-    _tag: "Layer",
-    build: () => asyncSucceed({ service: value, release: () => unit() })
-  };
-}
-function layerFail(error) {
-  return {
-    _tag: "Layer",
-    build: () => asyncFail(error)
-  };
-}
-function compose(from, to) {
-  return {
-    _tag: "Layer",
-    build: (deps) => asyncFlatMap(
-      from.build(deps),
-      ({ service: mid, release: releaseMid }) => asyncFold(
-        to.build(mid),
-        (error) => asyncFlatMap(releaseMid(), () => asyncFail(error)),
-        ({ service: out, release: releaseOut }) => asyncSucceed({
-          service: out,
-          release: () => asyncFlatMap(releaseOut(), () => releaseMid())
-        })
-      )
-    )
-  };
-}
-function merge(left, right) {
-  return {
-    _tag: "Layer",
-    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 },
-          release: () => asyncFlatMap(releaseB(), () => releaseA())
-        })
-      )
-    )
-  };
-}
-function mapLayer(l, f) {
-  return {
-    _tag: "Layer",
-    build: (deps) => asyncFlatMap(
-      l.build(deps),
-      ({ service, release }) => asyncSucceed({ service: f(service), release })
-    )
-  };
-}
-function provideLayer(l, use, deps) {
-  return asyncFlatMap(
-    l.build(deps ?? {}),
-    ({ service, release }) => asyncFold(
-      use(service),
-      (error) => asyncFlatMap(release(), () => asyncFail(error)),
-      (value) => asyncFlatMap(release(), () => asyncSucceed(value))
-    )
-  );
-}
-
-// src/core/runtime/workerPool.ts
-function makeWorkerPool(config = {}) {
-  const size = config.size ?? 4;
-  const maxQueue = config.maxQueue ?? 1e3;
-  const taskTimeoutMs = config.taskTimeoutMs ?? 3e4;
-  let closed = false;
-  let busy = 0;
-  let completed = 0;
-  let failed = 0;
-  let timedOut = 0;
-  const queue = [];
-  const processNext = () => {
-    if (queue.length === 0 || busy >= size) return;
-    const task = queue.shift();
-    busy++;
-    setImmediate(() => {
-      if (task.timeoutId) clearTimeout(task.timeoutId);
-      try {
-        const result = task.fn();
-        busy--;
-        completed++;
-        task.resolve(result);
-        processNext();
-      } catch (e) {
-        busy--;
-        failed++;
-        task.reject({ _tag: "WorkerTaskError", message: String(e) });
-        processNext();
-      }
-    });
-  };
-  const execute = (fn) => {
-    if (closed) return asyncFail({ _tag: "WorkerPoolClosed" });
-    if (queue.length >= maxQueue) {
-      return asyncFail({ _tag: "WorkerPoolFull", queued: queue.length });
-    }
-    return asyncEffect((_env, cb) => {
-      const task = {
-        fn,
-        resolve: (value) => cb({ _tag: "Success", value }),
-        reject: (error) => cb({ _tag: "Failure", cause: { _tag: "Fail", error } })
-      };
-      task.timeoutId = setTimeout(() => {
-        const idx = queue.indexOf(task);
-        if (idx >= 0) {
-          queue.splice(idx, 1);
-          timedOut++;
-          task.reject({ _tag: "WorkerTaskTimeout", ms: taskTimeoutMs });
-        }
-      }, taskTimeoutMs);
-      queue.push(task);
-      processNext();
-      return () => {
-        const idx = queue.indexOf(task);
-        if (idx >= 0) {
-          queue.splice(idx, 1);
-          if (task.timeoutId) clearTimeout(task.timeoutId);
-        }
-      };
-    });
-  };
-  const run = (taskSource, args = []) => {
-    return execute(() => {
-      const fn = new Function(...args.map((_, i) => `arg${i}`), taskSource);
-      return fn(...args);
-    });
-  };
-  return {
-    execute,
-    run,
-    stats: () => ({
-      size,
-      busy,
-      idle: size - busy,
-      queued: queue.length,
-      completed,
-      failed,
-      timedOut
-    }),
-    shutdown: async () => {
-      closed = true;
-      while (queue.length > 0) {
-        const task = queue.shift();
-        if (task.timeoutId) clearTimeout(task.timeoutId);
-        task.reject({ _tag: "WorkerPoolClosed" });
-      }
-    }
-  };
-}
-
-// src/core/runtime/tracing.ts
-var idCounter = 0;
-function generateId() {
-  return (++idCounter).toString(16).padStart(16, "0");
-}
-function makeTracer(config) {
-  const completedSpans = [];
-  const sampleRate = config.sampleRate ?? 1;
-  const shouldSample = () => {
-    if (sampleRate >= 1) return true;
-    if (sampleRate <= 0) return false;
-    return Math.random() < sampleRate;
-  };
-  const span = (name, effect, attributes) => {
-    if (!shouldSample()) return effect;
-    const spanObj = {
-      name,
-      context: {
-        traceId: generateId(),
-        spanId: generateId()
-      },
-      startTime: performance.now(),
-      status: "unset",
-      attributes: { "service.name": config.serviceName, ...attributes },
-      events: []
-    };
-    return asyncFold(
-      effect,
-      (error) => {
-        spanObj.endTime = performance.now();
-        spanObj.status = "error";
-        spanObj.events.push({
-          name: "error",
-          time: performance.now(),
-          attributes: { "error.message": String(error) }
-        });
-        completedSpans.push(spanObj);
-        config.onSpanEnd?.(spanObj);
-        return asyncFail(error);
-      },
-      (value) => {
-        spanObj.endTime = performance.now();
-        spanObj.status = "ok";
-        completedSpans.push(spanObj);
-        config.onSpanEnd?.(spanObj);
-        return asyncSucceed(value);
-      }
-    );
-  };
-  return {
-    span,
-    spans: () => completedSpans,
-    clear: () => {
-      completedSpans.length = 0;
-    }
-  };
-}
-
-// src/core/runtime/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 }
-      });
-    }
-    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;
-          }
-        }
-        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];
-        }
-        return entry.data.max;
-      }
-    };
-  };
-  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();
-    }
-  };
-}
-
-// src/core/types/typedError.ts
-function catchTag(effect, tag, handler) {
-  return asyncFold(
-    effect,
-    (error) => {
-      if (typeof error === "object" && error !== null && "_tag" in error && error._tag === tag) {
-        return handler(error);
-      }
-      return asyncFail(error);
-    },
-    (value) => asyncSucceed(value)
-  );
-}
-function catchTags(effect, handlers) {
-  return asyncFold(
-    effect,
-    (error) => {
-      if (typeof error === "object" && error !== null && "_tag" in error) {
-        const handler = handlers[error._tag];
-        if (handler) return handler(error);
-      }
-      return asyncFail(error);
-    },
-    (value) => asyncSucceed(value)
-  );
-}
-function mapError(effect, f) {
-  return asyncFold(effect, (error) => asyncFail(f(error)), asyncSucceed);
-}
-function tagError(effect, tag, enrich) {
-  return asyncFold(
-    effect,
-    (error) => {
-      const fields = enrich ? enrich(error) : {};
-      return asyncFail({ _tag: tag, ...fields });
-    },
-    asyncSucceed
-  );
-}
-function orElse(effect, fallback) {
-  return asyncFold(effect, fallback, asyncSucceed);
-}
-
-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,
-  assertSucceeds,
-  assertFails,
-  assertFailsWith,
-  assertCompletesWithin,
-  flakyEffect,
-  delayedEffect,
-  neverEffect,
-  layer,
-  layerFrom,
-  layerSucceed,
-  layerFail,
-  compose,
-  merge,
-  mapLayer,
-  provideLayer,
-  makeWorkerPool,
-  makeTracer,
-  makeMetrics,
-  catchTag,
-  catchTags,
-  mapError,
-  tagError,
-  orElse
-};