@graphrefly/graphrefly 0.45.0 → 0.47.0

package/dist/chunk-RJOG4IJU.js

@@ -0,0 +1,1039 @@
+import {
+  domainMeta
+} from "./chunk-FMPF42Q4.js";
+import {
+  clampNonNegative,
+  isAsyncIterable,
+  isNode,
+  isThenable,
+  msgVal,
+  operatorOpts,
+  resolveReactiveOption
+} from "./chunk-TSBFTJKM.js";
+import {
+  NS_PER_MS,
+  NS_PER_SEC
+} from "./chunk-P5LBT622.js";
+
+// src/utils/resilience/breaker.ts
+import {
+  COMPLETE,
+  DATA,
+  DIRTY,
+  ERROR,
+  factoryTag,
+  monotonicNs,
+  node,
+  RESOLVED
+} from "@graphrefly/pure-ts/core";
+var CircuitOpenError = class extends Error {
+  name = "CircuitOpenError";
+  constructor() {
+    super("Circuit breaker is open");
+  }
+};
+function circuitBreaker(options) {
+  let threshold = 5;
+  let baseCooldownNs = 30 * NS_PER_SEC;
+  let cooldownStrategy = null;
+  let halfOpenMax = 1;
+  let now = monotonicNs;
+  function applyOptions(o) {
+    threshold = Math.max(1, o?.failureThreshold ?? 5);
+    baseCooldownNs = clampNonNegative(o?.cooldownNs ?? 30 * NS_PER_SEC);
+    cooldownStrategy = o?.cooldown ?? null;
+    halfOpenMax = Math.max(1, o?.halfOpenMax ?? 1);
+    now = o?.now ?? monotonicNs;
+  }
+  let _state = "closed";
+  let _failureCount = 0;
+  let _openCycle = 0;
+  let _lastOpenedAt = 0;
+  let _lastCooldownNs = baseCooldownNs;
+  let _halfOpenAttempts = 0;
+  let initialOpts;
+  let optsUnsub;
+  if (isNode(options)) {
+    const optsNode = options;
+    initialOpts = optsNode.cache;
+    applyOptions(initialOpts);
+    const lockedNow = initialOpts?.now;
+    const hadInitialCache = initialOpts !== void 0;
+    let firstEmit = hadInitialCache;
+    optsUnsub = optsNode.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] !== DATA) continue;
+        if (firstEmit) {
+          firstEmit = false;
+          continue;
+        }
+        const next = m[1];
+        if (next == null || typeof next !== "object") continue;
+        if (Object.keys(next).length === 0) continue;
+        if ("now" in next && next.now !== lockedNow) {
+          console.error(
+            "circuitBreaker: ignoring mid-flight `now` change \u2014 clock override is mode-locked at construction. Prior `now` preserved."
+          );
+          continue;
+        }
+        const merged = {
+          ...initialOpts ?? {},
+          ...next,
+          ...lockedNow !== void 0 ? { now: lockedNow } : {}
+        };
+        applyOptions(merged);
+        initialOpts = merged;
+      }
+    });
+  } else {
+    applyOptions(options);
+  }
+  _lastCooldownNs = baseCooldownNs;
+  function getCooldownNs() {
+    if (!cooldownStrategy) return baseCooldownNs;
+    const delayNs = cooldownStrategy(_openCycle);
+    return delayNs !== null ? delayNs : baseCooldownNs;
+  }
+  function transitionToOpen() {
+    _state = "open";
+    _lastCooldownNs = getCooldownNs();
+    _lastOpenedAt = now();
+    _halfOpenAttempts = 0;
+  }
+  const breaker = {
+    canExecute() {
+      if (_state === "closed") return true;
+      if (_state === "open") {
+        const elapsed = now() - _lastOpenedAt;
+        if (elapsed >= _lastCooldownNs) {
+          _state = "half-open";
+          _halfOpenAttempts = 1;
+          return true;
+        }
+        return false;
+      }
+      if (_halfOpenAttempts < halfOpenMax) {
+        _halfOpenAttempts++;
+        return true;
+      }
+      return false;
+    },
+    recordSuccess() {
+      if (_state === "half-open") {
+        _state = "closed";
+        _failureCount = 0;
+        _openCycle = 0;
+      } else if (_state === "closed") {
+        _failureCount = 0;
+      }
+    },
+    recordFailure(_error) {
+      if (_state === "half-open") {
+        _openCycle++;
+        transitionToOpen();
+        return;
+      }
+      if (_state === "closed") {
+        _failureCount++;
+        if (_failureCount >= threshold) {
+          transitionToOpen();
+        }
+      }
+    },
+    get state() {
+      return _state;
+    },
+    get failureCount() {
+      return _failureCount;
+    },
+    reset() {
+      _state = "closed";
+      _failureCount = 0;
+      _openCycle = 0;
+      _halfOpenAttempts = 0;
+    },
+    dispose() {
+      optsUnsub?.();
+    }
+    // Internal accessors used by withBreaker for the BreakerState
+    // companion (DS-13.5.B). Not part of the public CircuitBreaker
+    // interface but exposed for the bundle wiring.
+  };
+  breaker._stateSnapshot = () => ({
+    status: _state,
+    failureCount: _failureCount,
+    openCycle: _openCycle,
+    lastOpenedAtNs: _lastOpenedAt,
+    halfOpenAttempts: _halfOpenAttempts,
+    lastCooldownNs: _lastCooldownNs
+  });
+  return breaker;
+}
+function withBreaker(breaker, options) {
+  const onOpen = options?.onOpen ?? "skip";
+  const callerMeta = options?.meta;
+  return (source) => {
+    const snapshot = breaker._stateSnapshot;
+    const initialSnapshot = snapshot ? snapshot() : {
+      status: breaker.state,
+      failureCount: breaker.failureCount,
+      openCycle: 0,
+      lastOpenedAtNs: 0,
+      halfOpenAttempts: 0,
+      lastCooldownNs: 0
+    };
+    const wrapped = node(
+      [],
+      (_deps, a) => {
+        function syncState() {
+          const s = snapshot ? snapshot() : {
+            status: breaker.state,
+            failureCount: breaker.failureCount,
+            openCycle: 0,
+            lastOpenedAtNs: 0,
+            halfOpenAttempts: 0,
+            lastCooldownNs: 0
+          };
+          wrapped.meta.breakerState.down([[DIRTY], [DATA, s]]);
+        }
+        const unsub = source.subscribe((msgs) => {
+          for (const m of msgs) {
+            const t = m[0];
+            if (t === DIRTY) a.down([[DIRTY]]);
+            else if (t === DATA) {
+              if (breaker.canExecute()) {
+                syncState();
+                a.emit(m[1]);
+              } else {
+                syncState();
+                if (onOpen === "error") a.down([[ERROR, new CircuitOpenError()]]);
+                else a.down([[RESOLVED]]);
+              }
+            } else if (t === RESOLVED) a.down([[RESOLVED]]);
+            else if (t === COMPLETE) {
+              breaker.recordSuccess();
+              syncState();
+              a.down([[COMPLETE]]);
+            } else if (t === ERROR) {
+              breaker.recordFailure(msgVal(m));
+              syncState();
+              a.down([m]);
+            } else a.down([m]);
+          }
+        });
+        syncState();
+        return unsub;
+      },
+      {
+        ...operatorOpts(),
+        meta: {
+          ...callerMeta ?? {},
+          breakerState: initialSnapshot,
+          ...factoryTag("withBreaker", { onOpen })
+        },
+        completeWhenDepsComplete: false,
+        initial: source.cache
+      }
+    );
+    return { node: wrapped, breakerState: wrapped.meta.breakerState };
+  };
+}
+
+// src/utils/resilience/budget-gate.ts
+import {
+  COMPLETE as COMPLETE2,
+  DATA as DATA2,
+  DIRTY as DIRTY2,
+  ERROR as ERROR2,
+  node as node2,
+  PAUSE,
+  RESOLVED as RESOLVED2,
+  RESUME
+} from "@graphrefly/pure-ts/core";
+var HeadIndexQueue = class {
+  buf = [];
+  head = 0;
+  get size() {
+    return this.buf.length - this.head;
+  }
+  push(item) {
+    this.buf.push(item);
+  }
+  /** O(1) — removes and returns the oldest item, or `undefined` when empty. */
+  shift() {
+    if (this.head >= this.buf.length) return void 0;
+    const item = this.buf[this.head];
+    this.buf[this.head] = void 0;
+    this.head++;
+    if (this.head > 32 && this.head * 2 > this.buf.length) {
+      this.buf = this.buf.slice(this.head);
+      this.head = 0;
+    }
+    return item;
+  }
+  clear() {
+    this.buf = [];
+    this.head = 0;
+  }
+};
+function budgetGate(source, constraints, opts) {
+  if (constraints.length === 0) throw new RangeError("budgetGate requires at least one constraint");
+  const constraintNodes = constraints.map((c) => c.node);
+  const allDeps = [source, ...constraintNodes];
+  const buffer = new HeadIndexQueue();
+  let paused = false;
+  let pendingResolved = false;
+  const lockId = /* @__PURE__ */ Symbol("budget-gate");
+  const latestValues = new Array(constraints.length);
+  function checkBudget() {
+    return constraints.every((c, i) => c.check(latestValues[i]));
+  }
+  function budgetGateStateEqual(a, b) {
+    if (a === b) return true;
+    if (a.status !== b.status) return false;
+    const sa = a.constraintsSnapshot;
+    const sb = b.constraintsSnapshot;
+    if (sa.length !== sb.length) return false;
+    for (let i = 0; i < sa.length; i++) {
+      const ai = sa[i];
+      const bi = sb[i];
+      if (ai === void 0 || bi === void 0) return false;
+      if (ai.name !== bi.name) return false;
+      if (ai.satisfied !== bi.satisfied) return false;
+      if (!Object.is(ai.value, bi.value)) return false;
+    }
+    return true;
+  }
+  const budgetGateState = node2([], {
+    name: "budgetGateState",
+    describeKind: "state",
+    initial: {
+      status: "closed",
+      constraintsSnapshot: constraints.map((c) => ({
+        name: c.name ?? c.node.name ?? "",
+        satisfied: false,
+        value: void 0
+      }))
+    },
+    equals: budgetGateStateEqual
+  });
+  let lastEmittedState = null;
+  function publishState() {
+    const snapshot = constraints.map((c, i) => {
+      const v = latestValues[i];
+      let satisfied = false;
+      try {
+        satisfied = c.check(v);
+      } catch (err) {
+        console.error(
+          `budgetGate: constraint "${c.name ?? c.node.name ?? `[${i}]`}" check threw; treating as not satisfied.`,
+          err
+        );
+        satisfied = false;
+      }
+      return {
+        name: c.name ?? c.node.name ?? "",
+        satisfied,
+        value: v
+      };
+    });
+    const status = snapshot.every((s) => s.satisfied) ? "open" : "closed";
+    const next = { status, constraintsSnapshot: snapshot };
+    if (lastEmittedState != null && budgetGateStateEqual(lastEmittedState, next)) {
+      return;
+    }
+    lastEmittedState = next;
+    budgetGateState.down([[DIRTY2], [DATA2, next]]);
+  }
+  function flushBuffer(actions) {
+    while (buffer.size > 0 && checkBudget()) {
+      const item = buffer.shift();
+      actions.emit(item);
+    }
+    if (buffer.size === 0 && pendingResolved) {
+      pendingResolved = false;
+      actions.down([[RESOLVED2]]);
+    }
+  }
+  const out = node2(
+    [],
+    (_data, gateActions) => {
+      for (let i = 0; i < constraints.length; i++) {
+        latestValues[i] = constraints[i].node.cache;
+      }
+      publishState();
+      const unsubs = [];
+      for (let depIdx = 0; depIdx < allDeps.length; depIdx++) {
+        const dep = allDeps[depIdx];
+        unsubs.push(
+          dep.subscribe((msgs) => {
+            for (const msg of msgs) {
+              _handleBudgetMessage(msg, depIdx, gateActions);
+            }
+          })
+        );
+      }
+      return () => {
+        for (const u of unsubs) u();
+      };
+    },
+    {
+      ...opts,
+      describeKind: "derived",
+      meta: domainMeta("resilience", "budget_gate", opts?.meta)
+    }
+  );
+  return { node: out, budgetGateState };
+  function _handleBudgetMessage(msg, depIndex, actions) {
+    const t = msg[0];
+    if (depIndex === 0) {
+      if (t === DATA2) {
+        if (checkBudget() && buffer.size === 0) {
+          actions.emit(msg[1]);
+        } else {
+          buffer.push(msg[1]);
+          if (!paused) {
+            paused = true;
+            actions.up([[PAUSE, lockId]]);
+          }
+        }
+        return true;
+      }
+      if (t === DIRTY2) {
+        actions.down([[DIRTY2]]);
+        return true;
+      }
+      if (t === RESOLVED2) {
+        if (buffer.size === 0) {
+          actions.down([[RESOLVED2]]);
+        } else {
+          pendingResolved = true;
+        }
+        return true;
+      }
+      if (t === COMPLETE2 || t === ERROR2) {
+        while (buffer.size > 0) {
+          actions.emit(buffer.shift());
+        }
+        pendingResolved = false;
+        if (paused) {
+          paused = false;
+          actions.up([[RESUME, lockId]]);
+        }
+        actions.down([msg]);
+        return true;
+      }
+      return false;
+    }
+    if (t === DATA2) {
+      latestValues[depIndex - 1] = msg[1];
+    }
+    if (t === DATA2 || t === RESOLVED2) {
+      const ok = checkBudget();
+      if (ok && buffer.size > 0) {
+        flushBuffer(actions);
+        if (buffer.size === 0 && paused) {
+          paused = false;
+          actions.up([[RESUME, lockId]]);
+        }
+      } else if (!ok && !paused && buffer.size > 0) {
+        paused = true;
+        actions.up([[PAUSE, lockId]]);
+      }
+      if (t === DATA2) publishState();
+      return true;
+    }
+    if (t === DIRTY2) {
+      return true;
+    }
+    if (t === ERROR2) {
+      actions.down([msg]);
+      return true;
+    }
+    if (t === COMPLETE2) {
+      return true;
+    }
+    return false;
+  }
+}
+
+// src/utils/resilience/fallback.ts
+import {
+  COMPLETE as COMPLETE3,
+  DATA as DATA3,
+  DIRTY as DIRTY3,
+  ERROR as ERROR3,
+  factoryTag as factoryTag2,
+  node as node3,
+  RESOLVED as RESOLVED3,
+  TEARDOWN
+} from "@graphrefly/pure-ts/core";
+import { fromAny } from "@graphrefly/pure-ts/extra";
+function fallback(source, fb, options) {
+  const callerMeta = options?.meta;
+  return node3(
+    (_data, a) => {
+      let fallbackUnsub;
+      let sourceUnsub;
+      function switchToFallback() {
+        sourceUnsub?.();
+        sourceUnsub = void 0;
+        if (isNode(fb) || isThenable(fb) || isAsyncIterable(fb)) {
+          const fbNode = fromAny(fb);
+          fallbackUnsub = fbNode.subscribe((fMsgs) => {
+            a.down(fMsgs);
+            for (const fm of fMsgs) {
+              const ft = fm[0];
+              if (ft === COMPLETE3 || ft === ERROR3 || ft === TEARDOWN) {
+                fallbackUnsub = void 0;
+                return;
+              }
+            }
+          });
+        } else {
+          a.emit(fb);
+          a.down([[COMPLETE3]]);
+        }
+      }
+      sourceUnsub = source.subscribe((msgs) => {
+        for (const m of msgs) {
+          const t = m[0];
+          if (t === DIRTY3) a.down([[DIRTY3]]);
+          else if (t === DATA3) a.emit(m[1]);
+          else if (t === RESOLVED3) a.down([[RESOLVED3]]);
+          else if (t === COMPLETE3) a.down([[COMPLETE3]]);
+          else if (t === ERROR3) {
+            switchToFallback();
+            return;
+          } else if (t === TEARDOWN) {
+            fallbackUnsub?.();
+            a.down([m]);
+            return;
+          } else a.down([m]);
+        }
+      });
+      return () => {
+        sourceUnsub?.();
+        fallbackUnsub?.();
+      };
+    },
+    {
+      ...operatorOpts(),
+      initial: source.cache,
+      meta: { ...callerMeta ?? {}, ...factoryTag2("fallback") }
+    }
+  );
+}
+
+// src/utils/resilience/rate-limiter.ts
+import {
+  COMPLETE as COMPLETE4,
+  DATA as DATA5,
+  DIRTY as DIRTY4,
+  ERROR as ERROR4,
+  factoryTag as factoryTag3,
+  monotonicNs as monotonicNs3,
+  node as node5,
+  RESOLVED as RESOLVED4,
+  ResettableTimer as ResettableTimer2,
+  RingBuffer,
+  TEARDOWN as TEARDOWN2
+} from "@graphrefly/pure-ts/core";
+
+// src/utils/resilience/adaptive-rate-limiter.ts
+import { DATA as DATA4, monotonicNs as monotonicNs2, node as node4, ResettableTimer } from "@graphrefly/pure-ts/core";
+import { fromAny as fromAny2 } from "@graphrefly/pure-ts/extra";
+function makeAbortError(reason) {
+  const err = new Error(reason);
+  err.name = "AbortError";
+  return err;
+}
+function adaptiveRateLimiter(opts = {}) {
+  const burst = Math.max(1, opts.burstMultiplier ?? 1);
+  const clampCooldownMs = opts.clampCooldownMs ?? 6e4;
+  const rpmInputNode = opts.rpm != null ? fromAny2(opts.rpm) : node4([], { initial: Number.POSITIVE_INFINITY });
+  const tpmInputNode = opts.tpm != null ? fromAny2(opts.tpm) : node4([], { initial: Number.POSITIVE_INFINITY });
+  const signalRpmCap = node4([], {
+    initial: Number.POSITIVE_INFINITY,
+    name: "adaptiveRateLimiter/signalRpmCap"
+  });
+  const signalTpmCap = node4([], {
+    initial: Number.POSITIVE_INFINITY,
+    name: "adaptiveRateLimiter/signalTpmCap"
+  });
+  const lastSignal = node4([], {
+    initial: {},
+    name: "adaptiveRateLimiter/lastSignal"
+  });
+  const effectiveRpm = node4(
+    [rpmInputNode, signalRpmCap],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(Math.min(Number(data[0] ?? Infinity), Number(data[1] ?? Infinity)));
+    },
+    { name: "adaptiveRateLimiter/effectiveRpm", describeKind: "derived" }
+  );
+  const effectiveTpm = node4(
+    [tpmInputNode, signalTpmCap],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(Math.min(Number(data[0] ?? Infinity), Number(data[1] ?? Infinity)));
+    },
+    { name: "adaptiveRateLimiter/effectiveTpm", describeKind: "derived" }
+  );
+  let rpmBucket = makeBucket(
+    Number(rpmInputNode.cache ?? Number.POSITIVE_INFINITY),
+    burst
+  );
+  let tpmBucket = makeBucket(
+    Number(tpmInputNode.cache ?? Number.POSITIVE_INFINITY),
+    burst
+  );
+  let rpmHardStop = false;
+  let tpmHardStop = false;
+  const unsubRpm = effectiveRpm.subscribe((msgs) => {
+    for (const msg of msgs) {
+      if (msg[0] === DATA4) {
+        const v = Number(msg[1]);
+        if (Number.isFinite(v) && v > 0) {
+          rpmBucket = makeBucket(v, burst);
+          rpmHardStop = false;
+        } else if (v === Infinity) {
+          rpmBucket = makeBucket(Infinity, burst);
+          rpmHardStop = false;
+        } else if (v <= 0) {
+          rpmHardStop = true;
+        }
+      }
+    }
+  });
+  const unsubTpm = effectiveTpm.subscribe((msgs) => {
+    for (const msg of msgs) {
+      if (msg[0] === DATA4) {
+        const v = Number(msg[1]);
+        if (Number.isFinite(v) && v > 0) {
+          tpmBucket = makeBucket(v, burst);
+          tpmHardStop = false;
+        } else if (v === Infinity) {
+          tpmBucket = makeBucket(Infinity, burst);
+          tpmHardStop = false;
+        } else if (v <= 0) {
+          tpmHardStop = true;
+        }
+      }
+    }
+  });
+  let throttleUntilNs = 0;
+  const rpmDecayTimer = new ResettableTimer();
+  const tpmDecayTimer = new ResettableTimer();
+  let unsubAdapt;
+  if (opts.adaptation != null) {
+    const adaptNode = fromAny2(opts.adaptation);
+    unsubAdapt = adaptNode.subscribe((msgs) => {
+      for (const msg of msgs) {
+        if (msg[0] === DATA4) applySignal(msg[1]);
+      }
+    });
+  }
+  function applySignal(sig) {
+    lastSignal.emit(sig);
+    if (sig.rpmCap != null && Number.isFinite(sig.rpmCap) && sig.rpmCap >= 0) {
+      signalRpmCap.emit(sig.rpmCap);
+      if (Number.isFinite(clampCooldownMs) && clampCooldownMs > 0) {
+        rpmDecayTimer.start(clampCooldownMs, () => signalRpmCap.emit(Number.POSITIVE_INFINITY));
+      }
+    }
+    if (sig.tpmCap != null && Number.isFinite(sig.tpmCap) && sig.tpmCap >= 0) {
+      signalTpmCap.emit(sig.tpmCap);
+      if (Number.isFinite(clampCooldownMs) && clampCooldownMs > 0) {
+        tpmDecayTimer.start(clampCooldownMs, () => signalTpmCap.emit(Number.POSITIVE_INFINITY));
+      }
+    }
+    if (sig.retryAfterMs != null && sig.retryAfterMs > 0) {
+      const resumeAt = monotonicNs2() + sig.retryAfterMs * 1e6;
+      if (resumeAt > throttleUntilNs) throttleUntilNs = resumeAt;
+    }
+  }
+  const pending = node4([], { initial: 0, name: "adaptiveRateLimiter/pending" });
+  const rpmAvailableNode = node4([], {
+    initial: Number.POSITIVE_INFINITY,
+    name: "adaptiveRateLimiter/rpmAvailable"
+  });
+  const tpmAvailableNode = node4([], {
+    initial: Number.POSITIVE_INFINITY,
+    name: "adaptiveRateLimiter/tpmAvailable"
+  });
+  const bumpPending = (delta) => {
+    pending.emit((pending.cache ?? 0) + delta);
+  };
+  const refreshAvailable = () => {
+    rpmAvailableNode.emit(rpmBucket.available());
+    tpmAvailableNode.emit(tpmBucket.available());
+  };
+  async function acquire(acquireOpts = {}) {
+    const requestCost = acquireOpts.requestCost ?? 1;
+    const tokenCost = acquireOpts.tokenCost ?? 0;
+    const abortSignal = acquireOpts.signal;
+    bumpPending(1);
+    try {
+      while (true) {
+        if (abortSignal?.aborted) throw makeAbortError("AdaptiveRateLimiter.acquire aborted");
+        const now = monotonicNs2();
+        if (throttleUntilNs > now) {
+          const waitMs = Math.ceil((throttleUntilNs - now) / 1e6);
+          await sleepReactive(waitMs, abortSignal);
+          continue;
+        }
+        if (requestCost > 0 && rpmHardStop || tokenCost > 0 && tpmHardStop) {
+          await sleepReactive(250, abortSignal);
+          continue;
+        }
+        const rpmAtAcquire = rpmBucket;
+        const tpmAtAcquire = tpmBucket;
+        const gotRpm = rpmAtAcquire.tryConsume(requestCost);
+        if (!gotRpm) {
+          await sleepReactive(estimateWaitMs(rpmAtAcquire, requestCost), abortSignal);
+          continue;
+        }
+        const gotTpm = tokenCost > 0 ? tpmAtAcquire.tryConsume(tokenCost) : true;
+        if (!gotTpm) {
+          rpmAtAcquire.putBack(requestCost);
+          await sleepReactive(estimateWaitMs(tpmAtAcquire, tokenCost), abortSignal);
+          continue;
+        }
+        refreshAvailable();
+        return;
+      }
+    } finally {
+      bumpPending(-1);
+    }
+  }
+  function recordUsage(delta) {
+    if (delta > 0) {
+      tpmBucket.tryConsume(delta);
+    } else if (delta < 0) {
+      tpmBucket.putBack(-delta);
+    }
+    refreshAvailable();
+  }
+  function dispose() {
+    unsubRpm();
+    unsubTpm();
+    unsubAdapt?.();
+    rpmDecayTimer.cancel();
+    tpmDecayTimer.cancel();
+  }
+  return {
+    effectiveRpm,
+    effectiveTpm,
+    lastSignal,
+    pending,
+    rpmAvailable: rpmAvailableNode,
+    tpmAvailable: tpmAvailableNode,
+    acquire,
+    recordUsage,
+    recordSignal: applySignal,
+    dispose
+  };
+}
+function makeBucket(perMinute, burst) {
+  if (!Number.isFinite(perMinute) || perMinute === Infinity) {
+    return tokenBucket(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+  }
+  const capacity = Math.max(1, perMinute * burst);
+  const refillPerSecond = perMinute / 60;
+  return tokenBucket(capacity, refillPerSecond);
+}
+function estimateWaitMs(bucket, needed) {
+  const have = bucket.available();
+  const deficit = Math.max(0, needed - have);
+  if (deficit <= 0) return 25;
+  return Math.min(5e3, Math.max(50, deficit * 100));
+}
+function sleepReactive(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  if (signal?.aborted) return Promise.reject(makeAbortError("AdaptiveRateLimiter.acquire aborted"));
+  return new Promise((resolve, reject) => {
+    const timer = new ResettableTimer();
+    let onAbort;
+    const cleanup = () => {
+      timer.cancel();
+      if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+    };
+    timer.start(ms, () => {
+      cleanup();
+      resolve();
+    });
+    if (signal) {
+      onAbort = () => {
+        cleanup();
+        reject(makeAbortError("AdaptiveRateLimiter.acquire aborted"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+
+// src/utils/resilience/rate-limiter.ts
+function tokenBucket(capacity, refillPerSecond, opts) {
+  if (capacity <= 0) throw new RangeError("capacity must be > 0");
+  if (refillPerSecond < 0) throw new RangeError("refillPerSecond must be >= 0");
+  const clock = opts?.clock ?? monotonicNs3;
+  let tokens = capacity;
+  let updatedAt = clock();
+  function refill(now) {
+    if (refillPerSecond > 0) {
+      const elapsedNs = now - updatedAt;
+      tokens = Math.min(capacity, tokens + elapsedNs / NS_PER_SEC * refillPerSecond);
+    }
+    updatedAt = now;
+  }
+  return {
+    available() {
+      refill(clock());
+      return tokens;
+    },
+    tryConsume(cost = 1) {
+      if (cost <= 0) return true;
+      const now = clock();
+      refill(now);
+      if (tokens >= cost) {
+        tokens -= cost;
+        return true;
+      }
+      return false;
+    },
+    putBack(cost = 1) {
+      if (cost <= 0) return;
+      refill(clock());
+      tokens = Math.min(capacity, tokens + cost);
+    }
+  };
+}
+var RateLimiterOverflowError = class extends Error {
+  name = "RateLimiterOverflowError";
+  constructor(maxBuffer) {
+    super(`rateLimiter buffer overflow (maxBuffer=${maxBuffer})`);
+  }
+};
+function rateLimiterStateEqual(a, b) {
+  return a.status === b.status && a.droppedCount === b.droppedCount && a.pendingCount === b.pendingCount && a.paused === b.paused;
+}
+var RATE_LIMITER_INITIAL_STATE = Object.freeze({
+  status: "open",
+  droppedCount: 0,
+  pendingCount: 0,
+  paused: false
+});
+function rateLimiter(source, opts) {
+  const isReactive = isNode(opts);
+  if (!isReactive) {
+    const o = opts;
+    if (o.maxEvents <= 0) throw new RangeError("maxEvents must be > 0");
+    if (o.windowNs <= 0) throw new RangeError("windowNs must be > 0");
+    if (o.maxBuffer === void 0) {
+      throw new RangeError(
+        "rateLimiter requires explicit maxBuffer (use Infinity to opt in to unbounded)"
+      );
+    }
+    const isUnbounded0 = o.maxBuffer === Infinity;
+    if (!isUnbounded0 && (!Number.isInteger(o.maxBuffer) || o.maxBuffer < 1)) {
+      throw new RangeError("maxBuffer must be a positive integer (or Infinity for unbounded)");
+    }
+  }
+  const initialOpts = isReactive ? opts.cache : opts;
+  const initialMaxBuffer = initialOpts?.maxBuffer;
+  const isUnbounded = initialMaxBuffer === Infinity;
+  const out = node5(
+    (_data, a) => {
+      let maxEvents = initialOpts?.maxEvents ?? 1;
+      let windowNs = initialOpts?.windowNs ?? NS_PER_SEC;
+      let maxBuffer = initialMaxBuffer ?? 1;
+      let onOverflow = initialOpts?.onOverflow ?? "drop-newest";
+      let refillPerSec = maxEvents * NS_PER_SEC / windowNs;
+      let tokenTimeNs = NS_PER_SEC / refillPerSec;
+      let bucket = tokenBucket(maxEvents, refillPerSec);
+      const pending = isUnbounded ? makeArrayQueue() : ringBufferQueue(Math.max(1, maxBuffer));
+      const timer = new ResettableTimer2();
+      let terminated = false;
+      let dropped = 0;
+      const droppedNode = out.meta.droppedCount;
+      const stateNode = out.meta.rateLimitState;
+      let lastState = RATE_LIMITER_INITIAL_STATE;
+      function syncState() {
+        droppedNode.emit(dropped);
+        const isPaused = pending.size > 0;
+        const next = {
+          status: isPaused ? "throttled" : "open",
+          droppedCount: dropped,
+          pendingCount: pending.size,
+          paused: isPaused
+        };
+        if (!rateLimiterStateEqual(lastState, next)) {
+          lastState = next;
+          stateNode.emit(next);
+        }
+      }
+      lastState = RATE_LIMITER_INITIAL_STATE;
+      droppedNode.emit(0);
+      stateNode.emit(RATE_LIMITER_INITIAL_STATE);
+      const optMirror = resolveReactiveOption(
+        opts,
+        (next) => {
+          if (terminated) return;
+          if (next == null) return;
+          if (typeof next === "object" && Object.keys(next).length === 0) return;
+          if (!(next.maxEvents > 0) || !(next.windowNs > 0)) return;
+          const nextBuf = next.maxBuffer;
+          if (nextBuf === void 0) return;
+          const nextUnbounded = nextBuf === Infinity;
+          if (nextUnbounded !== isUnbounded) {
+            return;
+          }
+          if (!nextUnbounded && (!Number.isInteger(nextBuf) || nextBuf < 1)) return;
+          if (!nextUnbounded && nextBuf > maxBuffer) {
+            console.warn(
+              `rateLimiter: reactive maxBuffer grow (${maxBuffer} \u2192 ${nextBuf}) rejected. The pending ring buffer is allocated at construction; reactive maxBuffer is monotonically non-increasing. Recreate the rateLimiter with the larger cap if growth is required.`
+            );
+            return;
+          }
+          maxEvents = next.maxEvents;
+          windowNs = next.windowNs;
+          maxBuffer = nextBuf;
+          onOverflow = next.onOverflow ?? "drop-newest";
+          refillPerSec = maxEvents * NS_PER_SEC / windowNs;
+          tokenTimeNs = NS_PER_SEC / refillPerSec;
+          bucket = tokenBucket(maxEvents, refillPerSec);
+          if (!nextUnbounded) {
+            while (pending.size > maxBuffer) {
+              pending.shift();
+              dropped += 1;
+            }
+          }
+          syncState();
+        }
+      );
+      function tryEmit() {
+        while (pending.size > 0) {
+          if (bucket.tryConsume(1)) {
+            a.emit(pending.shift());
+            syncState();
+          } else {
+            timer.start(Math.max(1, tokenTimeNs / NS_PER_MS), tryEmit);
+            return;
+          }
+        }
+      }
+      function recordDrop() {
+        dropped += 1;
+        syncState();
+      }
+      function resetForTerminal() {
+        terminated = true;
+        timer.cancel();
+        while (pending.size > 0) pending.shift();
+        dropped = 0;
+      }
+      const unsub = source.subscribe((msgs) => {
+        for (const m of msgs) {
+          if (terminated) return;
+          const t = m[0];
+          if (t === DIRTY4) a.down([[DIRTY4]]);
+          else if (t === DATA5) {
+            if (!isUnbounded && pending.size >= maxBuffer) {
+              if (onOverflow === "drop-newest") {
+                recordDrop();
+              } else if (onOverflow === "drop-oldest") {
+                pending.shift();
+                pending.push(m[1]);
+                recordDrop();
+              } else {
+                recordDrop();
+                resetForTerminal();
+                a.down([[ERROR4, new RateLimiterOverflowError(maxBuffer)]]);
+                return;
+              }
+            } else {
+              pending.push(m[1]);
+              syncState();
+            }
+            tryEmit();
+          } else if (t === RESOLVED4) a.down([[RESOLVED4]]);
+          else if (t === COMPLETE4) {
+            resetForTerminal();
+            a.down([[COMPLETE4]]);
+          } else if (t === ERROR4) {
+            resetForTerminal();
+            a.down([m]);
+          } else if (t === TEARDOWN2) {
+            resetForTerminal();
+            a.down([m]);
+            return;
+          } else a.down([m]);
+        }
+      });
+      return () => {
+        terminated = true;
+        timer.cancel();
+        unsub();
+        optMirror.unsub();
+      };
+    },
+    {
+      ...operatorOpts(),
+      initial: source.cache,
+      meta: {
+        // Caller-supplied meta first; companion seeds + factoryTag
+        // override below so they always win.
+        ...isReactive ? {} : opts.meta ?? {},
+        droppedCount: 0,
+        rateLimitState: RATE_LIMITER_INITIAL_STATE,
+        ...factoryTag3("rateLimiter", isReactive ? { reactiveOpts: true } : opts)
+      }
+    }
+  );
+  return {
+    node: out,
+    droppedCount: out.meta.droppedCount,
+    rateLimitState: out.meta.rateLimitState
+  };
+}
+function ringBufferQueue(capacity) {
+  const buf = new RingBuffer(capacity);
+  return {
+    push: (v) => buf.push(v),
+    shift: () => buf.shift(),
+    get size() {
+      return buf.size;
+    }
+  };
+}
+function makeArrayQueue() {
+  const arr = [];
+  return {
+    push: (v) => {
+      arr.push(v);
+    },
+    shift: () => arr.shift(),
+    get size() {
+      return arr.length;
+    }
+  };
+}
+
+export {
+  CircuitOpenError,
+  circuitBreaker,
+  withBreaker,
+  budgetGate,
+  fallback,
+  adaptiveRateLimiter,
+  tokenBucket,
+  RateLimiterOverflowError,
+  rateLimiter
+};
+//# sourceMappingURL=chunk-RJOG4IJU.js.map