@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-SF6YK3JI.js

@@ -0,0 +1,835 @@
+import {
+  getIntEnv,
+  readTimeoutEnvWithAlias
+} from "./chunk-T7E5JS6N.js";
+import {
+  signalCoordinator
+} from "./chunk-GC4CRMTS.js";
+import {
+  signalProcessGroup
+} from "./chunk-6CB3KJRY.js";
+import {
+  processIsAlive
+} from "./chunk-MT2WAIR3.js";
+import {
+  isQuietOutputRequested,
+  shouldShowLifecycleDiagnostics
+} from "./chunk-XWIZ6B5S.js";
+import {
+  emitWarning
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/safety/process-limiter.ts
+import { cpus, totalmem } from "os";
+var PROCESS_LIMITER_SIGKILL_GRACE_MS = 12e3;
+var PROCESS_LIMITER_HARD_DEADLINE_MS = 2e3;
+var OWNER_HANDLED_SIGNALS = /* @__PURE__ */ new Set([
+  "SIGINT",
+  "SIGTERM",
+  "SIGHUP"
+]);
+var ProcessLimiter = class _ProcessLimiter {
+  maxProcesses;
+  defaultTimeout;
+  trackedProcesses = /* @__PURE__ */ new Map();
+  nextProcessId = 1;
+  cleanupHandlers = [];
+  /** Stable process 'exit' handler ref for removeListener pairing. */
+  exitHandler = null;
+  lastCleanupTimestamp = 0;
+  cleanupIntervalMs = 1e3;
+  // Only cleanup every 1 second
+  reservationExpiryMs = 3e4;
+  pendingReservations = /* @__PURE__ */ new Map();
+  nextReservationId = 1;
+  signalHandlerName;
+  idleWaiters = /* @__PURE__ */ new Set();
+  // Static instances tracking for cleanup
+  static instances = [];
+  static nextInstanceNumber = 0;
+  constructor(maxProcesses2 = 20, defaultTimeoutMs = 36e5) {
+    this.maxProcesses = maxProcesses2;
+    this.defaultTimeout = defaultTimeoutMs;
+    const instanceNumber = ++_ProcessLimiter.nextInstanceNumber;
+    this.signalHandlerName = instanceNumber === 1 ? "ProcessLimiter" : `ProcessLimiter#${instanceNumber}`;
+    this.registerCleanupHandlers();
+    _ProcessLimiter.instances.push(this);
+  }
+  /**
+   * Raise the process ceiling to at least `target`. Raise-only: admission of
+   * more concurrent work is a reason to widen the runaway-spawn backstop in
+   * proportion, never to narrow it under live tracking. Returns the effective
+   * ceiling after the call.
+   */
+  raiseMaxProcesses(target) {
+    if (Number.isFinite(target) && Math.floor(target) > this.maxProcesses) {
+      this.maxProcesses = Math.floor(target);
+    }
+    return this.maxProcesses;
+  }
+  /**
+   * Check if we can spawn a new process.
+   * Returns true if under limit, false otherwise.
+   */
+  canSpawn() {
+    this.maybeCleanupDeadProcesses();
+    this.cleanupExpiredReservations();
+    return this.trackedProcesses.size + this.pendingReservations.size < this.maxProcesses;
+  }
+  /**
+   * Get current number of tracked processes.
+   */
+  getActiveCount() {
+    this.maybeCleanupDeadProcesses();
+    return this.trackedProcesses.size;
+  }
+  /** Wait until every tracked (or limiter-owned) child exits, with the grace period as a ceiling. */
+  waitForIdle(timeoutMs, abortSignal, limiterOwnedOnly = false) {
+    this.cleanupDeadProcesses();
+    const isIdle = () => (limiterOwnedOnly ? this.limiterOwnedIds() : [...this.trackedProcesses]).length === 0;
+    if (isIdle()) {
+      return Promise.resolve(true);
+    }
+    return new Promise((resolve) => {
+      let settled = false;
+      let timeout;
+      const finish = (idle) => {
+        if (settled) return;
+        settled = true;
+        if (timeout) clearTimeout(timeout);
+        this.idleWaiters.delete(onIdle);
+        abortSignal?.removeEventListener("abort", onAbort);
+        resolve(idle);
+      };
+      const onIdle = () => isIdle() && finish(true);
+      const onAbort = () => finish(false);
+      this.idleWaiters.add(onIdle);
+      timeout = setTimeout(() => finish(false), Math.max(0, timeoutMs));
+      timeout.unref?.();
+      if (abortSignal?.aborted) {
+        finish(false);
+        return;
+      }
+      abortSignal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  notifyIdleWaiters() {
+    for (const waiter of [...this.idleWaiters]) waiter();
+  }
+  limiterOwnedIds() {
+    return [...this.trackedProcesses].filter(([, t]) => !t.ownerHandlesSignalShutdown).map(([id]) => id);
+  }
+  /**
+   * Get maximum allowed processes.
+   */
+  getMaxProcesses() {
+    return this.maxProcesses;
+  }
+  /**
+   * Reserve a slot for an upcoming process spawn, eliminating the TOCTOU gap
+   * between canSpawn() and track().
+   *
+   * Lifecycle:
+   *   1. Call reserve() — receives a reservationId (or null if at capacity).
+   *   2. Spawn the process.
+   *   3. On success: call track(..., reservationId) to convert the reservation
+   *      into a tracked process.
+   *      On failure: call cancelReservation(reservationId) to release the slot.
+   *
+   * Reservations expire automatically after reservationExpiryMs (default 30s)
+   * to prevent leaked slots from blocking future spawns.
+   *
+   * @returns A reservation ID to pass to track(), or null if at capacity.
+   */
+  reserve() {
+    this.cleanupDeadProcesses();
+    this.cleanupExpiredReservations();
+    if (this.trackedProcesses.size + this.pendingReservations.size >= this.maxProcesses) {
+      return null;
+    }
+    const reservationId = this.nextReservationId++;
+    this.pendingReservations.set(reservationId, Date.now());
+    return reservationId;
+  }
+  /**
+   * Cancel a previously obtained reservation, freeing the reserved slot.
+   * No-op if the reservation ID is not found (already consumed or expired).
+   *
+   * @param reservationId - The ID returned by reserve()
+   */
+  cancelReservation(reservationId) {
+    this.pendingReservations.delete(reservationId);
+  }
+  /**
+   * Refresh the age of a still-held reservation so it survives past
+   * reservationExpiryMs. Used by long-lived holders that occupy a slot without
+   * a tracked ChildProcess (e.g. the tmux-exec transport, whose provider runs
+   * inside a detached tmux session rather than a direct child of this process).
+   *
+   * @returns true if the reservation was renewed, false if it was unknown
+   *          (already consumed, cancelled, or expired and reaped).
+   */
+  renewReservation(reservationId) {
+    if (!this.pendingReservations.has(reservationId)) {
+      return false;
+    }
+    this.pendingReservations.set(reservationId, Date.now());
+    return true;
+  }
+  /**
+   * Get the number of pending (unconsumed) reservations.
+   * Useful for monitoring and debugging.
+   */
+  getPendingReservationCount() {
+    return this.pendingReservations.size;
+  }
+  /**
+   * Track a newly spawned process.
+   * Enforces limits and sets up timeout.
+   *
+   * **Limitation**: Only direct child processes are tracked.  Grandchildren
+   * (processes spawned by the child) are NOT counted against the limit and
+   * are NOT cleaned up automatically.  The timeout logic does attempt a
+   * process-group kill (`process.kill(-pid, signal)`) which catches immediate
+   * grandchildren on POSIX systems, but this relies on the child having not
+   * changed its process group (e.g. via `setsid`).  For workloads that spawn
+   * deep process trees (e.g. test runners, build systems) the effective
+   * process count may exceed `maxProcesses` at runtime.
+   *
+   * @param childProcess - The spawned child process
+   * @param description - What this process is doing
+   * @param timeoutMs - Optional custom timeout (uses default if not provided)
+   * @throws Error if process limit exceeded
+   * @returns Process tracking ID
+   */
+  track(childProcess, description, timeoutMs, terminateDelegate, reservationId, ownerHandlesSignalShutdown = false) {
+    if (reservationId !== void 0) {
+      if (!this.pendingReservations.has(reservationId)) {
+        throw new Error("Invalid or expired process reservation");
+      }
+      this.pendingReservations.delete(reservationId);
+    } else {
+      this.cleanupDeadProcesses();
+      if (!this.canSpawn()) {
+        throw new Error(
+          `Alert: PROCESS LIMIT EXCEEDED
+
+Maximum processes: ${this.maxProcesses}
+Currently active: ${this.trackedProcesses.size}
+
+Cannot spawn new process: ${description}
+
+This safety limit prevents process table exhaustion.
+Wait for existing processes to complete or increase limit with BUILD_MAX_PROCESSES env var.`
+        );
+      }
+    }
+    const trackingId = this.nextProcessId++;
+    const timeout = timeoutMs ?? this.defaultTimeout;
+    const tracked = {
+      process: childProcess,
+      pid: childProcess.pid,
+      spawnedAt: Date.now(),
+      description,
+      timeoutMs: timeout,
+      terminateDelegate,
+      ownerHandlesSignalShutdown
+    };
+    if (timeout > 0) {
+      if (terminateDelegate) {
+        tracked.timeoutHandle = setTimeout(() => {
+          emitWarning(
+            "PERF-004",
+            {
+              taskId: "process-limiter",
+              subsystem: "safety",
+              executionPhase: "execution"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                stage: "delegate",
+                action: "terminateDelegate",
+                processDescription: description,
+                pid: childProcess.pid,
+                timeoutMs: timeout,
+                reason: "Process timeout - delegated termination"
+              }
+            }
+          );
+          try {
+            terminateDelegate({
+              trackingId,
+              pid: childProcess.pid,
+              description,
+              timeoutMs: timeout,
+              reason: "hard_timeout",
+              source: "process-limiter"
+            });
+          } catch (err) {
+            console.error("[ProcessLimiter] terminateDelegate failed:", err);
+            this.kill(trackingId, "SIGTERM");
+            return;
+          }
+          if (this.trackedProcesses.has(trackingId)) {
+            this.scheduleDelegateForceKillFallback(trackingId, tracked);
+          }
+        }, timeout);
+      } else {
+        tracked.timeoutHandle = setTimeout(() => {
+          emitWarning(
+            "PERF-004",
+            {
+              taskId: "process-limiter",
+              subsystem: "safety",
+              executionPhase: "execution"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                stage: "1/3",
+                action: "SIGTERM",
+                processDescription: description,
+                pid: childProcess.pid,
+                timeoutMs: timeout,
+                reason: "Process timeout - graceful shutdown"
+              }
+            }
+          );
+          if (childProcess.pid) {
+            try {
+              signalProcessGroup(childProcess.pid, "SIGTERM");
+            } catch (pgErr) {
+              try {
+                childProcess.kill("SIGTERM");
+              } catch (singleErr) {
+                const errorMsg = `Failed to terminate process ${childProcess.pid}: group kill failed (${pgErr}), single kill failed (${singleErr})`;
+                console.error(`[ProcessLimiter] CRITICAL: ${errorMsg}`);
+                emitWarning(
+                  "PR-001",
+                  {
+                    taskId: "process-limiter",
+                    subsystem: "safety",
+                    executionPhase: "execution"
+                  },
+                  {
+                    severity: "ERROR" /* ERROR */,
+                    metadata: {
+                      action: "SIGTERM",
+                      pid: childProcess.pid,
+                      error: errorMsg,
+                      reason: "Both process group and single process SIGTERM failed - process may be orphaned"
+                    }
+                  }
+                );
+              }
+            }
+          } else {
+            try {
+              childProcess.kill("SIGTERM");
+            } catch (err) {
+              const errorMsg = `Failed to terminate process (no PID): ${String(err)}`;
+              console.error(`[ProcessLimiter] CRITICAL: ${errorMsg}`);
+              emitWarning(
+                "PR-001",
+                {
+                  taskId: "process-limiter",
+                  subsystem: "safety",
+                  executionPhase: "execution"
+                },
+                {
+                  severity: "ERROR" /* ERROR */,
+                  metadata: {
+                    action: "SIGTERM",
+                    pid: childProcess.pid,
+                    error: String(err),
+                    reason: "SIGTERM signal delivery failed (no PID available)"
+                  }
+                }
+              );
+            }
+          }
+          tracked.forceKillTimeoutHandle = setTimeout(() => {
+            if (this.trackedProcesses.has(trackingId)) {
+              emitWarning(
+                "PERF-004",
+                {
+                  taskId: "process-limiter",
+                  subsystem: "safety",
+                  executionPhase: "execution"
+                },
+                {
+                  severity: "WARN" /* WARN */,
+                  metadata: {
+                    stage: "2/3",
+                    action: "SIGKILL",
+                    processDescription: description,
+                    pid: childProcess.pid,
+                    reason: "Process survived SIGTERM - force kill"
+                  }
+                }
+              );
+              if (childProcess.pid) {
+                try {
+                  signalProcessGroup(childProcess.pid, "SIGKILL");
+                } catch (pgErr) {
+                  try {
+                    childProcess.kill("SIGKILL");
+                  } catch (singleErr) {
+                    const errorMsg = `Process ${childProcess.pid} survived SIGKILL - manual intervention required: group kill failed (${pgErr}), single kill failed (${singleErr})`;
+                    console.error(`[ProcessLimiter] CRITICAL: ${errorMsg}`);
+                    emitWarning(
+                      "PR-001",
+                      {
+                        taskId: "process-limiter",
+                        subsystem: "safety",
+                        executionPhase: "execution"
+                      },
+                      {
+                        severity: "ERROR" /* ERROR */,
+                        metadata: {
+                          action: "SIGKILL",
+                          pid: childProcess.pid,
+                          error: errorMsg,
+                          reason: "Both process group and single process SIGKILL failed - process is orphaned and requires manual cleanup",
+                          manualCleanup: `kill -9 ${childProcess.pid}`
+                        }
+                      }
+                    );
+                  }
+                }
+              } else {
+                try {
+                  childProcess.kill("SIGKILL");
+                } catch (err) {
+                  const errorMsg = `Failed to SIGKILL process (no PID): ${String(err)}`;
+                  console.error(`[ProcessLimiter] CRITICAL: ${errorMsg}`);
+                  emitWarning(
+                    "PR-001",
+                    {
+                      taskId: "process-limiter",
+                      subsystem: "safety",
+                      executionPhase: "execution"
+                    },
+                    {
+                      severity: "ERROR" /* ERROR */,
+                      metadata: {
+                        action: "SIGKILL",
+                        pid: childProcess.pid,
+                        error: String(err),
+                        reason: "SIGKILL signal delivery failed (no PID available)"
+                      }
+                    }
+                  );
+                }
+              }
+              tracked.hardDeadlineHandle = setTimeout(() => {
+                const stillTracked = this.trackedProcesses.get(trackingId);
+                if (!stillTracked) return;
+                if (stillTracked.pid && !processIsAlive(stillTracked.pid)) {
+                  this.untrack(trackingId);
+                  return;
+                }
+                const errorMsg = `CRITICAL: Process ${childProcess.pid} (${description}) survived both SIGTERM and SIGKILL - manual intervention required: kill -9 ${childProcess.pid}`;
+                console.error(`[ProcessLimiter] ${errorMsg}`);
+                emitWarning(
+                  "PERF-004",
+                  {
+                    taskId: "process-limiter",
+                    subsystem: "safety",
+                    executionPhase: "execution"
+                  },
+                  {
+                    severity: "ERROR" /* ERROR */,
+                    metadata: {
+                      stage: "3/3",
+                      action: "retain-orphan",
+                      processDescription: description,
+                      pid: childProcess.pid,
+                      reason: "CRITICAL: Process survived SIGKILL - retained in accounting until it exits",
+                      manualCleanup: `kill -9 ${childProcess.pid}`
+                    }
+                  }
+                );
+              }, PROCESS_LIMITER_HARD_DEADLINE_MS);
+            }
+          }, PROCESS_LIMITER_SIGKILL_GRACE_MS);
+        }, timeout);
+      }
+    }
+    if (childProcess && "on" in childProcess && typeof childProcess.on === "function") {
+      try {
+        const exitHandler = () => this.untrack(trackingId);
+        tracked.exitHandler = exitHandler;
+        childProcess.on("exit", exitHandler);
+        childProcess.on("error", exitHandler);
+      } catch {
+      }
+    }
+    this.trackedProcesses.set(trackingId, tracked);
+    return trackingId;
+  }
+  /**
+   * Stop tracking a process (called automatically on exit).
+   * Cleans up timeout and removes from tracking.
+   * CRITICAL: Also removes event listeners to prevent memory leaks.
+   *
+   * @param trackingId - The tracking ID returned by track()
+   */
+  untrack(trackingId) {
+    const tracked = this.trackedProcesses.get(trackingId);
+    if (!tracked) return;
+    if (tracked.timeoutHandle) {
+      clearTimeout(tracked.timeoutHandle);
+    }
+    if (tracked.forceKillTimeoutHandle) {
+      clearTimeout(tracked.forceKillTimeoutHandle);
+      if (process.platform !== "win32" && tracked.pid && tracked.pid > 0) {
+        try {
+          signalProcessGroup(tracked.pid, "SIGKILL");
+        } catch {
+        }
+      }
+    }
+    if (tracked.hardDeadlineHandle) {
+      clearTimeout(tracked.hardDeadlineHandle);
+    }
+    if (tracked.exitHandler && tracked.process && "off" in tracked.process && typeof tracked.process.off === "function") {
+      try {
+        tracked.process.off("exit", tracked.exitHandler);
+        tracked.process.off("error", tracked.exitHandler);
+      } catch (_err) {
+      }
+    }
+    this.trackedProcesses.delete(trackingId);
+    this.notifyIdleWaiters();
+  }
+  /**
+   * Kill a tracked process.
+   *
+   * @param trackingId - The tracking ID
+   * @param signal - Signal to send (default: SIGTERM)
+   */
+  kill(trackingId, signal = "SIGTERM") {
+    const tracked = this.trackedProcesses.get(trackingId);
+    if (!tracked) return;
+    try {
+      if (process.platform !== "win32" && tracked.pid && tracked.pid > 0) {
+        try {
+          signalProcessGroup(tracked.pid, signal);
+        } catch {
+          tracked.process.kill(signal);
+        }
+      } else {
+        tracked.process.kill(signal);
+      }
+    } catch (err) {
+      emitWarning(
+        "PR-001",
+        {
+          taskId: "process-limiter",
+          subsystem: "safety",
+          executionPhase: "execution"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            action: "kill",
+            signal,
+            pid: tracked.pid,
+            error: String(err),
+            reason: "Process kill failed (may already be dead)"
+          }
+        }
+      );
+    }
+    if (signal === "SIGKILL") {
+      this.untrack(trackingId);
+      return;
+    }
+    if (tracked.forceKillTimeoutHandle) {
+      clearTimeout(tracked.forceKillTimeoutHandle);
+    }
+    tracked.forceKillTimeoutHandle = setTimeout(() => {
+      const current = this.trackedProcesses.get(trackingId);
+      if (!current) return;
+      this.kill(trackingId, "SIGKILL");
+    }, PROCESS_LIMITER_SIGKILL_GRACE_MS);
+    tracked.forceKillTimeoutHandle.unref?.();
+  }
+  /**
+   * Kill all tracked processes.
+   * Used during cleanup/shutdown.
+   *
+   * @param signal - Signal to send (default: SIGTERM)
+   */
+  killAll(signal = "SIGTERM") {
+    const trackingIds = Array.from(this.trackedProcesses.keys());
+    for (const id of trackingIds) {
+      this.kill(id, signal);
+    }
+  }
+  scheduleDelegateForceKillFallback(trackingId, tracked) {
+    if (tracked.forceKillTimeoutHandle) {
+      clearTimeout(tracked.forceKillTimeoutHandle);
+    }
+    tracked.forceKillTimeoutHandle = setTimeout(() => {
+      if (!this.trackedProcesses.has(trackingId)) return;
+      this.kill(trackingId, "SIGKILL");
+    }, PROCESS_LIMITER_SIGKILL_GRACE_MS);
+    tracked.forceKillTimeoutHandle.unref?.();
+  }
+  /**
+   * Get information about all tracked processes.
+   * Useful for debugging and monitoring.
+   */
+  getTrackedProcesses() {
+    this.cleanupDeadProcesses();
+    const now = Date.now();
+    return Array.from(this.trackedProcesses.entries()).map(([id, tracked]) => ({
+      trackingId: id,
+      pid: tracked.pid,
+      description: tracked.description,
+      ageMs: now - tracked.spawnedAt
+    }));
+  }
+  /**
+   * Remove expired reservations from the pending map.
+   * A reservation is expired when its age exceeds reservationExpiryMs.
+   */
+  cleanupExpiredReservations() {
+    const cutoff = Date.now() - this.reservationExpiryMs;
+    for (const [id, createdAt] of this.pendingReservations) {
+      if (createdAt < cutoff) {
+        this.pendingReservations.delete(id);
+      }
+    }
+  }
+  /**
+   * Lazy cleanup: Only runs if enough time has passed since last cleanup.
+   * Called on read operations (canSpawn, getActiveCount) to avoid O(N) overhead.
+   */
+  maybeCleanupDeadProcesses() {
+    const now = Date.now();
+    if (now - this.lastCleanupTimestamp >= this.cleanupIntervalMs) {
+      this.cleanupDeadProcesses();
+    }
+  }
+  /**
+   * Remove dead processes from tracking.
+   * Called automatically on spawn/untrack operations and periodically on read operations.
+   */
+  cleanupDeadProcesses() {
+    this.lastCleanupTimestamp = Date.now();
+    const deadIds = [];
+    const entries = Array.from(this.trackedProcesses.entries());
+    for (const [id, tracked] of entries) {
+      if (tracked.pid && !processIsAlive(tracked.pid)) {
+        deadIds.push(id);
+      }
+    }
+    for (const id of deadIds) {
+      this.untrack(id);
+    }
+  }
+  /**
+   * Register cleanup handlers for process exit.
+   */
+  registerCleanupHandlers() {
+    signalCoordinator.register(
+      this.signalHandlerName,
+      async (context) => {
+        const ownerHandles = OWNER_HANDLED_SIGNALS.has(context?.reason);
+        const ids = () => ownerHandles ? this.limiterOwnedIds() : [...this.trackedProcesses.keys()];
+        if (ids().length === 0) return;
+        if (!isQuietOutputRequested() && shouldShowLifecycleDiagnostics()) {
+          console.error("Cleaning up spawned processes...");
+        }
+        for (const id of ids()) this.kill(id, "SIGTERM");
+        const signal = context?.abortSignal;
+        const idle = await this.waitForIdle(PROCESS_LIMITER_SIGKILL_GRACE_MS, signal, ownerHandles);
+        if (!idle) for (const id of ids()) this.kill(id, "SIGKILL");
+      },
+      { priority: "critical", phase: "process-termination" }
+    );
+    if (!this.exitHandler) {
+      this.exitHandler = () => {
+        this.killAll("SIGTERM");
+        this.killAll("SIGKILL");
+      };
+    }
+    process.removeListener("exit", this.exitHandler);
+    process.on("exit", this.exitHandler);
+    this.cleanupHandlers = [
+      () => {
+        signalCoordinator.unregister?.(
+          this.signalHandlerName
+        );
+      },
+      () => {
+        if (this.exitHandler) {
+          process.removeListener("exit", this.exitHandler);
+        }
+      }
+    ];
+  }
+  /**
+   * Clean up all registered handlers and tracked processes
+   */
+  cleanup() {
+    for (const tracked of this.trackedProcesses.values()) {
+      if (tracked.timeoutHandle) clearTimeout(tracked.timeoutHandle);
+      if (tracked.forceKillTimeoutHandle) clearTimeout(tracked.forceKillTimeoutHandle);
+      if (tracked.hardDeadlineHandle) clearTimeout(tracked.hardDeadlineHandle);
+    }
+    this.trackedProcesses.clear();
+    this.pendingReservations.clear();
+    this.notifyIdleWaiters();
+    for (const handler of this.cleanupHandlers) {
+      try {
+        handler();
+      } catch (error) {
+        emitWarning(
+          "PR-001",
+          {
+            taskId: "process-limiter",
+            subsystem: "safety",
+            executionPhase: "cleanup"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              action: "cleanup",
+              error: String(error),
+              reason: "Cleanup handler execution failed"
+            }
+          }
+        );
+      }
+    }
+    this.cleanupHandlers = [];
+  }
+  /**
+   * Clean up resources and remove event listeners
+   */
+  close() {
+    for (const [, tracked] of this.trackedProcesses) {
+      if (tracked.timeoutHandle) {
+        clearTimeout(tracked.timeoutHandle);
+        tracked.timeoutHandle = void 0;
+      }
+      if (tracked.forceKillTimeoutHandle) {
+        clearTimeout(tracked.forceKillTimeoutHandle);
+        tracked.forceKillTimeoutHandle = void 0;
+      }
+      if (tracked.hardDeadlineHandle) {
+        clearTimeout(tracked.hardDeadlineHandle);
+        tracked.hardDeadlineHandle = void 0;
+      }
+      if (tracked.exitHandler && tracked.process && "off" in tracked.process && typeof tracked.process.off === "function") {
+        try {
+          tracked.process.off("exit", tracked.exitHandler);
+          tracked.process.off("error", tracked.exitHandler);
+        } catch (_error) {
+        }
+      }
+    }
+    this.trackedProcesses.clear();
+    this.pendingReservations.clear();
+    this.cleanupHandlers.forEach((cleanup) => {
+      try {
+        cleanup();
+      } catch (_error) {
+      }
+    });
+    this.cleanupHandlers = [];
+  }
+  /**
+   * Clean up all ProcessLimiter instances
+   * Call this during test teardown to prevent event listener leaks
+   */
+  static cleanupAllInstances() {
+    for (const instance of _ProcessLimiter.instances) {
+      try {
+        instance.cleanup();
+      } catch (error) {
+        emitWarning(
+          "PR-001",
+          {
+            taskId: "process-limiter",
+            subsystem: "safety",
+            executionPhase: "cleanup"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              action: "cleanupAllInstances",
+              error: String(error),
+              reason: "Failed to cleanup ProcessLimiter instance"
+            }
+          }
+        );
+      }
+    }
+    _ProcessLimiter.instances = [];
+  }
+};
+function getDynamicProcessLimits() {
+  const totalMemoryGB = totalmem() / 1024 ** 3;
+  let cpuCount = 1;
+  try {
+    const cpuInfo = cpus();
+    cpuCount = Array.isArray(cpuInfo) && cpuInfo.length > 0 ? cpuInfo.length : 1;
+  } catch {
+    cpuCount = 1;
+  }
+  let tier;
+  if (totalMemoryGB < 8) tier = "minimal";
+  else if (totalMemoryGB < 16) tier = "standard";
+  else if (totalMemoryGB < 32) tier = "performance";
+  else if (totalMemoryGB < 64) tier = "power";
+  else tier = "ultra";
+  const envTier = process.env.BUILD_RESOURCE_TIER;
+  if (envTier && ["minimal", "standard", "performance", "power", "ultra"].includes(envTier)) {
+    tier = envTier;
+  }
+  const configs = {
+    minimal: { maxProcesses: 5, timeoutMs: 30 * 60 * 1e3 },
+    // 30 min
+    standard: { maxProcesses: 10, timeoutMs: 45 * 60 * 1e3 },
+    // 45 min
+    performance: { maxProcesses: 15, timeoutMs: 60 * 60 * 1e3 },
+    // 60 min
+    power: { maxProcesses: 20, timeoutMs: 90 * 60 * 1e3 },
+    // 90 min
+    ultra: { maxProcesses: 30, timeoutMs: 120 * 60 * 1e3 }
+    // 120 min
+  };
+  const limits = { ...configs[tier] };
+  limits.maxProcesses = Math.min(limits.maxProcesses, Math.max(5, cpuCount * 2));
+  return limits;
+}
+var dynamicLimits = getDynamicProcessLimits();
+var maxProcesses = getIntEnv("BUILD_MAX_PROCESSES", dynamicLimits.maxProcesses);
+var _processTimeoutRaw = readTimeoutEnvWithAlias(
+  "BUILD_PROCESS_TIMEOUT_MS",
+  "BUILD_PROCESS_TIMEOUT"
+);
+var defaultTimeout = (() => {
+  if (_processTimeoutRaw === void 0) return dynamicLimits.timeoutMs;
+  const parsed = Number.parseInt(_processTimeoutRaw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : dynamicLimits.timeoutMs;
+})();
+var globalProcessLimiter = new ProcessLimiter(maxProcesses, defaultTimeout);
+var maxProcessesPinnedByEnv = getIntEnv("BUILD_MAX_PROCESSES", -1) !== -1;
+function ensureGlobalProcessCapacity(needed) {
+  if (maxProcessesPinnedByEnv) return globalProcessLimiter.getMaxProcesses();
+  return globalProcessLimiter.raiseMaxProcesses(needed);
+}
+
+export {
+  PROCESS_LIMITER_SIGKILL_GRACE_MS,
+  globalProcessLimiter,
+  ensureGlobalProcessCapacity
+};
+//# sourceMappingURL=chunk-SF6YK3JI.js.map