@schoolai/shipyard 3.7.0 → 3.8.0-rc.20260529.0

package/dist/{chunk-3MNPDCO5.js → chunk-WBB4XHLH.js}

@@ -1,9 +1,14 @@
 #!/usr/bin/env node
 import {
-  assertNever,
-  decodeLine,
-  encodeLine
-} from "./chunk-SNYEQHUK.js";
+  WorkerCommandCodec,
+  WorkerReplyCodec
+} from "./chunk-NACJENDW.js";
+import {
+  createServiceSupervisor
+} from "./chunk-ZFKJAYAN.js";
+import {
+  assertNever
+} from "./chunk-X3MULCV5.js";
 
 // src/services/metrics/metrics-collector.ts
 var NOOP_METRICS = {
@@ -73,6 +78,8 @@ function createMetricsCollector(workerUrl, authToken, telemetryEnabled) {
 
 // src/shared/file-watcher-guard.ts
 import { fork as childProcessFork } from "child_process";
+import { existsSync } from "fs";
+import { dirname } from "path";
 
 // src/services/watcher-worker/worker-supervisor.ts
 import { randomUUID } from "crypto";
@@ -81,34 +88,72 @@ 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 liveGeneration = 0;
+  let lastSpawnedAt = 0;
+  let lastPid = null;
   let shutdownInitiated = false;
   let restartTimer = null;
   let pendingRespawnGeneration = null;
+  let nextReplayStartedAt = 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) {
+  const adaptedFork = (modulePath, args, options) => {
+    return deps.fork(modulePath, Array.from(args), options);
+  };
+  const supervisor = createServiceSupervisor({
+    fork: adaptedFork,
+    workerPath: deps.workerPath,
+    commandCodec: WorkerCommandCodec,
+    replyCodec: WorkerReplyCodec,
+    onReply: (reply, fromGeneration) => dispatchReply(reply, fromGeneration),
+    onChildSpawned: ({ generation, pid }) => {
+      liveGeneration = generation;
+      lastPid = pid;
+      lastSpawnedAt = deps.now();
+      log({ event: "watcher_worker_started", pid });
+      captureMetric("watcher_worker_started", { pid });
+    },
+    onChildExit: ({ code, signal, generation, uptimeMs }) => {
+      handleChildExit(generation, code, signal, uptimeMs);
+    },
+    onDecodeFailed: ({ line }) => log({ event: "watcher_worker_decode_failed", line }),
+    onStderrLine: (line) => {
+      if (!line.trim()) return;
+      log({ event: "watcher_worker_stderr", line });
+    },
+    onMissingStdout: () => log({ event: "watcher_worker_no_stdout" }),
+    onOverflow: ({ stream, bytes, maxBytes }) => log({ event: "watcher_worker_stdio_overflow", stream, bytes, maxBytes }),
+    onPeerError: (err) => log({ event: "watcher_worker_error", err: err.message }),
+    log,
+    now: deps.now
+    /** Watcher uses its own file-watcher-guard circuit; opt out of the primitive's. */
+  });
+  function sendCommand(cmd) {
+    const sent = supervisor.send(cmd);
+    if (!sent && supervisor.getCurrentProcess() !== null) {
       log({
         event: "watcher_worker_stdin_write_failed",
-        err: err instanceof Error ? err.message : String(err)
+        err: "stdio peer send returned false"
       });
-      return false;
     }
+    return sent;
   }
   function dispatchReply(reply, fromGeneration) {
+    if (fromGeneration !== liveGeneration) {
+      log({
+        event: "watcher_worker_stale_reply_dropped",
+        replyType: reply.type,
+        id: reply.id,
+        generation: fromGeneration,
+        liveGeneration
+      });
+      return;
+    }
     switch (reply.type) {
       case "subscribed":
         handleSubscribedReply(reply.id, fromGeneration);
@@ -165,68 +210,11 @@ function createWatcherWorkerSupervisor(deps) {
     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) {
+  function handleChildExit(generation, code, signal, uptimeMs) {
+    if (pendingRespawnGeneration === 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;
@@ -243,11 +231,11 @@ function createWatcherWorkerSupervisor(deps) {
       replayCount,
       uptimeMs
     });
-    recordRestartFailure(holder);
+    recordRestartFailure(uptimeMs);
     fireSyntheticEvictionToAll();
     scheduleRespawn();
   }
-  function recordRestartFailure(holder) {
+  function recordRestartFailure(uptimeMs) {
     const failureDecision = decideAction(restartState, { kind: "subscribe_failure" }, deps.now());
     restartState = failureDecision.state;
     for (const sig of failureDecision.signals) {
@@ -255,7 +243,7 @@ function createWatcherWorkerSupervisor(deps) {
         log({ event: "watcher_worker_circuit_open" });
         captureMetric("watcher_worker_circuit_open", {
           deathCount: restartState.failureCount,
-          windowMs: deps.now() - holder.spawnedAt
+          windowMs: uptimeMs
         });
       } else if (sig.kind === "circuit_closed") {
         log({ event: "watcher_worker_circuit_closed" });
@@ -342,45 +330,37 @@ function createWatcherWorkerSupervisor(deps) {
     }
   }
   function forkAndReplay() {
-    const isRespawn = nextGeneration > 1;
-    const replayStart = deps.now();
-    const holder = spawnChildHolder();
-    if (isRespawn && subscriptions.size > 0) {
-      pendingRespawnGeneration = holder.generation;
+    const isRespawn = liveGeneration >= 1;
+    nextReplayStartedAt = deps.now();
+    const shouldMarkPendingRespawn = isRespawn && subscriptions.size > 0;
+    if (liveGeneration === 0) {
+      supervisor.start();
+    } else {
+      supervisor.restart();
     }
-    const replayResult = replaySubscriptions(holder);
+    if (shouldMarkPendingRespawn) {
+      pendingRespawnGeneration = liveGeneration;
+    }
+    const replayResult = replaySubscriptions();
     if (replayResult.kind === "pipe_failed") {
-      handleReplayPipeFailure(holder, replayResult.replayedCount);
+      handleReplayPipeFailure(replayResult.replayedCount);
       return;
     }
     if (replayResult.replayedCount > 0) {
       log({ event: "watcher_worker_replayed", replayCount: replayResult.replayedCount });
     }
     if (isRespawn) {
-      recordRespawnTelemetry(holder, replayResult.replayedCount, deps.now() - replayStart);
+      recordRespawnTelemetry(
+        replayResult.replayedCount,
+        deps.now() - (nextReplayStartedAt ?? deps.now())
+      );
     }
   }
-  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) {
+  function replaySubscriptions() {
     let replayedCount = 0;
     for (const entry of subscriptions.values()) {
       entry.status = "pending";
-      const ok = sendCommand(holder, {
+      const ok = sendCommand({
         cmd: "subscribe",
         id: entry.id,
         path: entry.path,
@@ -393,17 +373,18 @@ function createWatcherWorkerSupervisor(deps) {
     }
     return { kind: "completed", replayedCount };
   }
-  function handleReplayPipeFailure(holder, replayedCount) {
+  function handleReplayPipeFailure(replayedCount) {
     log({
       event: "watcher_worker_replay_pipe_failed",
-      pid: holder.process.pid ?? null,
+      pid: lastPid,
       replayedCount,
       pendingCount: subscriptions.size - replayedCount
     });
-    recordRestartFailure(holder);
-    if (!holder.exited) {
+    recordRestartFailure(deps.now() - lastSpawnedAt);
+    const proc = supervisor.getCurrentProcess();
+    if (proc !== null) {
       try {
-        holder.process.kill("SIGKILL");
+        proc.kill("SIGKILL");
       } catch (err) {
         log({
           event: "watcher_worker_kill_failed",
@@ -414,15 +395,15 @@ function createWatcherWorkerSupervisor(deps) {
     }
     scheduleRespawn();
   }
-  function recordRespawnTelemetry(holder, replayCount, replayDurationMs) {
+  function recordRespawnTelemetry(replayCount, replayDurationMs) {
     log({
       event: "watcher_worker_respawned",
-      pid: holder.process.pid ?? null,
+      pid: lastPid,
       replayCount,
       replayDurationMs
     });
     captureMetric("watcher_worker_respawned", {
-      newPid: holder.process.pid ?? null,
+      newPid: lastPid,
       replayCount,
       replayDurationMs
     });
@@ -435,13 +416,13 @@ function createWatcherWorkerSupervisor(deps) {
   function unsubscribeEntry(entry) {
     if (!subscriptions.has(entry.id)) return Promise.resolve();
     entry.status = "unsubscribing";
-    if (!child) {
+    if (supervisor.getCurrentProcess() === null) {
       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 });
+      const sent = sendCommand({ cmd: "unsubscribe", id: entry.id });
       if (!sent) {
         subscriptions.delete(entry.id);
         resolve();
@@ -453,7 +434,7 @@ function createWatcherWorkerSupervisor(deps) {
     } };
   }
   async function start() {
-    if (child !== null) return;
+    if (supervisor.getCurrentProcess() !== null) return;
     if (shutdownInitiated) {
       throw new Error("WatcherWorkerSupervisor: cannot start after shutdown");
     }
@@ -483,10 +464,10 @@ function createWatcherWorkerSupervisor(deps) {
       entry.rejectSubscribed = reject;
     });
     subscriptions.set(id, entry);
-    if (child === null) {
+    if (supervisor.getCurrentProcess() === null) {
       await start();
     } else {
-      sendCommand(child, { cmd: "subscribe", id, path, opts });
+      sendCommand({ cmd: "subscribe", id, path, opts });
     }
     return promise;
   }
@@ -505,17 +486,18 @@ function createWatcherWorkerSupervisor(deps) {
       entry.resolveUnsubscribed = void 0;
     }
     subscriptions.clear();
-    const holder = child;
-    if (holder === null) return;
-    sendCommand(holder, { cmd: "shutdown" });
-    await escalateShutdown(holder);
+    const proc = supervisor.getCurrentProcess();
+    supervisor.dispose();
+    if (proc === null) return;
+    sendCommand({ cmd: "shutdown" });
+    await escalateShutdown(proc);
   }
-  function killWithSignal(holder, signal) {
+  function killWithSignal(proc, signal) {
     log({
       event: signal === "SIGTERM" ? "watcher_worker_shutdown_sigterm" : "watcher_worker_shutdown_sigkill"
     });
     try {
-      holder.process.kill(signal);
+      proc.kill(signal);
     } catch (err) {
       log({
         event: "watcher_worker_kill_failed",
@@ -524,30 +506,29 @@ function createWatcherWorkerSupervisor(deps) {
       });
     }
   }
-  function escalateShutdown(holder) {
+  function escalateShutdown(proc) {
     return new Promise((resolve) => {
-      const ctx = { done: false };
+      const ctx = { done: false, exited: false };
       const finish = () => {
         if (ctx.done) return;
         ctx.done = true;
         resolve();
       };
-      holder.process.once("exit", finish);
-      if (holder.exited) {
+      proc.once("exit", () => {
+        ctx.exited = true;
         finish();
-        return;
-      }
-      deps.setTimeout(() => onSigtermDeadline(holder, ctx, finish), SHUTDOWN_GRACEFUL_MS);
+      });
+      deps.setTimeout(() => onSigtermDeadline(proc, 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 onSigtermDeadline(proc, ctx, finish) {
+    if (ctx.done || ctx.exited) return;
+    killWithSignal(proc, "SIGTERM");
+    deps.setTimeout(() => onSigkillDeadline(proc, ctx, finish), SHUTDOWN_SIGTERM_MS);
   }
-  function onSigkillDeadline(holder, ctx, finish) {
-    if (ctx.done || holder.exited) return;
-    killWithSignal(holder, "SIGKILL");
+  function onSigkillDeadline(proc, ctx, finish) {
+    if (ctx.done || ctx.exited) return;
+    killWithSignal(proc, "SIGKILL");
     finish();
   }
   return { start, subscribe, shutdown };
@@ -777,7 +758,9 @@ function toGuardedEvent(e) {
 }
 function ensureSupervisor() {
   if (moduleState.supervisor) return moduleState.supervisor;
-  const workerPath = new URL("./worker.js", import.meta.url).pathname;
+  const selfUrl = import.meta.url;
+  const isDevMode = selfUrl.endsWith(".ts");
+  const workerPath = isDevMode ? new URL("../services/watcher-worker/worker.ts", selfUrl).pathname : new URL("./worker.js", selfUrl).pathname;
   moduleState.supervisor = createWatcherWorkerSupervisor({
     fork: nodeFork,
     workerPath,
@@ -894,10 +877,19 @@ async function performSubscribe(path, consumerCallback, opts, tier) {
     const priorState = moduleState.perPath.get(path) ?? makeInitialAttemptState();
     const failureDecision = decideAction(priorState, { kind: "subscribe_failure" }, now);
     moduleState.perPath.set(path, failureDecision.state);
+    const parentExists = pathExistsForLog(dirname(path));
     deps.log({
       event: "file_watcher_subscribe_failed",
       path,
-      err: err instanceof Error ? err.message : String(err)
+      pathExists: pathExistsForLog(path),
+      parentExists,
+      err: err instanceof Error ? err.message : String(err),
+      /**
+       * The expected-ENOENT fallback path (file doesn't exist yet but
+       * parent does) is a normal poll cycle, not a failure. Downgrade
+       * the log level so log triage doesn't flag 40+ of these per task.
+       */
+      ...parentExists ? { level: "debug" } : {}
     });
     emitSignals(path, failureDecision.signals);
     if (failureDecision.state.circuitOpenedAt !== null) {
@@ -906,6 +898,13 @@ async function performSubscribe(path, consumerCallback, opts, tier) {
     throw err;
   }
 }
+function pathExistsForLog(path) {
+  try {
+    return existsSync(path);
+  } catch {
+    return false;
+  }
+}
 function pickOldest(entries, tier) {
   let target = null;
   for (const entry of entries) {
@@ -1008,4 +1007,4 @@ export {
   shutdownFileWatcherGuard,
   guardedSubscribe
 };
-//# sourceMappingURL=chunk-3MNPDCO5.js.map
+//# sourceMappingURL=chunk-WBB4XHLH.js.map