@schoolai/shipyard 3.5.0-rc.20260504.0 → 3.5.0

package/dist/chunk-3MNPDCO5.js

@@ -0,0 +1,1011 @@
+#!/usr/bin/env node
+import {
+  assertNever,
+  decodeLine,
+  encodeLine
+} from "./chunk-SNYEQHUK.js";
+
+// src/services/metrics/metrics-collector.ts
+var NOOP_METRICS = {
+  capture() {
+  },
+  dispose() {
+  }
+};
+var MetricsCollector = class {
+  #workerUrl;
+  #authToken;
+  #maxBatchSize;
+  #buffer = [];
+  #timer = null;
+  #disposed = false;
+  constructor(workerUrl, authToken, opts) {
+    this.#workerUrl = workerUrl.replace(/\/$/, "");
+    this.#authToken = authToken;
+    this.#maxBatchSize = opts?.maxBatchSize ?? 50;
+    const intervalMs = opts?.flushIntervalMs ?? 3e4;
+    this.#timer = setInterval(() => {
+      this.flush();
+    }, intervalMs);
+    this.#timer.unref();
+  }
+  capture(eventType, properties) {
+    if (this.#disposed) return;
+    const taskId = typeof properties?.taskId === "string" ? properties.taskId : void 0;
+    this.#buffer.push({
+      eventType,
+      taskId,
+      payload: properties ?? {},
+      clientTimestamp: Date.now()
+    });
+    if (this.#buffer.length >= this.#maxBatchSize) {
+      this.flush();
+    }
+  }
+  flush() {
+    if (this.#buffer.length === 0) return;
+    const events = this.#buffer;
+    this.#buffer = [];
+    const body = { events };
+    fetch(`${this.#workerUrl}/ingest`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.#authToken}`
+      },
+      body: JSON.stringify(body)
+    }).catch(() => {
+    });
+  }
+  dispose() {
+    this.#disposed = true;
+    if (this.#timer) {
+      clearInterval(this.#timer);
+      this.#timer = null;
+    }
+    this.flush();
+  }
+};
+function createMetricsCollector(workerUrl, authToken, telemetryEnabled) {
+  if (!telemetryEnabled || !workerUrl || !authToken) return NOOP_METRICS;
+  return new MetricsCollector(workerUrl, authToken);
+}
+
+// src/shared/file-watcher-guard.ts
+import { fork as childProcessFork } from "child_process";
+
+// src/services/watcher-worker/worker-supervisor.ts
+import { randomUUID } from "crypto";
+var ABNORMAL_SIGNALS = /* @__PURE__ */ new Set(["SIGABRT", "SIGSEGV", "SIGBUS", "SIGKILL"]);
+var SHUTDOWN_GRACEFUL_MS = 2e3;
+var SHUTDOWN_SIGTERM_MS = 500;
+function createWatcherWorkerSupervisor(deps) {
+  const subscriptions = /* @__PURE__ */ new Map();
+  let child = null;
+  let restartState = makeInitialAttemptState();
+  let nextGeneration = 1;
+  let shutdownInitiated = false;
+  let restartTimer = null;
+  let pendingRespawnGeneration = null;
+  function log(entry) {
+    deps.log(entry);
+  }
+  function captureMetric(eventType, properties) {
+    deps.metrics?.capture(eventType, properties);
+  }
+  function sendCommand(holder, cmd) {
+    const stdin = holder.process.stdin;
+    if (!stdin || stdin.destroyed || holder.exited) return false;
+    try {
+      stdin.write(`${encodeLine(cmd)}
+`);
+      return true;
+    } catch (err) {
+      log({
+        event: "watcher_worker_stdin_write_failed",
+        err: err instanceof Error ? err.message : String(err)
+      });
+      return false;
+    }
+  }
+  function dispatchReply(reply, fromGeneration) {
+    switch (reply.type) {
+      case "subscribed":
+        handleSubscribedReply(reply.id, fromGeneration);
+        return;
+      case "subscribe_failed":
+        handleSubscribeFailedReply(reply.id, reply.error);
+        return;
+      case "unsubscribed":
+        handleUnsubscribedReply(reply.id);
+        return;
+      case "events":
+        handleEventsReply(reply.id, reply.events);
+        return;
+      default:
+        assertNever(reply);
+    }
+  }
+  function handleSubscribedReply(id, fromGeneration) {
+    const entry = subscriptions.get(id);
+    if (!entry) return;
+    if (pendingRespawnGeneration !== null && fromGeneration === pendingRespawnGeneration) {
+      pendingRespawnGeneration = null;
+      const successDecision = decideAction(restartState, { kind: "subscribe_success" }, deps.now());
+      restartState = successDecision.state;
+      for (const sig of successDecision.signals) {
+        if (sig.kind === "circuit_closed") {
+          log({ event: "watcher_worker_circuit_closed" });
+        }
+      }
+    }
+    if (entry.status === "pending" && entry.resolveSubscribed) {
+      entry.status = "subscribed";
+      entry.resolveSubscribed(makeHandle(entry));
+      entry.resolveSubscribed = void 0;
+      entry.rejectSubscribed = void 0;
+      return;
+    }
+    entry.status = "subscribed";
+  }
+  function handleSubscribeFailedReply(id, error) {
+    const entry = subscriptions.get(id);
+    if (!entry) return;
+    subscriptions.delete(id);
+    entry.rejectSubscribed?.(new Error(error));
+  }
+  function handleUnsubscribedReply(id) {
+    const entry = subscriptions.get(id);
+    if (!entry) return;
+    subscriptions.delete(id);
+    entry.resolveUnsubscribed?.();
+  }
+  function handleEventsReply(id, events) {
+    const entry = subscriptions.get(id);
+    if (!entry || entry.status === "unsubscribing") return;
+    entry.callback(null, toCallbackEvents(events));
+  }
+  function attachChildIo(holder) {
+    const proc = holder.process;
+    const { stdout, stderr } = proc;
+    if (!stdout) {
+      log({ event: "watcher_worker_no_stdout" });
+      return;
+    }
+    let stdoutBuffer = "";
+    const fromGeneration = holder.generation;
+    stdout.setEncoding("utf8");
+    stdout.on("data", (chunk) => {
+      stdoutBuffer += chunk;
+      let nl = stdoutBuffer.indexOf("\n");
+      while (nl !== -1) {
+        const line = stdoutBuffer.slice(0, nl);
+        stdoutBuffer = stdoutBuffer.slice(nl + 1);
+        nl = stdoutBuffer.indexOf("\n");
+        if (line.length === 0) continue;
+        const decoded = decodeLine(line);
+        if (decoded === null) {
+          log({ event: "watcher_worker_decode_failed", line });
+          continue;
+        }
+        if (!("type" in decoded)) {
+          log({ event: "watcher_worker_unexpected_command", cmd: decoded.cmd });
+          continue;
+        }
+        dispatchReply(decoded, fromGeneration);
+      }
+    });
+    if (stderr) {
+      stderr.setEncoding("utf8");
+      let stderrBuffer = "";
+      stderr.on("data", (chunk) => {
+        stderrBuffer += chunk;
+        let nl = stderrBuffer.indexOf("\n");
+        while (nl !== -1) {
+          const line = stderrBuffer.slice(0, nl);
+          stderrBuffer = stderrBuffer.slice(nl + 1);
+          nl = stderrBuffer.indexOf("\n");
+          if (line.length > 0) {
+            log({ event: "watcher_worker_stderr", line });
+          }
+        }
+      });
+    }
+    proc.on("exit", (code, signal) => {
+      handleChildExit(holder, code, signal);
+    });
+    proc.on("error", (err) => {
+      log({ event: "watcher_worker_error", err: err.message });
+    });
+  }
+  function handleChildExit(holder, code, signal) {
+    holder.exited = true;
+    if (child !== holder) return;
+    child = null;
+    if (pendingRespawnGeneration === holder.generation) {
+      pendingRespawnGeneration = null;
+    }
+    const replayCount = subscriptions.size;
+    const uptimeMs = deps.now() - holder.spawnedAt;
+    if (shutdownInitiated) {
+      log({ event: "watcher_worker_exited_during_shutdown", code, signal, uptimeMs });
+      return;
+    }
+    const abnormal = isAbnormalExit(code, signal) || replayCount > 0;
+    if (!abnormal) {
+      log({ event: "watcher_worker_exited_clean", code, signal, uptimeMs });
+      return;
+    }
+    log({ event: "watcher_worker_died", code, signal, replayCount, uptimeMs });
+    captureMetric("watcher_worker_died", {
+      code,
+      signal,
+      replayCount,
+      uptimeMs
+    });
+    recordRestartFailure(holder);
+    fireSyntheticEvictionToAll();
+    scheduleRespawn();
+  }
+  function recordRestartFailure(holder) {
+    const failureDecision = decideAction(restartState, { kind: "subscribe_failure" }, deps.now());
+    restartState = failureDecision.state;
+    for (const sig of failureDecision.signals) {
+      if (sig.kind === "circuit_opened") {
+        log({ event: "watcher_worker_circuit_open" });
+        captureMetric("watcher_worker_circuit_open", {
+          deathCount: restartState.failureCount,
+          windowMs: deps.now() - holder.spawnedAt
+        });
+      } else if (sig.kind === "circuit_closed") {
+        log({ event: "watcher_worker_circuit_closed" });
+      }
+    }
+  }
+  function dispatchSyntheticEviction(entry) {
+    if (!subscriptions.has(entry.id)) return;
+    try {
+      entry.callback(null, [{ type: "evicted", path: entry.path }]);
+    } catch (err) {
+      log({
+        event: "watcher_worker_synthetic_dispatch_failed",
+        id: entry.id,
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  function fireSyntheticEvictionToAll() {
+    const snapshot = Array.from(subscriptions.values());
+    queueMicrotask(() => {
+      for (const entry of snapshot) {
+        dispatchSyntheticEviction(entry);
+      }
+    });
+  }
+  function scheduleRespawn() {
+    if (shutdownInitiated) return;
+    if (restartTimer !== null) return;
+    const requestDecision = decideAction(
+      restartState,
+      { kind: "request_subscribe", reason: "rescan", activeCount: 0 },
+      deps.now()
+    );
+    restartState = requestDecision.state;
+    switch (requestDecision.action.kind) {
+      case "reject_stub": {
+        const openedAt = restartState.circuitOpenedAt;
+        if (openedAt === null) {
+          attemptRespawn();
+          return;
+        }
+        const cooldownEnd = openedAt + restartState.circuitCooldownMs;
+        const waitMs = Math.max(0, cooldownEnd - deps.now());
+        restartTimer = deps.setTimeout(() => {
+          restartTimer = null;
+          scheduleRespawn();
+        }, waitMs);
+        return;
+      }
+      case "wait": {
+        restartTimer = deps.setTimeout(() => {
+          restartTimer = null;
+          attemptRespawn();
+        }, requestDecision.action.ms);
+        return;
+      }
+      case "subscribe":
+      case "evict_and_subscribe":
+        attemptRespawn();
+        return;
+      case "noop":
+        attemptRespawn();
+        return;
+      default:
+        assertNever(requestDecision.action);
+    }
+  }
+  function attemptRespawn() {
+    if (shutdownInitiated) return;
+    if (restartState.circuitOpenedAt !== null) {
+      log({ event: "watcher_worker_probe_attempt" });
+    }
+    try {
+      forkAndReplay();
+    } catch (err) {
+      log({
+        event: "watcher_worker_fork_failed",
+        err: err instanceof Error ? err.message : String(err)
+      });
+      const failureDecision = decideAction(restartState, { kind: "subscribe_failure" }, deps.now());
+      restartState = failureDecision.state;
+      scheduleRespawn();
+    }
+  }
+  function forkAndReplay() {
+    const isRespawn = nextGeneration > 1;
+    const replayStart = deps.now();
+    const holder = spawnChildHolder();
+    if (isRespawn && subscriptions.size > 0) {
+      pendingRespawnGeneration = holder.generation;
+    }
+    const replayResult = replaySubscriptions(holder);
+    if (replayResult.kind === "pipe_failed") {
+      handleReplayPipeFailure(holder, replayResult.replayedCount);
+      return;
+    }
+    if (replayResult.replayedCount > 0) {
+      log({ event: "watcher_worker_replayed", replayCount: replayResult.replayedCount });
+    }
+    if (isRespawn) {
+      recordRespawnTelemetry(holder, replayResult.replayedCount, deps.now() - replayStart);
+    }
+  }
+  function spawnChildHolder() {
+    const proc = deps.fork(deps.workerPath, [], {
+      stdio: ["pipe", "pipe", "pipe", "ipc"]
+    });
+    const holder = {
+      process: proc,
+      spawnedAt: deps.now(),
+      generation: nextGeneration++,
+      exited: false
+    };
+    child = holder;
+    log({ event: "watcher_worker_started", pid: proc.pid ?? null });
+    captureMetric("watcher_worker_started", { pid: proc.pid ?? null });
+    attachChildIo(holder);
+    return holder;
+  }
+  function replaySubscriptions(holder) {
+    let replayedCount = 0;
+    for (const entry of subscriptions.values()) {
+      entry.status = "pending";
+      const ok = sendCommand(holder, {
+        cmd: "subscribe",
+        id: entry.id,
+        path: entry.path,
+        opts: entry.opts
+      });
+      if (!ok) {
+        return { kind: "pipe_failed", replayedCount };
+      }
+      replayedCount++;
+    }
+    return { kind: "completed", replayedCount };
+  }
+  function handleReplayPipeFailure(holder, replayedCount) {
+    log({
+      event: "watcher_worker_replay_pipe_failed",
+      pid: holder.process.pid ?? null,
+      replayedCount,
+      pendingCount: subscriptions.size - replayedCount
+    });
+    recordRestartFailure(holder);
+    if (!holder.exited) {
+      try {
+        holder.process.kill("SIGKILL");
+      } catch (err) {
+        log({
+          event: "watcher_worker_kill_failed",
+          signal: "SIGKILL",
+          err: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    scheduleRespawn();
+  }
+  function recordRespawnTelemetry(holder, replayCount, replayDurationMs) {
+    log({
+      event: "watcher_worker_respawned",
+      pid: holder.process.pid ?? null,
+      replayCount,
+      replayDurationMs
+    });
+    captureMetric("watcher_worker_respawned", {
+      newPid: holder.process.pid ?? null,
+      replayCount,
+      replayDurationMs
+    });
+  }
+  function makeHandle(entry) {
+    return {
+      unsubscribe: () => unsubscribeEntry(entry)
+    };
+  }
+  function unsubscribeEntry(entry) {
+    if (!subscriptions.has(entry.id)) return Promise.resolve();
+    entry.status = "unsubscribing";
+    if (!child) {
+      subscriptions.delete(entry.id);
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      entry.resolveUnsubscribed = resolve;
+      const sent = child !== null && sendCommand(child, { cmd: "unsubscribe", id: entry.id });
+      if (!sent) {
+        subscriptions.delete(entry.id);
+        resolve();
+      }
+    });
+  }
+  function makeStubHandle() {
+    return { unsubscribe: async () => {
+    } };
+  }
+  async function start() {
+    if (child !== null) return;
+    if (shutdownInitiated) {
+      throw new Error("WatcherWorkerSupervisor: cannot start after shutdown");
+    }
+    forkAndReplay();
+  }
+  async function subscribe(path, callback, opts) {
+    if (shutdownInitiated) {
+      throw new Error("WatcherWorkerSupervisor: cannot subscribe after shutdown");
+    }
+    if (restartState.circuitOpenedAt !== null) {
+      const cooldownEnd = restartState.circuitOpenedAt + restartState.circuitCooldownMs;
+      if (deps.now() < cooldownEnd) {
+        log({ event: "watcher_worker_subscribe_stubbed", path });
+        return makeStubHandle();
+      }
+    }
+    const id = randomUUID();
+    const entry = {
+      id,
+      path,
+      opts,
+      callback,
+      status: "pending"
+    };
+    const promise = new Promise((resolve, reject) => {
+      entry.resolveSubscribed = resolve;
+      entry.rejectSubscribed = reject;
+    });
+    subscriptions.set(id, entry);
+    if (child === null) {
+      await start();
+    } else {
+      sendCommand(child, { cmd: "subscribe", id, path, opts });
+    }
+    return promise;
+  }
+  async function shutdown() {
+    if (shutdownInitiated) return;
+    shutdownInitiated = true;
+    if (restartTimer !== null) {
+      deps.clearTimeout(restartTimer);
+      restartTimer = null;
+    }
+    for (const entry of subscriptions.values()) {
+      entry.rejectSubscribed?.(new Error("WatcherWorkerSupervisor: shutdown"));
+      entry.rejectSubscribed = void 0;
+      entry.resolveSubscribed = void 0;
+      entry.resolveUnsubscribed?.();
+      entry.resolveUnsubscribed = void 0;
+    }
+    subscriptions.clear();
+    const holder = child;
+    if (holder === null) return;
+    sendCommand(holder, { cmd: "shutdown" });
+    await escalateShutdown(holder);
+  }
+  function killWithSignal(holder, signal) {
+    log({
+      event: signal === "SIGTERM" ? "watcher_worker_shutdown_sigterm" : "watcher_worker_shutdown_sigkill"
+    });
+    try {
+      holder.process.kill(signal);
+    } catch (err) {
+      log({
+        event: "watcher_worker_kill_failed",
+        signal,
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  function escalateShutdown(holder) {
+    return new Promise((resolve) => {
+      const ctx = { done: false };
+      const finish = () => {
+        if (ctx.done) return;
+        ctx.done = true;
+        resolve();
+      };
+      holder.process.once("exit", finish);
+      if (holder.exited) {
+        finish();
+        return;
+      }
+      deps.setTimeout(() => onSigtermDeadline(holder, ctx, finish), SHUTDOWN_GRACEFUL_MS);
+    });
+  }
+  function onSigtermDeadline(holder, ctx, finish) {
+    if (ctx.done || holder.exited) return;
+    killWithSignal(holder, "SIGTERM");
+    deps.setTimeout(() => onSigkillDeadline(holder, ctx, finish), SHUTDOWN_SIGTERM_MS);
+  }
+  function onSigkillDeadline(holder, ctx, finish) {
+    if (ctx.done || holder.exited) return;
+    killWithSignal(holder, "SIGKILL");
+    finish();
+  }
+  return { start, subscribe, shutdown };
+}
+function isAbnormalExit(code, signal) {
+  if (signal !== null && ABNORMAL_SIGNALS.has(signal)) return true;
+  if (code !== null && code !== 0) return true;
+  return false;
+}
+function toCallbackEvents(events) {
+  return events.map((e) => ({ type: e.type, path: e.path }));
+}
+
+// src/shared/file-watcher-guard.ts
+var DEFAULT_MAX_ACTIVE_WATCHERS = 450;
+var ENV_MAX = process.env.SHIPYARD_FILE_WATCHER_MAX;
+var PARSED_ENV_MAX = ENV_MAX ? Number.parseInt(ENV_MAX, 10) : Number.NaN;
+var MAX_ACTIVE_WATCHERS = Number.isFinite(PARSED_ENV_MAX) && PARSED_ENV_MAX > 0 ? PARSED_ENV_MAX : DEFAULT_MAX_ACTIVE_WATCHERS;
+var STARTING_BACKOFF_MS_INITIAL = 250;
+var STARTING_BACKOFF_MS_ESCALATION = 1e3;
+var MAX_BACKOFF_MS = 3e4;
+var BACKOFF_RESET_AFTER_MS = 5 * 6e4;
+var CIRCUIT_FAILURES = 5;
+var CIRCUIT_WINDOW_MS = 6e4;
+var CIRCUIT_OPEN_MS = 5 * 6e4;
+var CIRCUIT_OPEN_MAX_MS = 30 * 6e4;
+var ESSENTIAL_RESUBSCRIBE_DELAY_MS = 1e3;
+function makeInitialAttemptState() {
+  return {
+    failureCount: 0,
+    backoffMs: 0,
+    lastFailureAt: 0,
+    circuitOpenedAt: null,
+    circuitCooldownMs: CIRCUIT_OPEN_MS,
+    recentFailures: [],
+    halfOpenAt: null
+  };
+}
+function isCleanAttemptState(state) {
+  return state.circuitOpenedAt === null && state.failureCount === 0 && state.backoffMs === 0 && state.recentFailures.length === 0 && state.halfOpenAt === null;
+}
+function decideAction(state, event, now) {
+  switch (event.kind) {
+    case "request_subscribe":
+      return decideRequest(state, event, now);
+    case "subscribe_success":
+      return decideSuccess(state, now);
+    case "subscribe_failure":
+      return decideFailure(state, now);
+    default:
+      return assertNever(event);
+  }
+}
+function decideRequest(state, event, now) {
+  const decayed = decayBackoff(state, now);
+  if (decayed.circuitOpenedAt !== null) {
+    const cooldownEnd = decayed.circuitOpenedAt + decayed.circuitCooldownMs;
+    if (now < cooldownEnd) {
+      return {
+        state: decayed,
+        action: { kind: "reject_stub", reason: "circuit_open" },
+        signals: []
+      };
+    }
+    return {
+      state: { ...decayed, halfOpenAt: now },
+      action: event.activeCount >= MAX_ACTIVE_WATCHERS ? { kind: "evict_and_subscribe" } : { kind: "subscribe" },
+      signals: [{ kind: "circuit_probe" }]
+    };
+  }
+  if (decayed.backoffMs > 0 && now < decayed.lastFailureAt + decayed.backoffMs) {
+    const remaining = decayed.lastFailureAt + decayed.backoffMs - now;
+    return { state: decayed, action: { kind: "wait", ms: remaining }, signals: [] };
+  }
+  let nextState = decayed;
+  if (decayed.backoffMs === 0 && event.reason === "escalation") {
+    nextState = { ...decayed, backoffMs: STARTING_BACKOFF_MS_ESCALATION };
+  }
+  if (event.activeCount >= MAX_ACTIVE_WATCHERS) {
+    return { state: nextState, action: { kind: "evict_and_subscribe" }, signals: [] };
+  }
+  return { state: nextState, action: { kind: "subscribe" }, signals: [] };
+}
+function decideSuccess(state, _now) {
+  const wasHalfOpen = state.halfOpenAt !== null;
+  const next = {
+    failureCount: 0,
+    backoffMs: 0,
+    lastFailureAt: 0,
+    circuitOpenedAt: null,
+    circuitCooldownMs: CIRCUIT_OPEN_MS,
+    recentFailures: [],
+    halfOpenAt: null
+  };
+  return {
+    state: next,
+    action: { kind: "noop" },
+    signals: wasHalfOpen ? [{ kind: "circuit_closed" }] : []
+  };
+}
+function decideFailure(state, now) {
+  const recent = [...state.recentFailures.filter((t) => now - t < CIRCUIT_WINDOW_MS), now];
+  const baseBackoff = state.backoffMs === 0 ? STARTING_BACKOFF_MS_INITIAL : Math.min(state.backoffMs * 2, MAX_BACKOFF_MS);
+  if (state.halfOpenAt !== null) {
+    const nextCooldown = Math.min(state.circuitCooldownMs * 2, CIRCUIT_OPEN_MAX_MS);
+    return {
+      state: {
+        ...state,
+        failureCount: state.failureCount + 1,
+        backoffMs: baseBackoff,
+        lastFailureAt: now,
+        recentFailures: recent,
+        circuitOpenedAt: now,
+        circuitCooldownMs: nextCooldown,
+        halfOpenAt: null
+      },
+      action: { kind: "noop" },
+      signals: [{ kind: "circuit_opened" }]
+    };
+  }
+  if (recent.length >= CIRCUIT_FAILURES && state.circuitOpenedAt === null) {
+    return {
+      state: {
+        ...state,
+        failureCount: state.failureCount + 1,
+        backoffMs: baseBackoff,
+        lastFailureAt: now,
+        recentFailures: recent,
+        circuitOpenedAt: now,
+        circuitCooldownMs: CIRCUIT_OPEN_MS,
+        halfOpenAt: null
+      },
+      action: { kind: "noop" },
+      signals: [{ kind: "circuit_opened" }]
+    };
+  }
+  return {
+    state: {
+      ...state,
+      failureCount: state.failureCount + 1,
+      backoffMs: baseBackoff,
+      lastFailureAt: now,
+      recentFailures: recent
+    },
+    action: { kind: "noop" },
+    signals: []
+  };
+}
+function decayBackoff(state, now) {
+  if (state.lastFailureAt === 0 || state.backoffMs === 0) return state;
+  const sinceLast = now - state.lastFailureAt;
+  if (sinceLast >= BACKOFF_RESET_AFTER_MS) {
+    return { ...state, backoffMs: 0, failureCount: 0, recentFailures: [] };
+  }
+  const halvings = Math.floor(sinceLast / 6e4);
+  if (halvings === 0) return state;
+  const next = Math.max(STARTING_BACKOFF_MS_INITIAL, state.backoffMs >> halvings);
+  return { ...state, backoffMs: next };
+}
+var moduleState = makeModuleState();
+function makeModuleState() {
+  return {
+    active: /* @__PURE__ */ new Set(),
+    reservations: /* @__PURE__ */ new Set(),
+    perPath: /* @__PURE__ */ new Map(),
+    loggedOpenAt: /* @__PURE__ */ new Map(),
+    deps: defaultDeps(),
+    supervisor: null,
+    supervisorMetrics: null
+  };
+}
+var IN_VITEST = process.env.VITEST === "true" || process.env.NODE_ENV === "test";
+function defaultDeps() {
+  return {
+    /**
+     * Production path: route every subscribe through the watcher worker
+     * supervisor (which runs `@parcel/watcher` in a subprocess). The
+     * supervisor delivers `WatcherWorkerEventLike[]` whose 'evicted' variant
+     * is fired during worker respawns; we widen it to `GuardedEvent[]`
+     * (which already accommodates 'evicted' via the LRU eviction path).
+     */
+    subscribe: (path, fn, opts) => {
+      if (IN_VITEST) return legacyDirectSubscribe(path, fn, opts);
+      return supervisorSubscribe(path, fn, opts);
+    },
+    log: () => {
+    },
+    now: () => Date.now(),
+    setTimeout: (fn, ms) => setTimeout(fn, ms),
+    clearTimeout: (timer) => {
+      if (timer === null || timer === void 0) return;
+      clearTimeout(timer);
+    }
+  };
+}
+var supervisorSubscribe = async (path, fn, opts) => {
+  const supervisor = ensureSupervisor();
+  const handle = await supervisor.subscribe(
+    path,
+    (err, events) => {
+      fn(err, events.map(toGuardedEvent));
+    },
+    toSupervisorOpts(opts)
+  );
+  return { unsubscribe: () => handle.unsubscribe() };
+};
+function toSupervisorOpts(opts) {
+  const out = {};
+  if (!opts) return out;
+  if (opts.ignore) out.ignore = opts.ignore;
+  if (opts.backend === "brute-force" || opts.backend === "watchman") {
+    out.backend = opts.backend;
+  }
+  return out;
+}
+function toGuardedEvent(e) {
+  switch (e.type) {
+    case "evicted":
+      return { type: "evicted", path: e.path };
+    case "create":
+    case "update":
+    case "delete":
+      return { type: e.type, path: e.path };
+    default:
+      return assertNever(e.type);
+  }
+}
+function ensureSupervisor() {
+  if (moduleState.supervisor) return moduleState.supervisor;
+  const workerPath = new URL("./worker.js", import.meta.url).pathname;
+  moduleState.supervisor = createWatcherWorkerSupervisor({
+    fork: nodeFork,
+    workerPath,
+    log: (entry) => moduleState.deps.log(entry),
+    metrics: moduleState.supervisorMetrics ?? void 0,
+    now: () => moduleState.deps.now(),
+    setTimeout: (fn, ms) => moduleState.deps.setTimeout(fn, ms),
+    clearTimeout: (timer) => moduleState.deps.clearTimeout(timer)
+  });
+  return moduleState.supervisor;
+}
+var nodeFork = (modulePath, args, options) => childProcessFork(modulePath, args, options);
+function occupancy() {
+  return moduleState.active.size + moduleState.reservations.size;
+}
+function configureFileWatcherGuard(deps) {
+  moduleState.deps = { ...moduleState.deps, log: deps.log };
+  if (deps.metrics) {
+    moduleState.supervisorMetrics = deps.metrics;
+  }
+}
+var legacyDirectSubscribe = async (path, fn, opts) => {
+  const mod = await import("@parcel/watcher");
+  return mod.subscribe(
+    path,
+    (err, events) => {
+      const widened = events.map((e) => ({ type: e.type, path: e.path }));
+      fn(err, widened);
+    },
+    opts
+  );
+};
+async function shutdownFileWatcherGuard() {
+  const supervisor = moduleState.supervisor;
+  if (!supervisor) return;
+  moduleState.supervisor = null;
+  await supervisor.shutdown();
+}
+async function guardedSubscribe(path, callback, opts, tier, reason) {
+  const { deps } = moduleState;
+  const now = deps.now();
+  const priorState = moduleState.perPath.get(path) ?? makeInitialAttemptState();
+  const decision = decideAction(
+    priorState,
+    { kind: "request_subscribe", reason, activeCount: occupancy() },
+    now
+  );
+  moduleState.perPath.set(path, decision.state);
+  emitSignals(path, decision.signals);
+  switch (decision.action.kind) {
+    case "reject_stub":
+      return makeStubSubscription();
+    case "wait": {
+      const waitMs = decision.action.ms;
+      await new Promise((resolve) => deps.setTimeout(() => resolve(), waitMs));
+      return guardedSubscribe(path, callback, opts, tier, "escalation");
+    }
+    case "evict_and_subscribe":
+      evictOne(path);
+      return performSubscribe(path, callback, opts, tier);
+    case "subscribe":
+      return performSubscribe(path, callback, opts, tier);
+    case "noop":
+      throw new Error("guardedSubscribe: unexpected noop on request");
+    default:
+      return assertNever(decision.action);
+  }
+}
+async function performSubscribe(path, consumerCallback, opts, tier) {
+  const { deps } = moduleState;
+  let entry = null;
+  const reservation = { path, tier, reservedAt: deps.now() };
+  moduleState.reservations.add(reservation);
+  const wrapped = (err, events) => {
+    if (entry) entry.lastUsedAt = deps.now();
+    consumerCallback(err, events);
+  };
+  try {
+    const sub = await deps.subscribe(path, wrapped, opts);
+    moduleState.reservations.delete(reservation);
+    const now = deps.now();
+    const priorState = moduleState.perPath.get(path) ?? makeInitialAttemptState();
+    const successDecision = decideAction(priorState, { kind: "subscribe_success" }, now);
+    if (isCleanAttemptState(successDecision.state)) {
+      moduleState.perPath.delete(path);
+    } else {
+      moduleState.perPath.set(path, successDecision.state);
+    }
+    emitSignals(path, successDecision.signals);
+    entry = {
+      path,
+      tier,
+      lastUsedAt: now,
+      unsubscribe: () => sub.unsubscribe(),
+      consumerCallback
+    };
+    moduleState.active.add(entry);
+    deps.log({ event: "file_watcher_active_count", count: moduleState.active.size });
+    return {
+      unsubscribe: async () => {
+        if (entry && moduleState.active.has(entry)) {
+          moduleState.active.delete(entry);
+        }
+        const current = moduleState.perPath.get(path);
+        if (current && isCleanAttemptState(current)) {
+          moduleState.perPath.delete(path);
+        }
+        await sub.unsubscribe();
+      }
+    };
+  } catch (err) {
+    moduleState.reservations.delete(reservation);
+    const now = deps.now();
+    const priorState = moduleState.perPath.get(path) ?? makeInitialAttemptState();
+    const failureDecision = decideAction(priorState, { kind: "subscribe_failure" }, now);
+    moduleState.perPath.set(path, failureDecision.state);
+    deps.log({
+      event: "file_watcher_subscribe_failed",
+      path,
+      err: err instanceof Error ? err.message : String(err)
+    });
+    emitSignals(path, failureDecision.signals);
+    if (failureDecision.state.circuitOpenedAt !== null) {
+      return makeStubSubscription();
+    }
+    throw err;
+  }
+}
+function pickOldest(entries, tier) {
+  let target = null;
+  for (const entry of entries) {
+    if (tier !== null && entry.tier !== tier) continue;
+    if (target === null || entry.lastUsedAt < target.lastUsedAt) target = entry;
+  }
+  return target;
+}
+function selectEvictionVictim(entries) {
+  const lazy = pickOldest(entries, "lazy");
+  if (lazy !== null) return { victim: lazy, evictingEssential: false };
+  const any = pickOldest(entries, null);
+  if (any !== null) return { victim: any, evictingEssential: true };
+  return null;
+}
+function evictOne(incomingPath) {
+  const { deps } = moduleState;
+  if (moduleState.active.size === 0) {
+    throw new Error("file-watcher-guard: cannot evict \u2014 active set is empty (counter is broken)");
+  }
+  const selection = selectEvictionVictim(moduleState.active);
+  if (selection === null) {
+    throw new Error("file-watcher-guard: eviction selection failed");
+  }
+  const { victim, evictingEssential } = selection;
+  moduleState.active.delete(victim);
+  deps.log({
+    event: evictingEssential ? "file_watcher_essential_evicted" : "file_watcher_evicted",
+    path: victim.path,
+    tier: victim.tier,
+    incomingPath
+  });
+  queueMicrotask(() => {
+    victim.consumerCallback(null, [{ type: "evicted", path: victim.path }]);
+  });
+  victim.unsubscribe().catch((err) => {
+    deps.log({
+      event: "file_watcher_unsubscribe_failed_during_eviction",
+      path: victim.path,
+      err: err instanceof Error ? err.message : String(err)
+    });
+  });
+  if (evictingEssential) {
+    scheduleEssentialResubscribe(victim);
+  }
+}
+function scheduleEssentialResubscribe(victim) {
+  const { deps } = moduleState;
+  deps.log({
+    event: "file_watcher_essential_re_subscribe_scheduled",
+    path: victim.path,
+    delayMs: ESSENTIAL_RESUBSCRIBE_DELAY_MS
+  });
+  deps.setTimeout(() => {
+    void retryEssentialSubscribe(victim);
+  }, ESSENTIAL_RESUBSCRIBE_DELAY_MS);
+}
+async function retryEssentialSubscribe(victim) {
+  const { deps } = moduleState;
+  try {
+    await guardedSubscribe(victim.path, victim.consumerCallback, {}, "essential", "rescan");
+    deps.log({ event: "file_watcher_essential_re_subscribed", path: victim.path });
+  } catch (err) {
+    deps.log({
+      event: "file_watcher_essential_re_subscribe_failed",
+      path: victim.path,
+      err: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function emitSignals(path, signals) {
+  const { deps } = moduleState;
+  for (const sig of signals) {
+    switch (sig.kind) {
+      case "circuit_opened":
+        deps.log({ event: "file_watcher_circuit_open", path });
+        moduleState.loggedOpenAt.set(path, deps.now());
+        break;
+      case "circuit_closed":
+        deps.log({ event: "file_watcher_circuit_closed", path });
+        moduleState.loggedOpenAt.delete(path);
+        break;
+      case "circuit_probe":
+        break;
+      default:
+        assertNever(sig);
+    }
+  }
+}
+function makeStubSubscription() {
+  return { unsubscribe: async () => {
+  } };
+}
+
+export {
+  createMetricsCollector,
+  makeInitialAttemptState,
+  decideAction,
+  configureFileWatcherGuard,
+  shutdownFileWatcherGuard,
+  guardedSubscribe
+};
+//# sourceMappingURL=chunk-3MNPDCO5.js.map