brass-runtime 1.14.0 → 1.15.0

package/dist/chunk-XPZNXSVN.cjs

@@ -0,0 +1,1043 @@
+"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 _chunkMS34J5LYcjs = require('./chunk-MS34J5LY.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkTGIFUAK4cjs = require('./chunk-TGIFUAK4.cjs');
+
+// 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 (e2) {
+        }
+        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 _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (env, cb) => {
+    const runtime = _chunkTGIFUAK4cjs.unsafeGetCurrentRuntime.call(void 0, );
+    const scope = new (0, _chunkTGIFUAK4cjs.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(_chunkTGIFUAK4cjs.Exit.failCause(_chunkTGIFUAK4cjs.Cause.interrupt()));
+    };
+  });
+}
+function safeRelease(release, resource, exit) {
+  return _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+    (() => {
+      try {
+        return release(resource, exit);
+      } catch (e3) {
+        return _chunkTGIFUAK4cjs.unit.call(void 0, );
+      }
+    })(),
+    () => _chunkTGIFUAK4cjs.unit.call(void 0, ),
+    () => _chunkTGIFUAK4cjs.unit.call(void 0, )
+  );
+}
+function ensuring(effect, finalizer) {
+  return _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (env, cb) => {
+    const runtime = _chunkTGIFUAK4cjs.unsafeGetCurrentRuntime.call(void 0, );
+    const fiber = runtime.fork(effect);
+    fiber.join((exit) => {
+      const fin = _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+        (() => {
+          try {
+            return finalizer(exit);
+          } catch (e4) {
+            return _chunkTGIFUAK4cjs.unit.call(void 0, );
+          }
+        })(),
+        () => _chunkTGIFUAK4cjs.unit.call(void 0, ),
+        () => _chunkTGIFUAK4cjs.unit.call(void 0, )
+      );
+      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 = _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (env, cb) => {
+    const runtime = _chunkTGIFUAK4cjs.unsafeGetCurrentRuntime.call(void 0, );
+    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 _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (_env, cb) => {
+      const runtime = _chunkTGIFUAK4cjs.unsafeGetCurrentRuntime.call(void 0, );
+      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 = _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+          m.release(resources[i], exit),
+          () => _chunkTGIFUAK4cjs.unit.call(void 0, ),
+          () => _chunkTGIFUAK4cjs.unit.call(void 0, )
+        );
+        runtime.fork(releaseEff).join(() => resolve());
+      });
+    } catch (e5) {
+    }
+  }
+}
+
+// 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}
+  __init2() {this.tail = null}
+  __init3() {this.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--;
+  }
+}, _class);
+
+// 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 _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (_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 _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, 
+      acquire(),
+      () => _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (_env, cb) => {
+        const runtime = _chunkTGIFUAK4cjs.unsafeGetCurrentRuntime.call(void 0, );
+        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: () => _chunkTGIFUAK4cjs.asyncSync.call(void 0, () => value),
+    set: (v) => _chunkTGIFUAK4cjs.asyncSync.call(void 0, () => {
+      value = v;
+    }),
+    update: (f) => _chunkTGIFUAK4cjs.asyncSync.call(void 0, () => {
+      value = f(value);
+      return value;
+    }),
+    modify: (f) => _chunkTGIFUAK4cjs.asyncSync.call(void 0, () => {
+      const [result, next] = f(value);
+      value = next;
+      return result;
+    }),
+    unsafeGet: () => value
+  };
+}
+function derivedRef(parent, get, set) {
+  return {
+    get: () => _chunkTGIFUAK4cjs.asyncSync.call(void 0, () => get(parent.unsafeGet())),
+    set: (b) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, parent.get(), (current) => parent.set(set(current, b))),
+    update: (f) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, parent.get(), (parentVal) => {
+      const newB = f(get(parentVal));
+      return _chunkTGIFUAK4cjs.asyncMap.call(void 0, parent.set(set(parentVal, newB)), () => newB);
+    }),
+    modify: (f) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, parent.get(), (parentVal) => {
+      const [result, newB] = f(get(parentVal));
+      return _chunkTGIFUAK4cjs.asyncMap.call(void 0, 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) => _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+    effect,
+    (error) => {
+      const [decision, nextState, _output] = schedule.step(state, error);
+      if (!decision.continue) return _chunkTGIFUAK4cjs.asyncFail.call(void 0, error);
+      if (decision.delayMs <= 0) return loop(nextState);
+      return _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, _chunkMS34J5LYcjs.sleep.call(void 0, decision.delayMs), () => loop(nextState));
+    },
+    (value) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, 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 _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, lastValue);
+    if (decision.delayMs <= 0) {
+      return _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+        effect,
+        (error) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, error),
+        (value) => loop(nextState, value)
+      );
+    }
+    return _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, 
+      _chunkMS34J5LYcjs.sleep.call(void 0, decision.delayMs),
+      () => _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+        effect,
+        (error) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, error),
+        (value) => loop(nextState, value)
+      )
+    );
+  };
+  return _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+    effect,
+    (error) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, error),
+    (value) => loop(schedule.initial(), value)
+  );
+}
+
+// src/core/runtime/shutdown.ts
+async function gracefulShutdown(runtime, config = {}) {
+  const timeoutMs = _nullishCoalesce(config.timeoutMs, () => ( 3e4));
+  const startedAt = Date.now();
+  _optionalChain([config, 'access', _2 => _2.onStart, 'optionalCall', _3 => _3()]);
+  let timedOut = false;
+  const shutdownPromise = (async () => {
+    try {
+      await runtime.shutdown();
+    } catch (e6) {
+    }
+  })();
+  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) {
+    _optionalChain([config, 'access', _4 => _4.onTimeout, 'optionalCall', _5 => _5(stats)]);
+  } else {
+    _optionalChain([config, 'access', _6 => _6.onComplete, 'optionalCall', _7 => _7(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) => {
+        _optionalChain([config, 'access', _8 => _8.onComplete, 'optionalCall', _9 => _9(stats)]);
+        if (!config.onComplete) {
+          console.log(`[brass-runtime] Shutdown complete (${stats.elapsedMs}ms)`);
+          process.exit(0);
+        }
+      },
+      onTimeout: (stats) => {
+        _optionalChain([config, 'access', _10 => _10.onTimeout, 'optionalCall', _11 => _11(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 = _chunkTGIFUAK4cjs.Runtime.make(_nullishCoalesce(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 = _nullishCoalesce(runtime, () => ( _chunkTGIFUAK4cjs.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 = _nullishCoalesce(runtime, () => ( _chunkTGIFUAK4cjs.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 = _nullishCoalesce(runtime, () => ( _chunkTGIFUAK4cjs.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 = _nullishCoalesce(runtime, () => ( _chunkTGIFUAK4cjs.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 _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (_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 _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (_env, cb) => {
+    const id = setTimeout(() => cb({ _tag: "Success", value }), ms);
+    return () => clearTimeout(id);
+  });
+}
+function neverEffect() {
+  return _chunkTGIFUAK4cjs.asyncEffect.call(void 0, () => {
+    return () => {
+    };
+  });
+}
+
+// src/core/runtime/layer.ts
+function layer(acquire, release) {
+  return {
+    _tag: "Layer",
+    build: (_deps) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, acquire(), (service) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, {
+      service,
+      release: release ? () => release(service) : () => _chunkTGIFUAK4cjs.unit.call(void 0, )
+    }))
+  };
+}
+function layerFrom() {
+  return (acquire, release) => ({
+    _tag: "Layer",
+    build: (deps) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, acquire(deps), (service) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, {
+      service,
+      release: release ? () => release(service) : () => _chunkTGIFUAK4cjs.unit.call(void 0, )
+    }))
+  });
+}
+function layerSucceed(value) {
+  return {
+    _tag: "Layer",
+    build: () => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, { service: value, release: () => _chunkTGIFUAK4cjs.unit.call(void 0, ) })
+  };
+}
+function layerFail(error) {
+  return {
+    _tag: "Layer",
+    build: () => _chunkTGIFUAK4cjs.asyncFail.call(void 0, error)
+  };
+}
+function compose(from, to) {
+  return {
+    _tag: "Layer",
+    build: (deps) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, 
+      from.build(deps),
+      ({ service: mid, release: releaseMid }) => _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+        to.build(mid),
+        (error) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, releaseMid(), () => _chunkTGIFUAK4cjs.asyncFail.call(void 0, error)),
+        ({ service: out, release: releaseOut }) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, {
+          service: out,
+          release: () => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, releaseOut(), () => releaseMid())
+        })
+      )
+    )
+  };
+}
+function merge(left, right) {
+  return {
+    _tag: "Layer",
+    build: (deps) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, 
+      left.build(deps),
+      ({ service: a, release: releaseA }) => _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+        right.build(deps),
+        (error) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, releaseA(), () => _chunkTGIFUAK4cjs.asyncFail.call(void 0, error)),
+        ({ service: b, release: releaseB }) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, {
+          service: { ...a, ...b },
+          release: () => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, releaseB(), () => releaseA())
+        })
+      )
+    )
+  };
+}
+function mapLayer(l, f) {
+  return {
+    _tag: "Layer",
+    build: (deps) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, 
+      l.build(deps),
+      ({ service, release }) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, { service: f(service), release })
+    )
+  };
+}
+function provideLayer(l, use, deps) {
+  return _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, 
+    l.build(_nullishCoalesce(deps, () => ( {}))),
+    ({ service, release }) => _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+      use(service),
+      (error) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, release(), () => _chunkTGIFUAK4cjs.asyncFail.call(void 0, error)),
+      (value) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, release(), () => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, value))
+    )
+  );
+}
+
+// src/core/runtime/workerPool.ts
+function makeWorkerPool(config = {}) {
+  const size = _nullishCoalesce(config.size, () => ( 4));
+  const maxQueue = _nullishCoalesce(config.maxQueue, () => ( 1e3));
+  const taskTimeoutMs = _nullishCoalesce(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 _chunkTGIFUAK4cjs.asyncFail.call(void 0, { _tag: "WorkerPoolClosed" });
+    if (queue.length >= maxQueue) {
+      return _chunkTGIFUAK4cjs.asyncFail.call(void 0, { _tag: "WorkerPoolFull", queued: queue.length });
+    }
+    return _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (_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 = _nullishCoalesce(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 _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+      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);
+        _optionalChain([config, 'access', _12 => _12.onSpanEnd, 'optionalCall', _13 => _13(spanObj)]);
+        return _chunkTGIFUAK4cjs.asyncFail.call(void 0, error);
+      },
+      (value) => {
+        spanObj.endTime = performance.now();
+        spanObj.status = "ok";
+        completedSpans.push(spanObj);
+        _optionalChain([config, 'access', _14 => _14.onSpanEnd, 'optionalCall', _15 => _15(spanObj)]);
+        return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, 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 _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+    effect,
+    (error) => {
+      if (typeof error === "object" && error !== null && "_tag" in error && error._tag === tag) {
+        return handler(error);
+      }
+      return _chunkTGIFUAK4cjs.asyncFail.call(void 0, error);
+    },
+    (value) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, value)
+  );
+}
+function catchTags(effect, handlers) {
+  return _chunkTGIFUAK4cjs.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 _chunkTGIFUAK4cjs.asyncFail.call(void 0, error);
+    },
+    (value) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, value)
+  );
+}
+function mapError(effect, f) {
+  return _chunkTGIFUAK4cjs.asyncFold.call(void 0, effect, (error) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, f(error)), _chunkTGIFUAK4cjs.asyncSucceed);
+}
+function tagError(effect, tag, enrich) {
+  return _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+    effect,
+    (error) => {
+      const fields = enrich ? enrich(error) : {};
+      return _chunkTGIFUAK4cjs.asyncFail.call(void 0, { _tag: tag, ...fields });
+    },
+    _chunkTGIFUAK4cjs.asyncSucceed
+  );
+}
+function orElse(effect, fallback) {
+  return _chunkTGIFUAK4cjs.asyncFold.call(void 0, effect, fallback, _chunkTGIFUAK4cjs.asyncSucceed);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.makeCancelToken = makeCancelToken; exports.linkAbortController = linkAbortController; exports.bracket = bracket; exports.ensuring = ensuring; exports.managed = managed; exports.useManaged = useManaged; exports.managedAll = managedAll; exports.LinkedQueue = LinkedQueue; exports.makeSemaphore = makeSemaphore; exports.makeRef = makeRef; exports.derivedRef = derivedRef; exports.recurs = recurs; exports.fixed = fixed; exports.exponential = exponential; exports.jittered = jittered; exports.elapsed = elapsed; exports.whileInput = whileInput; exports.take = take; exports.andThen = andThen; exports.intersect = intersect; exports.union = union; exports.retryWithSchedule = retryWithSchedule; exports.repeatWithSchedule = repeatWithSchedule; 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.makeMetrics = makeMetrics; exports.catchTag = catchTag; exports.catchTags = catchTags; exports.mapError = mapError; exports.tagError = tagError; exports.orElse = orElse;