@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-JVHGMURQ.js

@@ -0,0 +1,1106 @@
+import {
+  logDebug
+} from "./chunk-ETAD4NKD.js";
+import {
+  ProviderRegistry,
+  registerProviderRegistryReloadInvalidator
+} from "./chunk-QJ6OEH4K.js";
+import {
+  resolveBuildRoot
+} from "./chunk-CHA2HDE5.js";
+
+// src/core/safety/circuit-breaker.ts
+var CircuitState = /* @__PURE__ */ ((CircuitState2) => {
+  CircuitState2["CLOSED"] = "closed";
+  CircuitState2["OPEN"] = "open";
+  CircuitState2["HALF_OPEN"] = "half_open";
+  return CircuitState2;
+})(CircuitState || {});
+var CircuitBreaker = class {
+  options;
+  state = "closed" /* CLOSED */;
+  failures = [];
+  // Timestamp array
+  successes = [];
+  // Timestamp array
+  /** HALF_OPEN probes admitted but not yet resolved; bounded by halfOpenMaxCalls. */
+  halfOpenCallsInFlight = 0;
+  /** Probe slots still awaiting an outcome. Cleared on every state transition. */
+  liveProbes = /* @__PURE__ */ new Set();
+  nextProbeId = 0;
+  /**
+   * When the circuit last entered OPEN. Recovery is measured from this instant,
+   * not from the newest failure timestamp, so the failure window (which is
+   * pruned by cleanupOldData) cannot cap a longer recoveryTimeout.
+   */
+  openedAt;
+  rejectedCalls = 0;
+  totalResponseTime = 0;
+  totalSuccessfulCalls = 0;
+  constructor(options = {}) {
+    const recoveryTimeout = options.timeout ?? options.recoveryTimeout ?? 3e4;
+    const failureWindow = options.windowMs ?? options.failureWindow ?? 6e4;
+    if (options.halfOpenMaxCalls !== void 0 && options.halfOpenMaxCalls < 1) {
+      throw new Error(
+        `halfOpenMaxCalls must be >= 1 (got ${options.halfOpenMaxCalls}); a value of 0 makes HALF_OPEN state non-functional`
+      );
+    }
+    this.options = {
+      failureThreshold: options.failureThreshold ?? 5,
+      errorThreshold: options.errorThreshold,
+      minRequests: options.minRequests ?? 5,
+      failureWindow,
+      windowMs: failureWindow,
+      recoveryTimeout,
+      timeout: recoveryTimeout,
+      halfOpenMaxCalls: options.halfOpenMaxCalls ?? 1,
+      baseDelay: options.baseDelay ?? 1e3,
+      maxDelay: options.maxDelay ?? 3e4,
+      // 30 seconds
+      isFailure: options.isFailure
+    };
+  }
+  /**
+   * Execute a function through the circuit breaker
+   * @returns Promise that resolves with the function result or rejects with CircuitBreakerError
+   */
+  async execute(fn) {
+    const now = Date.now();
+    this.cleanupOldData(now);
+    if (this.state === "open" /* OPEN */) {
+      if (this.canAttemptRecovery(now)) {
+        this.enterHalfOpen();
+      } else {
+        this.rejectedCalls++;
+        const waitTime = Math.max(0, this.options.recoveryTimeout - (now - (this.openedAt ?? now)));
+        throw new CircuitBreakerError("Circuit breaker is OPEN. Rejected call.", {
+          state: this.state,
+          waitTime,
+          metrics: this.getMetrics()
+        });
+      }
+    }
+    let admission;
+    if (this.state === "half_open" /* HALF_OPEN */) {
+      if (this.halfOpenCallsInFlight >= this.options.halfOpenMaxCalls) {
+        this.rejectedCalls++;
+        throw new CircuitBreakerError("Circuit breaker is HALF_OPEN and test limit reached.", {
+          state: this.state,
+          waitTime: this.options.recoveryTimeout,
+          metrics: this.getMetrics()
+        });
+      }
+      admission = this.reserveProbe();
+    }
+    const startTime = Date.now();
+    try {
+      const result = await fn();
+      const responseTime = Date.now() - startTime;
+      this.recordSuccessInternal(responseTime);
+      if (this.releaseProbe(admission) && this.state === "half_open" /* HALF_OPEN */) {
+        this.closeCircuit();
+      }
+      return result;
+    } catch (error) {
+      if (this.options.isFailure && !this.options.isFailure(error)) {
+        this.releaseProbe(admission);
+        throw error;
+      }
+      const responseTime = Date.now() - startTime;
+      this.recordFailureInternal(responseTime);
+      if (this.releaseProbe(admission) && this.state === "half_open" /* HALF_OPEN */) {
+        this.openCircuit();
+      } else if (this.state === "closed" /* CLOSED */ && this.shouldOpenCircuit()) {
+        this.openCircuit();
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get current circuit breaker metrics
+   */
+  getMetrics() {
+    const latestFailure = this.failures.at(-1);
+    return {
+      state: this.state,
+      failureCount: this.failures.length,
+      successCount: this.successes.length,
+      lastFailureTime: latestFailure,
+      rejectedCalls: this.rejectedCalls,
+      averageResponseTime: this.totalSuccessfulCalls > 0 ? Math.round(this.totalResponseTime / this.totalSuccessfulCalls) : 0,
+      nextRecoveryAttempt: this.openedAt !== void 0 ? this.openedAt + this.options.recoveryTimeout : void 0
+    };
+  }
+  /**
+   * Force the circuit breaker to OPEN state (for testing)
+   */
+  forceOpen() {
+    this.openCircuit();
+  }
+  /**
+   * Reset the circuit breaker to CLOSED state (for testing)
+   */
+  reset() {
+    this.state = "closed" /* CLOSED */;
+    this.failures = [];
+    this.successes = [];
+    this.halfOpenCallsInFlight = 0;
+    this.liveProbes.clear();
+    this.openedAt = void 0;
+    this.rejectedCalls = 0;
+    this.totalResponseTime = 0;
+    this.totalSuccessfulCalls = 0;
+  }
+  /**
+   * Calculate exponential backoff delay
+   */
+  getBackoffDelay() {
+    const failureCount = Math.min(this.failures.length, 10);
+    const delay = this.options.baseDelay * 2 ** Math.max(0, failureCount - 1);
+    return Math.min(delay, this.options.maxDelay);
+  }
+  /**
+   * Inspect whether an admission would currently succeed (manual usage pattern).
+   *
+   * Read-only with respect to admission: it never transitions OPEN → HALF_OPEN
+   * and never consumes a probe slot, so it can be called any number of times
+   * (for example a coarse pre-check before deciding what to admit). It still
+   * prunes the statistics window, which is bookkeeping rather than admission
+   * state.
+   *
+   * @returns true if the circuit would admit a request right now
+   */
+  isRequestAllowed() {
+    const now = Date.now();
+    this.cleanupOldData(now);
+    if (this.state === "closed" /* CLOSED */) {
+      return true;
+    }
+    if (this.state === "open" /* OPEN */) {
+      return this.canAttemptRecovery(now);
+    }
+    return this.halfOpenCallsInFlight < this.options.halfOpenMaxCalls;
+  }
+  /**
+   * Check if a request can be made (for manual usage pattern).
+   *
+   * Inspection alias for {@link isRequestAllowed}; it does not reserve anything.
+   * Callers that are about to make a real call must use {@link tryAdmit}.
+   *
+   * @returns true if circuit allows request, false if circuit is OPEN
+   */
+  canMakeRequest() {
+    return this.isRequestAllowed();
+  }
+  /**
+   * Admit one real request (manual usage pattern).
+   *
+   * Performs the OPEN → HALF_OPEN transition once the recovery timeout has
+   * elapsed and reserves one probe slot bounded by `halfOpenMaxCalls`, so
+   * concurrent recovery probes cannot exceed that bound. Pair the returned
+   * handle with exactly one `recordSuccess`/`recordFailure` call.
+   *
+   * @returns an admission handle, or null when the circuit refuses the request
+   */
+  tryAdmit() {
+    const now = Date.now();
+    this.cleanupOldData(now);
+    if (this.state === "closed" /* CLOSED */) {
+      return { state: "closed" /* CLOSED */ };
+    }
+    if (this.state === "open" /* OPEN */) {
+      if (!this.canAttemptRecovery(now)) return null;
+      this.enterHalfOpen();
+    }
+    if (this.halfOpenCallsInFlight >= this.options.halfOpenMaxCalls) {
+      return null;
+    }
+    return this.reserveProbe();
+  }
+  /**
+   * Record a successful request (for manual usage pattern).
+   *
+   * @param admission - handle from {@link tryAdmit}. A success for an admitted
+   *   HALF_OPEN probe closes the circuit; a success without a handle, or from a
+   *   request admitted before the circuit opened, only updates statistics.
+   */
+  recordSuccess(admission) {
+    const now = Date.now();
+    this.cleanupOldData(now);
+    this.successes.push(now);
+    this.totalSuccessfulCalls++;
+    if (this.releaseProbe(admission) && this.state === "half_open" /* HALF_OPEN */) {
+      this.closeCircuit();
+    }
+  }
+  /**
+   * Record a failed request (for manual usage pattern).
+   *
+   * @param admission - handle from {@link tryAdmit}. A failure for an admitted
+   *   HALF_OPEN probe reopens the circuit and restarts the recovery clock; a
+   *   failure without a handle only updates statistics, which can still trip a
+   *   CLOSED circuit through the configured threshold.
+   */
+  recordFailure(admission) {
+    const now = Date.now();
+    this.cleanupOldData(now);
+    this.failures.push(now);
+    if (this.releaseProbe(admission) && this.state === "half_open" /* HALF_OPEN */) {
+      this.openCircuit();
+    } else if (this.state === "closed" /* CLOSED */ && this.shouldOpenCircuit()) {
+      this.openCircuit();
+    }
+  }
+  canAttemptRecovery(now) {
+    if (this.openedAt === void 0) return true;
+    return now - this.openedAt >= this.options.recoveryTimeout;
+  }
+  /** Enter OPEN and start the recovery clock from now. */
+  openCircuit() {
+    this.state = "open" /* OPEN */;
+    this.openedAt = Date.now();
+    this.halfOpenCallsInFlight = 0;
+    this.liveProbes.clear();
+  }
+  /** Enter HALF_OPEN with a fresh set of probe slots. */
+  enterHalfOpen() {
+    this.state = "half_open" /* HALF_OPEN */;
+    this.halfOpenCallsInFlight = 0;
+    this.liveProbes.clear();
+  }
+  /** Enter CLOSED, clearing the failure history that tripped the circuit. */
+  closeCircuit() {
+    this.state = "closed" /* CLOSED */;
+    this.failures = [];
+    this.halfOpenCallsInFlight = 0;
+    this.liveProbes.clear();
+    this.openedAt = void 0;
+  }
+  /** Reserve one HALF_OPEN probe slot. */
+  reserveProbe() {
+    this.halfOpenCallsInFlight++;
+    const probeId = ++this.nextProbeId;
+    this.liveProbes.add(probeId);
+    return { state: "half_open" /* HALF_OPEN */, probeId };
+  }
+  /**
+   * Release the probe slot held by an admission.
+   *
+   * @returns true when the admission was a probe still awaiting its outcome, so
+   *   only that outcome may drive a HALF_OPEN transition. Stale handles (their
+   *   generation of probes ended when the circuit last changed state) and
+   *   handle-less outcomes return false.
+   */
+  releaseProbe(admission) {
+    const probeId = admission?.probeId;
+    if (probeId === void 0 || !this.liveProbes.delete(probeId)) return false;
+    this.halfOpenCallsInFlight = Math.max(0, this.halfOpenCallsInFlight - 1);
+    return true;
+  }
+  shouldOpenCircuit() {
+    if (this.options.errorThreshold !== void 0) {
+      const total = this.failures.length + this.successes.length;
+      if (total < this.options.minRequests) {
+        return false;
+      }
+      const errorRate = this.failures.length / total;
+      return errorRate > this.options.errorThreshold;
+    }
+    return this.failures.length >= this.options.failureThreshold;
+  }
+  recordFailureInternal(_responseTime) {
+    const now = Date.now();
+    this.failures.push(now);
+  }
+  recordSuccessInternal(responseTime) {
+    const now = Date.now();
+    this.successes.push(now);
+    this.totalSuccessfulCalls++;
+    this.totalResponseTime += responseTime;
+    if (this.state === "half_open" /* HALF_OPEN */) {
+      this.failures = [];
+    }
+  }
+  /**
+   * Prune the sliding statistics window used by the trip decision.
+   *
+   * This deliberately does not touch `openedAt`: recovery timing is independent
+   * of the failure window, so a `recoveryTimeout` longer than `failureWindow` is
+   * honored instead of being capped at the moment the last failure ages out.
+   */
+  cleanupOldData(now) {
+    const cutoff = now - this.options.failureWindow;
+    this.failures = this.failures.filter((timestamp) => timestamp > cutoff);
+    this.successes = this.successes.filter((timestamp) => timestamp > cutoff);
+  }
+};
+var CircuitBreakerError = class extends Error {
+  state;
+  waitTime;
+  metrics;
+  constructor(message, options) {
+    super(message);
+    this.name = "CircuitBreakerError";
+    this.state = options.state;
+    this.waitTime = options.waitTime;
+    this.metrics = options.metrics;
+  }
+};
+function createCircuitBreakerOptions(options) {
+  return {
+    failureThreshold: options.failureThreshold ?? 5,
+    errorThreshold: options.errorThreshold,
+    minRequests: options.minRequests ?? 5,
+    failureWindow: options.failureWindow ?? options.windowMs ?? 6e4,
+    windowMs: options.windowMs ?? options.failureWindow ?? 6e4,
+    recoveryTimeout: options.recoveryTimeout ?? options.timeout ?? 3e4,
+    timeout: options.timeout ?? options.recoveryTimeout ?? 3e4,
+    halfOpenMaxCalls: options.halfOpenMaxCalls ?? 1,
+    baseDelay: options.baseDelay ?? 1e3,
+    maxDelay: options.maxDelay ?? 3e4
+  };
+}
+
+// src/core/safety/circuit-breaker-registry.ts
+var CircuitBreakerRegistry = class {
+  breakers = /* @__PURE__ */ new Map();
+  defaultOptions;
+  /**
+   * Creates a new circuit breaker registry
+   * @param defaultOptions - Default options to apply to all circuit breakers
+   */
+  constructor(defaultOptions = {}) {
+    this.defaultOptions = defaultOptions;
+  }
+  /**
+   * Gets or creates a circuit breaker for the specified provider.
+   * @param provider - The provider name (e.g., 'gemini', 'claude')
+   * @param options - Optional circuit breaker configuration (merged with defaults)
+   * @returns The circuit breaker instance for this provider
+   */
+  getBreaker(provider, options = {}) {
+    let breaker = this.breakers.get(provider);
+    if (!breaker) {
+      const mergedOptions = {
+        failureThreshold: 5,
+        recoveryTimeout: 3e4,
+        ...this.defaultOptions,
+        ...options
+      };
+      breaker = new CircuitBreaker(mergedOptions);
+      this.breakers.set(provider, breaker);
+    }
+    return breaker;
+  }
+  /**
+   * Resets the circuit breaker for a specific provider.
+   * @param provider - The provider name
+   */
+  resetBreaker(provider) {
+    const breaker = this.breakers.get(provider);
+    if (breaker) {
+      breaker.reset();
+    }
+  }
+  /**
+   * Removes the circuit breaker for a specific provider.
+   * This completely removes the breaker from the registry.
+   * @param provider - The provider name
+   */
+  removeBreaker(provider) {
+    this.breakers.delete(provider);
+  }
+  /**
+   * Resets all circuit breakers in the registry.
+   */
+  resetAllBreakers() {
+    for (const breaker of this.breakers.values()) {
+      breaker.reset();
+    }
+  }
+  /**
+   * Removes all circuit breakers from the registry.
+   */
+  clear() {
+    this.breakers.clear();
+  }
+  /**
+   * Gets all circuit breakers in the registry.
+   * @returns Map of provider names to circuit breakers
+   */
+  getAllBreakers() {
+    return this.breakers;
+  }
+  /**
+   * Checks if a circuit breaker exists for the specified provider.
+   * @param provider - The provider name
+   * @returns true if a breaker exists, false otherwise
+   */
+  hasBreaker(provider) {
+    return this.breakers.has(provider);
+  }
+  /**
+   * Gets the number of registered circuit breakers.
+   * @returns The count of circuit breakers
+   */
+  get size() {
+    return this.breakers.size;
+  }
+};
+
+// src/core/safety/file-token-bucket.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { setTimeout as timersSetTimeout } from "timers/promises";
+var DEFAULT_STATE_DIR = path.join(process.cwd(), ".build-project", "rate-limits");
+var DEFAULT_STALE_LOCK_THRESHOLD_MS = 6e4;
+var DEFAULT_MAX_WAIT_MS = 3e4;
+var LOCK_RETRY_INTERVAL_MS = 50;
+var FileTokenBucket = class {
+  key;
+  bucketSize;
+  refillRate;
+  initialTokens;
+  stateDir;
+  staleLockThresholdMs;
+  maxWaitMs;
+  // In-memory fallback for sync operations (tryAcquire)
+  inMemoryTokens;
+  inMemoryLastRefill;
+  inMemoryTotalWaitMs = 0;
+  inMemoryTotalRequests = 0;
+  constructor(key, options) {
+    this.key = key.replace(/[^a-zA-Z0-9_.-]/g, "_").replace(/\.{2,}/g, "_");
+    this.bucketSize = options.bucketSize;
+    this.refillRate = options.refillRate;
+    this.initialTokens = options.initialTokens ?? options.bucketSize;
+    this.stateDir = options.stateDir ?? DEFAULT_STATE_DIR;
+    this.staleLockThresholdMs = options.staleLockThresholdMs ?? DEFAULT_STALE_LOCK_THRESHOLD_MS;
+    this.maxWaitMs = options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS;
+    this.inMemoryTokens = this.initialTokens;
+    this.inMemoryLastRefill = Date.now();
+  }
+  get statePath() {
+    return path.join(this.stateDir, `${this.key}.json`);
+  }
+  get lockPath() {
+    return path.join(this.stateDir, `${this.key}.lock`);
+  }
+  /**
+   * Acquire tokens from the cross-process bucket (async - waits if insufficient).
+   */
+  async acquire(tokens = 1) {
+    await this.ensureStateDir();
+    const deadline = Date.now() + this.maxWaitMs;
+    while (Date.now() < deadline) {
+      const acquired = await this.tryAcquireFromFile(tokens);
+      if (acquired.success) {
+        return;
+      }
+      const waitMs = Math.min(acquired.waitMs ?? 500, deadline - Date.now());
+      if (waitMs <= 0) break;
+      await timersSetTimeout(waitMs);
+    }
+    throw new Error(
+      `FileTokenBucket(${this.key}): timed out waiting for ${tokens} token(s) after ${this.maxWaitMs}ms`
+    );
+  }
+  /**
+   * Try to acquire tokens without waiting (non-blocking).
+   * Falls back to in-memory bucket for synchronous operation.
+   */
+  tryAcquire(tokens = 1) {
+    this.inMemoryTotalRequests += 1;
+    this.refillInMemory();
+    if (this.inMemoryTokens >= tokens) {
+      this.inMemoryTokens -= tokens;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get current metrics (in-memory snapshot).
+   */
+  getMetrics() {
+    this.refillInMemory();
+    return {
+      availableTokens: this.inMemoryTokens,
+      bucketSize: this.bucketSize,
+      refillRate: this.refillRate,
+      lastRefillTime: this.inMemoryLastRefill,
+      totalWaitTimeMs: this.inMemoryTotalWaitMs,
+      totalRequests: this.inMemoryTotalRequests
+    };
+  }
+  /**
+   * Reset both in-memory and file-based state.
+   * WARNING: Not safe to call during concurrent acquire/release operations.
+   * Only use when no other callers are active (e.g., between test runs).
+   */
+  reset() {
+    this.inMemoryTokens = this.initialTokens;
+    this.inMemoryLastRefill = Date.now();
+    this.inMemoryTotalWaitMs = 0;
+    this.inMemoryTotalRequests = 0;
+    fs.unlink(this.statePath).catch(() => {
+    });
+    fs.unlink(this.lockPath).catch(() => {
+    });
+  }
+  // --- Internal file-based operations ---
+  async ensureStateDir() {
+    await fs.mkdir(this.stateDir, { recursive: true });
+  }
+  async tryAcquireFromFile(tokens) {
+    let lockHandle;
+    try {
+      lockHandle = await this.acquireLock();
+      if (!lockHandle) {
+        return { success: false, waitMs: LOCK_RETRY_INTERVAL_MS };
+      }
+      const state = await this.readState();
+      this.refillState(state);
+      state.totalRequests += 1;
+      if (state.availableTokens >= tokens) {
+        state.availableTokens -= tokens;
+        await this.writeState(state);
+        this.inMemoryTokens = state.availableTokens;
+        this.inMemoryLastRefill = state.lastRefillTime;
+        this.inMemoryTotalRequests = state.totalRequests;
+        this.inMemoryTotalWaitMs = state.totalWaitTimeMs;
+        return { success: true };
+      }
+      const tokensNeeded = tokens - state.availableTokens;
+      const waitMs = Math.ceil(tokensNeeded / this.refillRate * 1e3);
+      state.totalWaitTimeMs += waitMs;
+      await this.writeState(state);
+      return { success: false, waitMs };
+    } finally {
+      await this.releaseLock(lockHandle);
+    }
+  }
+  async acquireLock() {
+    try {
+      const lockStat = await fs.stat(this.lockPath);
+      if (Date.now() - lockStat.mtimeMs > this.staleLockThresholdMs) {
+        await fs.unlink(this.lockPath).catch(() => {
+        });
+      }
+    } catch {
+    }
+    try {
+      const handle = await fs.open(this.lockPath, "wx");
+      await handle.write(`${process.pid}
+`);
+      return handle;
+    } catch {
+      return void 0;
+    }
+  }
+  async releaseLock(handle) {
+    if (handle) {
+      await handle.close().catch(() => {
+      });
+      await fs.unlink(this.lockPath).catch(() => {
+      });
+    }
+  }
+  async readState() {
+    try {
+      const content = await fs.readFile(this.statePath, "utf-8");
+      const parsed = JSON.parse(content);
+      if (typeof parsed.availableTokens === "number" && typeof parsed.lastRefillTime === "number") {
+        return parsed;
+      }
+    } catch {
+    }
+    return {
+      availableTokens: this.initialTokens,
+      lastRefillTime: Date.now(),
+      totalWaitTimeMs: 0,
+      totalRequests: 0
+    };
+  }
+  async writeState(state) {
+    const content = JSON.stringify(state);
+    const fd = await fs.open(this.statePath, "w");
+    try {
+      await fd.write(content);
+      await fd.datasync();
+    } finally {
+      await fd.close();
+    }
+  }
+  refillState(state) {
+    const now = Date.now();
+    const elapsedMs = now - state.lastRefillTime;
+    const elapsedSeconds = elapsedMs / 1e3;
+    const tokensToAdd = elapsedSeconds * this.refillRate;
+    if (tokensToAdd > 0) {
+      state.availableTokens = Math.min(this.bucketSize, state.availableTokens + tokensToAdd);
+      state.lastRefillTime = now;
+    }
+  }
+  refillInMemory() {
+    const now = Date.now();
+    const elapsedMs = now - this.inMemoryLastRefill;
+    const elapsedSeconds = elapsedMs / 1e3;
+    const tokensToAdd = elapsedSeconds * this.refillRate;
+    if (tokensToAdd > 0) {
+      this.inMemoryTokens = Math.min(this.bucketSize, this.inMemoryTokens + tokensToAdd);
+      this.inMemoryLastRefill = now;
+    }
+  }
+};
+
+// src/core/safety/rate-limiter-factory.ts
+import * as fsSync from "fs";
+import path2 from "path";
+
+// src/core/safety/token-bucket.ts
+var TokenBucket = class {
+  options;
+  availableTokens;
+  lastRefillTime;
+  totalWaitTimeMs = 0;
+  totalRequests = 0;
+  _queue = Promise.resolve();
+  queuedAcquires = 0;
+  generation = 0;
+  constructor(options) {
+    this.options = {
+      bucketSize: options.bucketSize,
+      refillRate: options.refillRate,
+      initialTokens: options.initialTokens ?? options.bucketSize
+    };
+    this.availableTokens = this.options.initialTokens;
+    this.lastRefillTime = Date.now();
+  }
+  /**
+   * Acquire tokens from the bucket (async - waits if insufficient tokens)
+   * @param tokens - Number of tokens to acquire (default: 1)
+   * @returns Promise that resolves when tokens are acquired
+   */
+  async acquire(tokens = 1) {
+    if (tokens > this.options.bucketSize) {
+      throw new Error(
+        `TokenBucket cannot acquire ${tokens} token(s); bucket size is ${this.options.bucketSize}`
+      );
+    }
+    const generationAtEnqueue = this.generation;
+    const execute = async () => {
+      if (generationAtEnqueue !== this.generation) {
+        return;
+      }
+      this.prepareAcquire();
+      if (this.availableTokens >= tokens) {
+        this.availableTokens -= tokens;
+        return;
+      }
+      const tokensNeeded = tokens - this.availableTokens;
+      if (this.options.refillRate <= 0) {
+        throw new Error(
+          `TokenBucket cannot acquire ${tokens} token(s); refill rate is zero or negative`
+        );
+      }
+      const waitTimeMs = tokensNeeded / this.options.refillRate * 1e3;
+      this.totalWaitTimeMs += waitTimeMs;
+      await this.sleep(waitTimeMs);
+      if (generationAtEnqueue !== this.generation) {
+        return;
+      }
+      this.refreshState();
+      this.availableTokens = Math.max(0, this.availableTokens - tokens);
+    };
+    this.queuedAcquires++;
+    const next = this.queuedAcquires === 1 ? execute() : this._queue.then(execute, execute);
+    this._queue = next.finally(() => {
+      if (this.queuedAcquires > 0) {
+        this.queuedAcquires--;
+      }
+    });
+    return this._queue;
+  }
+  /**
+   * Try to acquire tokens without waiting (non-blocking)
+   * @param tokens - Number of tokens to acquire (default: 1)
+   * @returns true if tokens were acquired, false if insufficient tokens
+   */
+  tryAcquire(tokens = 1) {
+    if (tokens > this.options.bucketSize) {
+      return false;
+    }
+    if (this.queuedAcquires > 0) {
+      return false;
+    }
+    this.prepareAcquire();
+    if (this.availableTokens >= tokens) {
+      this.availableTokens -= tokens;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get current token bucket metrics
+   */
+  getMetrics() {
+    this.refreshState();
+    return {
+      availableTokens: this.availableTokens,
+      bucketSize: this.options.bucketSize,
+      refillRate: this.options.refillRate,
+      lastRefillTime: this.lastRefillTime,
+      totalWaitTimeMs: this.totalWaitTimeMs,
+      totalRequests: this.totalRequests
+    };
+  }
+  /**
+   * Reset the token bucket to initial state (for testing)
+   */
+  reset() {
+    this.generation++;
+    this._queue = Promise.resolve();
+    this.queuedAcquires = 0;
+    this.availableTokens = this.options.initialTokens;
+    this.lastRefillTime = Date.now();
+    this.totalWaitTimeMs = 0;
+    this.totalRequests = 0;
+  }
+  /**
+   * Get current number of available tokens
+   */
+  getAvailableTokens() {
+    this.refreshState();
+    return this.availableTokens;
+  }
+  refreshState() {
+    const now = Date.now();
+    this.refillTokens(now);
+  }
+  prepareAcquire() {
+    this.totalRequests++;
+    this.refreshState();
+  }
+  refillTokens(now) {
+    const elapsedMs = now - this.lastRefillTime;
+    const elapsedSeconds = elapsedMs / 1e3;
+    const tokensToAdd = elapsedSeconds * this.options.refillRate;
+    if (tokensToAdd > 0) {
+      this.availableTokens = Math.min(this.options.bucketSize, this.availableTokens + tokensToAdd);
+      this.lastRefillTime = now;
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var TokenBucketError = class extends Error {
+  availableTokens;
+  requiredTokens;
+  metrics;
+  constructor(message, options) {
+    super(message);
+    this.name = "TokenBucketError";
+    this.availableTokens = options.availableTokens;
+    this.requiredTokens = options.requiredTokens;
+    this.metrics = options.metrics;
+  }
+};
+
+// src/core/safety/rate-limiter-registry.ts
+var RateLimiterRegistry = class {
+  buckets = /* @__PURE__ */ new Map();
+  defaultOptions;
+  bucketFactory;
+  /**
+   * Creates a new rate limiter registry
+   * @param defaultOptions - Default options to apply to all token buckets
+   * @param bucketFactory - Optional factory for creating buckets (defaults to in-memory TokenBucket)
+   */
+  constructor(defaultOptions = {}, bucketFactory) {
+    this.defaultOptions = defaultOptions;
+    this.bucketFactory = bucketFactory ?? ((_key, opts) => new TokenBucket(opts));
+  }
+  /**
+   * Gets or creates a token bucket for the specified provider and optional model.
+   * @param provider - The provider name (e.g., 'gemini', 'claude')
+   * @param model - Optional model name (e.g., 'gpt-4', 'claude-3-opus')
+   * @param options - Optional token bucket configuration (merged with defaults)
+   * @returns The token bucket instance for this provider/model combination
+   */
+  getBucket(provider, model, options = {}) {
+    const key = model ? `${provider}:${model}` : provider;
+    let bucket = this.buckets.get(key);
+    if (!bucket) {
+      const mergedOptions = {
+        bucketSize: 60,
+        refillRate: 1,
+        ...this.defaultOptions,
+        ...options
+      };
+      bucket = this.bucketFactory(key, mergedOptions);
+      this.buckets.set(key, bucket);
+    }
+    return bucket;
+  }
+  /**
+   * Resets the token bucket for a specific provider/model combination.
+   * @param provider - The provider name
+   * @param model - Optional model name
+   */
+  resetBucket(provider, model) {
+    const key = model ? `${provider}:${model}` : provider;
+    const bucket = this.buckets.get(key);
+    if (bucket) {
+      bucket.reset();
+    }
+  }
+  /**
+   * Removes the token bucket for a specific provider/model combination.
+   * This completely removes the bucket from the registry.
+   * @param provider - The provider name
+   * @param model - Optional model name
+   */
+  removeBucket(provider, model) {
+    const key = model ? `${provider}:${model}` : provider;
+    this.buckets.delete(key);
+  }
+  /**
+   * Resets all token buckets in the registry.
+   */
+  resetAllBuckets() {
+    for (const bucket of this.buckets.values()) {
+      bucket.reset();
+    }
+  }
+  /**
+   * Removes all token buckets from the registry.
+   */
+  clear() {
+    this.buckets.clear();
+  }
+  /**
+   * Gets all token buckets in the registry.
+   * @returns Map of provider:model keys to token buckets
+   */
+  getAllBuckets() {
+    return this.buckets;
+  }
+  /**
+   * Checks if a token bucket exists for the specified provider/model combination.
+   * @param provider - The provider name
+   * @param model - Optional model name
+   * @returns true if a bucket exists, false otherwise
+   */
+  hasBucket(provider, model) {
+    const key = model ? `${provider}:${model}` : provider;
+    return this.buckets.has(key);
+  }
+  /**
+   * Gets the number of registered token buckets.
+   * @returns The count of token buckets
+   */
+  get size() {
+    return this.buckets.size;
+  }
+};
+
+// src/core/safety/rate-limiter-factory.ts
+var DEFAULT_RATE_LIMITS = {
+  bucketSize: 10,
+  // 10 request burst
+  refillRate: 0.83
+  // ~50 RPM
+};
+function resolveRefillRate(entry) {
+  if (typeof entry?.refill_rate === "number" && Number.isFinite(entry.refill_rate)) {
+    return entry.refill_rate;
+  }
+  if (typeof entry?.rpm === "number" && Number.isFinite(entry.rpm)) {
+    return entry.rpm / 60;
+  }
+  return DEFAULT_RATE_LIMITS.refillRate;
+}
+function configToOptions(config) {
+  if (!config) {
+    return DEFAULT_RATE_LIMITS;
+  }
+  const entry = config.default || {
+    rpm: config.rpm,
+    bucket_size: config.bucket_size,
+    refill_rate: config.refill_rate
+  };
+  return {
+    bucketSize: entry.bucket_size ?? DEFAULT_RATE_LIMITS.bucketSize,
+    refillRate: resolveRefillRate(entry)
+  };
+}
+function shouldUseDistributedRateLimiting() {
+  if (process.env.BUILD_DISTRIBUTED_RATE_LIMIT === "1") {
+    return true;
+  }
+  const agents = Number.parseInt(process.env.BUILD_AGENTS ?? "1", 10);
+  return !Number.isNaN(agents) && agents > 1;
+}
+function getRateLimitStateDir() {
+  return path2.join(resolveBuildRoot(), ".build-project", "rate-limits");
+}
+function createFileBucketFactory() {
+  const stateDir = getRateLimitStateDir();
+  return (key, options) => new FileTokenBucket(key, { ...options, stateDir });
+}
+function createRateLimiterFromConfig(providerId) {
+  let config = null;
+  let defaultOptions = DEFAULT_RATE_LIMITS;
+  try {
+    const registryConfig = ProviderRegistry.load();
+    if (registryConfig.defaults?.rate_limits) {
+      defaultOptions = configToOptions(registryConfig.defaults.rate_limits);
+    }
+    const providerConfig = providerId ? registryConfig.providers[providerId] : void 0;
+    if (providerConfig?.rate_limits) {
+      defaultOptions = configToOptions(providerConfig.rate_limits);
+    }
+    config = registryConfig;
+  } catch {
+  }
+  const bucketFactory = shouldUseDistributedRateLimiting() ? createFileBucketFactory() : void 0;
+  const registry = new RateLimiterRegistry(defaultOptions, bucketFactory);
+  if (config) {
+    const registryConfig = config;
+    for (const [provider, providerConfig] of Object.entries(registryConfig.providers)) {
+      if (providerConfig.rate_limits?.models) {
+        for (const [model, modelConfig] of Object.entries(providerConfig.rate_limits.models)) {
+          registry.getBucket(provider, model, {
+            bucketSize: modelConfig.bucket_size,
+            refillRate: resolveRefillRate(modelConfig)
+          });
+        }
+      }
+    }
+  }
+  return registry;
+}
+function getRateLimitOptions(providerId, modelId) {
+  try {
+    const config = ProviderRegistry.load();
+    const providerConfig = config.providers[providerId];
+    const rateLimits = providerConfig?.rate_limits;
+    const modelConfig = modelId ? rateLimits?.models?.[modelId] : void 0;
+    if (modelConfig) {
+      return {
+        bucketSize: modelConfig.bucket_size,
+        refillRate: resolveRefillRate(modelConfig)
+      };
+    }
+    if (rateLimits) {
+      return configToOptions(rateLimits);
+    }
+    if (config.defaults?.rate_limits) {
+      return configToOptions(config.defaults.rate_limits);
+    }
+  } catch {
+  }
+  return DEFAULT_RATE_LIMITS;
+}
+var globalRegistry = null;
+function getGlobalRateLimiterRegistry() {
+  if (!globalRegistry) {
+    globalRegistry = createRateLimiterFromConfig();
+  }
+  return globalRegistry;
+}
+function clearGlobalRateLimiterRegistryCache() {
+  globalRegistry = null;
+}
+registerProviderRegistryReloadInvalidator(clearGlobalRateLimiterRegistryCache);
+function resetGlobalRateLimiterRegistry() {
+  if (globalRegistry) {
+    globalRegistry.clear();
+    globalRegistry = null;
+  }
+  if (shouldUseDistributedRateLimiting()) {
+    const stateDir = getRateLimitStateDir();
+    try {
+      if (fsSync.existsSync(stateDir)) {
+        for (const entry of fsSync.readdirSync(stateDir)) {
+          if (entry.endsWith(".json")) {
+            fsSync.rmSync(path2.join(stateDir, entry), { force: true });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+}
+
+// src/core/safety/index.ts
+async function acquireRateLimitToken(provider, model, options) {
+  const registry = getGlobalRateLimiterRegistry();
+  const isNewBucket = !registry.hasBucket(provider, model);
+  const bucket = registry.getBucket(provider, model, options ?? {});
+  if (isNewBucket && options != null && (typeof options.bucketSize === "number" || typeof options.refillRate === "number")) {
+    logDebug(
+      "rate-limiter",
+      `Created rate limit bucket provider=${provider} model=${model ?? "(default)"} bucketSize=${String(options.bucketSize)} refillRate=${String(options.refillRate)}`
+    );
+  }
+  await bucket.acquire();
+}
+var globalRegistry2;
+var scopedRegistries = /* @__PURE__ */ new Map();
+function getOrCreateGlobalRegistry() {
+  if (!globalRegistry2) {
+    globalRegistry2 = new CircuitBreakerRegistry();
+  }
+  return globalRegistry2;
+}
+function getScopedRegistry(scope) {
+  let registry = scopedRegistries.get(scope);
+  if (!registry) {
+    registry = new CircuitBreakerRegistry();
+    scopedRegistries.set(scope, registry);
+  }
+  return registry;
+}
+function clearScopedRegistry(scope) {
+  scopedRegistries.delete(scope);
+}
+async function executeWithCircuitBreaker(providerName, fn, options = {}, scope) {
+  const registry = scope ? getScopedRegistry(scope) : getOrCreateGlobalRegistry();
+  const breaker = registry.getBreaker(providerName, options);
+  return await breaker.execute(fn);
+}
+function resetAllCircuitBreakers() {
+  getOrCreateGlobalRegistry().clear();
+}
+function _getGlobalRegistry() {
+  return getOrCreateGlobalRegistry();
+}
+function _clearGlobalRegistry() {
+  getOrCreateGlobalRegistry().clear();
+}
+
+export {
+  CircuitState,
+  CircuitBreaker,
+  CircuitBreakerError,
+  createCircuitBreakerOptions,
+  CircuitBreakerRegistry,
+  FileTokenBucket,
+  TokenBucket,
+  TokenBucketError,
+  RateLimiterRegistry,
+  createRateLimiterFromConfig,
+  getRateLimitOptions,
+  getGlobalRateLimiterRegistry,
+  resetGlobalRateLimiterRegistry,
+  acquireRateLimitToken,
+  getScopedRegistry,
+  clearScopedRegistry,
+  executeWithCircuitBreaker,
+  resetAllCircuitBreakers,
+  _getGlobalRegistry,
+  _clearGlobalRegistry
+};
+//# sourceMappingURL=chunk-JVHGMURQ.js.map