@ricsam/r5d-worker 0.0.137 → 0.0.139

package/dist/cjs/port-forward-client.cjs

@@ -1,206 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var port_forward_client_exports = {};
-__export(port_forward_client_exports, {
-  openWorkerPortForwardRelay: () => openWorkerPortForwardRelay
-});
-module.exports = __toCommonJS(port_forward_client_exports);
-var import_node_net = __toESM(require("node:net"), 1);
-var import_ws = __toESM(require("ws"), 1);
-const RELAY_FRAME_BYTES = 64 * 1024;
-const RELAY_PAUSE_BYTES = 1024 * 1024;
-const RELAY_RESUME_BYTES = 256 * 1024;
-const LOOPBACK_HOSTS = ["127.0.0.1", "::1"];
-function relayUrl(baseUrl, label, forwardId, relayConnectionId) {
-  const url = new URL("/worker/port-forward/ws", baseUrl);
-  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-  url.searchParams.set("label", label);
-  url.searchParams.set("forward", forwardId);
-  url.searchParams.set("connection", relayConnectionId);
-  return url.toString();
-}
-function loopbackAddress(host, port) {
-  return host.includes(":") ? `[${host}]:${port}` : `${host}:${port}`;
-}
-function rawDataBuffer(data) {
-  if (Buffer.isBuffer(data)) return data;
-  if (Array.isArray(data)) return Buffer.concat(data);
-  return Buffer.from(data);
-}
-function openWorkerPortForwardRelay(options) {
-  const relay = new import_ws.default(relayUrl(options.baseUrl, options.label, options.forwardId, options.relayConnectionId), {
-    headers: { Authorization: `Bearer ${options.token}` },
-    perMessageDeflate: false
-  });
-  let socket;
-  let relayReady = false;
-  let targetReady = false;
-  let targetEndRequested = false;
-  let targetFailure;
-  const pendingChunks = [];
-  let pendingBytes = 0;
-  const pendingWrites = [];
-  let pendingWriteBytes = 0;
-  let closing = false;
-  let resumeTimer;
-  const maybeResume = () => {
-    if (relayReady && targetReady && !resumeTimer) socket?.resume();
-  };
-  const cleanup = () => {
-    if (closing) return;
-    closing = true;
-    if (resumeTimer) clearInterval(resumeTimer);
-    socket?.destroy();
-    if (relay.readyState === import_ws.default.OPEN || relay.readyState === import_ws.default.CONNECTING) relay.close();
-  };
-  const sendError = (message) => {
-    if (closing) return;
-    const payload = JSON.stringify({ type: "error", error: message });
-    if (relay.readyState === import_ws.default.CONNECTING) {
-      closing = true;
-      if (resumeTimer) clearInterval(resumeTimer);
-      socket?.destroy();
-      relay.once("open", () => {
-        relay.send(payload);
-        relay.close();
-      });
-      return;
-    }
-    if (relay.readyState === import_ws.default.OPEN) relay.send(payload);
-    cleanup();
-  };
-  const waitForRelayDrain = () => {
-    if (resumeTimer || relay.bufferedAmount <= RELAY_PAUSE_BYTES) return;
-    socket?.pause();
-    resumeTimer = setInterval(() => {
-      if (relay.readyState !== import_ws.default.OPEN) return cleanup();
-      if (relay.bufferedAmount > RELAY_RESUME_BYTES) return;
-      clearInterval(resumeTimer);
-      resumeTimer = void 0;
-      maybeResume();
-    }, 10);
-  };
-  const sendChunk = (chunk) => {
-    for (let offset = 0; offset < chunk.byteLength; offset += RELAY_FRAME_BYTES) {
-      relay.send(chunk.subarray(offset, Math.min(chunk.byteLength, offset + RELAY_FRAME_BYTES)), { binary: true });
-    }
-    waitForRelayDrain();
-  };
-  const adoptTarget = (target, host) => {
-    if (closing) return target.destroy();
-    socket = target;
-    target.on("data", (chunk) => {
-      if (!relayReady || relay.readyState !== import_ws.default.OPEN) {
-        pendingBytes += chunk.byteLength;
-        if (pendingBytes > RELAY_PAUSE_BYTES) return cleanup();
-        pendingChunks.push(Buffer.from(chunk));
-        target.pause();
-        return;
-      }
-      sendChunk(chunk);
-    });
-    target.on("end", () => {
-      if (relay.readyState === import_ws.default.OPEN) relay.send(JSON.stringify({ type: "end" }));
-    });
-    target.on("error", (error) => sendError(`Connection to ${loopbackAddress(host, options.workerPort)} failed: ${error.message}`));
-    target.on("close", cleanup);
-    target.pause();
-    targetReady = true;
-    for (const chunk of pendingWrites.splice(0)) target.write(chunk);
-    pendingWriteBytes = 0;
-    if (targetFailure) return void target.destroy(targetFailure);
-    if (targetEndRequested) target.end();
-    maybeResume();
-  };
-  const dialFailures = [];
-  const dialTarget = (host, fallbackHosts2) => {
-    if (closing) return;
-    const candidate = import_node_net.default.createConnection({ host, port: options.workerPort, allowHalfOpen: true });
-    candidate.pause();
-    candidate.setNoDelay(true);
-    const onDialError = (error) => {
-      candidate.destroy();
-      dialFailures.push(`${loopbackAddress(host, options.workerPort)} (${error.code ?? error.message})`);
-      const [nextHost, ...rest] = fallbackHosts2;
-      if (nextHost) return dialTarget(nextHost, rest);
-      sendError(
-        `Could not connect to ${dialFailures.join(" or ")} on the worker. Nothing is listening on either loopback address for port ${options.workerPort} \u2014 make sure the server is running and bound to a loopback or wildcard host.`
-      );
-    };
-    candidate.once("error", onDialError);
-    candidate.once("connect", () => {
-      candidate.off("error", onDialError);
-      adoptTarget(candidate, host);
-    });
-  };
-  relay.on("message", (data, isBinary) => {
-    if (!isBinary) {
-      let control;
-      try {
-        control = JSON.parse(rawDataBuffer(data).toString("utf8"));
-      } catch {
-        return cleanup();
-      }
-      if (control.type === "ready") {
-        relayReady = true;
-        for (const chunk2 of pendingChunks.splice(0)) sendChunk(chunk2);
-        pendingBytes = 0;
-        maybeResume();
-      } else if (control.type === "end") {
-        if (socket) socket.end();
-        else targetEndRequested = true;
-      } else if (control.type === "error") {
-        const failure = new Error(control.error || "Port-forward relay failed.");
-        if (socket) socket.destroy(failure);
-        else targetFailure = failure;
-      }
-      return;
-    }
-    const chunk = rawDataBuffer(data);
-    if (!socket) {
-      pendingWriteBytes += chunk.byteLength;
-      if (pendingWriteBytes > RELAY_PAUSE_BYTES) return cleanup();
-      pendingWrites.push(Buffer.from(chunk));
-      return;
-    }
-    const target = socket;
-    if (!target.write(chunk)) {
-      relay.pause();
-      target.once("drain", () => relay.resume());
-    }
-  });
-  relay.on("error", cleanup);
-  relay.once("close", cleanup);
-  const [primaryHost, ...fallbackHosts] = LOOPBACK_HOSTS;
-  dialTarget(primaryHost, fallbackHosts);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  openWorkerPortForwardRelay
-});

package/dist/cjs/process-tree.cjs

@@ -1,117 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var process_tree_exports = {};
-__export(process_tree_exports, {
-  terminateProcessTree: () => terminateProcessTree
-});
-module.exports = __toCommonJS(process_tree_exports);
-const DEFAULT_TERMINATION_GRACE_MS = 2e3;
-const DEFAULT_FORCE_KILL_WAIT_MS = 2e3;
-const PROCESS_GROUP_POLL_INTERVAL_MS = 25;
-const processTerminations = /* @__PURE__ */ new WeakMap();
-function errorCode(error) {
-  if (!error || typeof error !== "object" || !("code" in error)) {
-    return void 0;
-  }
-  return typeof error.code === "string" ? error.code : void 0;
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function isPosixProcessGroupRunning(processGroupId) {
-  try {
-    process.kill(-processGroupId, 0);
-    return true;
-  } catch (error) {
-    if (errorCode(error) === "ESRCH") {
-      return false;
-    }
-    if (errorCode(error) === "EPERM") {
-      return true;
-    }
-    throw error;
-  }
-}
-function signalPosixProcessGroup(processGroupId, signal) {
-  try {
-    process.kill(-processGroupId, signal);
-  } catch (error) {
-    if (errorCode(error) !== "ESRCH") {
-      throw error;
-    }
-  }
-}
-async function waitForPosixProcessGroupExit(processGroupId, timeoutMs) {
-  const deadline = Date.now() + Math.max(0, timeoutMs);
-  while (isPosixProcessGroupRunning(processGroupId)) {
-    const remainingMs = deadline - Date.now();
-    if (remainingMs <= 0) {
-      return false;
-    }
-    await delay(Math.min(PROCESS_GROUP_POLL_INTERVAL_MS, remainingMs));
-  }
-  return true;
-}
-async function runWindowsTaskkill(pid) {
-  const taskkill = Bun.spawn(["taskkill", "/PID", String(pid), "/T", "/F"], {
-    stdout: "ignore",
-    stderr: "pipe"
-  });
-  const [exitCode, stderr] = await Promise.all([
-    taskkill.exited,
-    taskkill.stderr ? new Response(taskkill.stderr).text() : Promise.resolve("")
-  ]);
-  if (exitCode !== 0 && !/not found|no running instance/i.test(stderr)) {
-    throw new Error(`Failed to terminate process tree ${pid}: ${stderr.trim() || `taskkill exited ${exitCode}`}`);
-  }
-}
-async function terminateProcessTreeOnce(subprocess, options) {
-  if (!Number.isSafeInteger(subprocess.pid) || subprocess.pid <= 0) {
-    throw new Error(`Cannot terminate invalid subprocess PID: ${subprocess.pid}`);
-  }
-  if (process.platform === "win32") {
-    await runWindowsTaskkill(subprocess.pid);
-    return;
-  }
-  const graceMs = options.graceMs ?? DEFAULT_TERMINATION_GRACE_MS;
-  const forceKillWaitMs = options.forceKillWaitMs ?? DEFAULT_FORCE_KILL_WAIT_MS;
-  signalPosixProcessGroup(subprocess.pid, "SIGTERM");
-  if (await waitForPosixProcessGroupExit(subprocess.pid, graceMs)) {
-    return;
-  }
-  signalPosixProcessGroup(subprocess.pid, "SIGKILL");
-  if (!await waitForPosixProcessGroupExit(subprocess.pid, forceKillWaitMs)) {
-    throw new Error(`Process group ${subprocess.pid} remained active after SIGKILL`);
-  }
-}
-function terminateProcessTree(subprocess, options = {}) {
-  const pending = processTerminations.get(subprocess);
-  if (pending) {
-    return pending;
-  }
-  const termination = terminateProcessTreeOnce(subprocess, options).finally(() => {
-    processTerminations.delete(subprocess);
-  });
-  processTerminations.set(subprocess, termination);
-  return termination;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  terminateProcessTree
-});

package/dist/cjs/project-checkout-garbage.cjs

@@ -1,219 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var project_checkout_garbage_exports = {};
-__export(project_checkout_garbage_exports, {
-  PROJECT_DELETED_CHECKOUTS_DIRECTORY: () => PROJECT_DELETED_CHECKOUTS_DIRECTORY,
-  ProjectCheckoutGarbageCollector: () => ProjectCheckoutGarbageCollector,
-  discoverStagedProjectCheckouts: () => discoverStagedProjectCheckouts,
-  isStagedProjectCheckoutPath: () => isStagedProjectCheckoutPath,
-  ownedStagedPath: () => ownedStagedPath,
-  removeStagedProjectCheckout: () => removeStagedProjectCheckout,
-  stageProjectCheckoutForDeletion: () => stageProjectCheckoutForDeletion,
-  stageProjectForDeletion: () => stageProjectForDeletion
-});
-module.exports = __toCommonJS(project_checkout_garbage_exports);
-var import_node_crypto = require("node:crypto");
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-const PROJECT_DELETED_CHECKOUTS_DIRECTORY = ".r5d-deleted";
-function isRealDirectory(candidate) {
-  try {
-    return import_node_fs.default.lstatSync(candidate).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function stageProjectCheckoutForDeletion(projectRoot, branchName, checkoutPath) {
-  const garbageRoot = import_node_path.default.join(projectRoot, PROJECT_DELETED_CHECKOUTS_DIRECTORY);
-  if (!isRealDirectory(checkoutPath)) throw new Error(`Cannot stage ${checkoutPath} for deletion: not a directory`);
-  import_node_fs.default.mkdirSync(garbageRoot, { recursive: true });
-  if (!isRealDirectory(garbageRoot)) throw new Error(`Cannot stage ${checkoutPath} for deletion: ${garbageRoot} is not a directory`);
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const target = import_node_path.default.join(garbageRoot, `${branchName.replace(/\//g, "__")}-${timestamp}-${(0, import_node_crypto.randomUUID)().slice(0, 8)}`);
-  import_node_fs.default.renameSync(checkoutPath, target);
-  return target;
-}
-function stageProjectForDeletion(projectsRoot, projectRoot) {
-  const root = import_node_path.default.resolve(projectsRoot);
-  const resolved = import_node_path.default.resolve(projectRoot);
-  const relative = import_node_path.default.relative(root, resolved);
-  const segments = relative.split(import_node_path.default.sep);
-  if (!relative || relative.startsWith("..") || import_node_path.default.isAbsolute(relative) || segments.length !== 2 || segments.some((segment) => !segment || segment.startsWith("."))) {
-    throw new Error(`Cannot stage ${projectRoot} for deletion: not a project root under ${projectsRoot}`);
-  }
-  if (!isRealDirectory(resolved)) throw new Error(`Cannot stage ${projectRoot} for deletion: not a directory`);
-  const garbageRoot = import_node_path.default.join(root, segments[0], PROJECT_DELETED_CHECKOUTS_DIRECTORY);
-  import_node_fs.default.mkdirSync(garbageRoot, { recursive: true });
-  if (!isRealDirectory(garbageRoot)) throw new Error(`Cannot stage ${projectRoot} for deletion: ${garbageRoot} is not a directory`);
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const target = import_node_path.default.join(garbageRoot, `${segments[1]}-${timestamp}-${(0, import_node_crypto.randomUUID)().slice(0, 8)}`);
-  import_node_fs.default.renameSync(resolved, target);
-  return target;
-}
-function isStagedProjectCheckoutPath(projectsRoot, candidate) {
-  const relative = import_node_path.default.relative(import_node_path.default.resolve(projectsRoot), import_node_path.default.resolve(candidate));
-  if (!relative || relative.startsWith("..") || import_node_path.default.isAbsolute(relative)) return false;
-  const segments = relative.split(import_node_path.default.sep);
-  const entry = segments[segments.length - 1];
-  if (!entry || entry.startsWith(".")) return false;
-  if (segments.length === 4)
-    return segments[2] === PROJECT_DELETED_CHECKOUTS_DIRECTORY && !segments[0].startsWith(".") && !segments[1].startsWith(".");
-  if (segments.length === 3) return segments[1] === PROJECT_DELETED_CHECKOUTS_DIRECTORY && !segments[0].startsWith(".");
-  return false;
-}
-function ownedStagedPath(projectsRoot, candidate) {
-  const root = import_node_path.default.resolve(projectsRoot);
-  const resolved = import_node_path.default.resolve(candidate);
-  if (!isStagedProjectCheckoutPath(root, resolved)) return null;
-  let current = root;
-  for (const segment of import_node_path.default.relative(root, import_node_path.default.dirname(resolved)).split(import_node_path.default.sep)) {
-    current = import_node_path.default.join(current, segment);
-    if (!isRealDirectory(current)) return null;
-  }
-  let stat;
-  try {
-    stat = import_node_fs.default.lstatSync(resolved);
-  } catch {
-    return null;
-  }
-  if (stat.isSymbolicLink()) return { kind: "link" };
-  return stat.isDirectory() ? { kind: "directory" } : null;
-}
-function realDirectoryEntries(directory) {
-  if (!isRealDirectory(directory)) return [];
-  try {
-    return import_node_fs.default.readdirSync(directory, { withFileTypes: true }).map((entry) => entry.name).sort();
-  } catch {
-    return [];
-  }
-}
-function discoverStagedProjectCheckouts(projectsRoot) {
-  const root = import_node_path.default.resolve(projectsRoot);
-  const staged = [];
-  for (const namespace of realDirectoryEntries(root)) {
-    if (namespace.startsWith(".")) continue;
-    const namespaceGarbageRoot = import_node_path.default.join(root, namespace, PROJECT_DELETED_CHECKOUTS_DIRECTORY);
-    for (const entry of realDirectoryEntries(namespaceGarbageRoot)) {
-      const candidate = import_node_path.default.join(namespaceGarbageRoot, entry);
-      if (ownedStagedPath(root, candidate)) staged.push(candidate);
-    }
-    for (const project of realDirectoryEntries(import_node_path.default.join(root, namespace))) {
-      if (project.startsWith(".")) continue;
-      const garbageRoot = import_node_path.default.join(root, namespace, project, PROJECT_DELETED_CHECKOUTS_DIRECTORY);
-      for (const entry of realDirectoryEntries(garbageRoot)) {
-        const candidate = import_node_path.default.join(garbageRoot, entry);
-        if (ownedStagedPath(root, candidate)) staged.push(candidate);
-      }
-    }
-  }
-  return staged;
-}
-async function removeStagedProjectCheckout(stagedPath) {
-  if (import_node_fs.default.lstatSync(stagedPath).isSymbolicLink()) {
-    import_node_fs.default.unlinkSync(stagedPath);
-    return;
-  }
-  if (process.platform === "win32") {
-    await import_node_fs.default.promises.rm(stagedPath, { recursive: true, force: true });
-    return;
-  }
-  const command = ["rm", "-rf", "--", stagedPath];
-  if (Bun.which("nice")) command.unshift("nice", "-n", "19");
-  if (process.platform === "linux" && Bun.which("ionice")) command.unshift("ionice", "-c", "3");
-  const child = Bun.spawn(command, { stdin: "ignore", stdout: "ignore", stderr: "pipe" });
-  const [exitCode, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
-  if (exitCode !== 0) throw new Error(`rm exited ${exitCode}: ${stderr.trim()}`);
-  if (import_node_fs.default.existsSync(stagedPath)) throw new Error("staged checkout still exists after removal");
-}
-class ProjectCheckoutGarbageCollector {
-  projectsRoot;
-  remove;
-  log;
-  queued = /* @__PURE__ */ new Set();
-  tail = Promise.resolve();
-  collectedCount = 0;
-  constructor(options) {
-    this.projectsRoot = import_node_path.default.resolve(options.projectsRoot);
-    this.remove = options.remove ?? removeStagedProjectCheckout;
-    this.log = options.log ?? ((message) => process.stderr.write(`${message}
-`));
-  }
-  /** Number of removals that have completed successfully. */
-  get collected() {
-    return this.collectedCount;
-  }
-  /** Resolves once everything queued so far has been attempted. */
-  get idle() {
-    return this.tail;
-  }
-  enqueue(stagedPath) {
-    const resolved = import_node_path.default.resolve(stagedPath);
-    if (!ownedStagedPath(this.projectsRoot, resolved)) {
-      throw new Error(`Refusing to collect ${stagedPath}: not a staged checkout under ${this.projectsRoot}`);
-    }
-    if (this.queued.has(resolved)) return;
-    this.queued.add(resolved);
-    this.tail = this.tail.then(async () => {
-      try {
-        const owned = ownedStagedPath(this.projectsRoot, resolved);
-        if (owned) {
-          const startedAt = performance.now();
-          await this.remove(resolved);
-          this.collectedCount += 1;
-          this.log(`[r5d-worker] collected deleted checkout ${resolved} in ${Math.round(performance.now() - startedAt)}ms`);
-        } else if (import_node_fs.default.existsSync(resolved) || isRealDirectory(import_node_path.default.dirname(resolved))) {
-          this.log(`[r5d-worker] skipped deleted checkout ${resolved}: no longer an owned staged checkout`);
-        }
-      } catch (error) {
-        this.log(
-          `[r5d-worker] deleted checkout ${resolved} could not be collected yet: ${error instanceof Error ? error.message : String(error)}`
-        );
-      } finally {
-        this.queued.delete(resolved);
-      }
-    });
-  }
-  /** Enqueue every staged checkout left behind by an earlier process. */
-  sweep() {
-    const staged = discoverStagedProjectCheckouts(this.projectsRoot);
-    for (const stagedPath of staged) this.enqueue(stagedPath);
-    return staged.length;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PROJECT_DELETED_CHECKOUTS_DIRECTORY,
-  ProjectCheckoutGarbageCollector,
-  discoverStagedProjectCheckouts,
-  isStagedProjectCheckoutPath,
-  ownedStagedPath,
-  removeStagedProjectCheckout,
-  stageProjectCheckoutForDeletion,
-  stageProjectForDeletion
-});

package/dist/cjs/project-mirror-fetch-policy.cjs

@@ -1,82 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var project_mirror_fetch_policy_exports = {};
-__export(project_mirror_fetch_policy_exports, {
-  parseProjectMirrorRefsTokensMessage: () => parseProjectMirrorRefsTokensMessage,
-  planProjectMirrorObservationFetch: () => planProjectMirrorObservationFetch,
-  projectMirrorFetchDecision: () => projectMirrorFetchDecision
-});
-module.exports = __toCommonJS(project_mirror_fetch_policy_exports);
-function projectMirrorFetchDecision(input) {
-  if (!input.skippingEnabled) return { fetch: true, reason: "skipping_disabled" };
-  if (input.advertisedToken === void 0) return { fetch: true, reason: "no_advertised_token" };
-  if (input.fetchedToken === void 0) return { fetch: true, reason: "never_fetched" };
-  if (input.advertisedToken !== input.fetchedToken) return { fetch: true, reason: "token_changed" };
-  return { fetch: false, reason: "token_match" };
-}
-function planProjectMirrorObservationFetch(input) {
-  if (!input.skippingEnabled) return { scope: "project", reason: "skipping_disabled" };
-  if (input.advertisedMountTokens === void 0) {
-    const decision = projectMirrorFetchDecision({
-      advertisedToken: input.advertisedProjectToken,
-      fetchedToken: input.fetchedProjectToken,
-      skippingEnabled: true
-    });
-    return decision.fetch ? { scope: "project", reason: decision.reason } : { scope: "none" };
-  }
-  const mounts = [];
-  for (const branchName of [...input.branchNames].sort()) {
-    const decision = projectMirrorFetchDecision({
-      advertisedToken: input.advertisedMountTokens.get(branchName),
-      fetchedToken: input.fetchedMountTokens.get(branchName),
-      skippingEnabled: true
-    });
-    if (decision.fetch) mounts.push({ branchName, reason: decision.reason });
-  }
-  return mounts.length === 0 ? { scope: "none" } : { scope: "mounts", mounts };
-}
-const TOKEN_RE = /^[0-9a-f]{64}$/;
-const GIT_OBJECT_NAME_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
-function parseProjectMirrorRefsTokensMessage(message) {
-  const projectTokens = /* @__PURE__ */ new Map();
-  if (message.tokens && typeof message.tokens === "object") {
-    for (const [projectId, token] of Object.entries(message.tokens)) {
-      if (typeof token === "string" && TOKEN_RE.test(token)) projectTokens.set(projectId, token);
-    }
-  }
-  const mountTokens = /* @__PURE__ */ new Map();
-  if (message.mountTokens && typeof message.mountTokens === "object") {
-    for (const [projectId, tokensByBranch] of Object.entries(message.mountTokens)) {
-      if (!tokensByBranch || typeof tokensByBranch !== "object") continue;
-      const perMount = /* @__PURE__ */ new Map();
-      for (const [branchName, token] of Object.entries(tokensByBranch)) {
-        if (typeof token === "string" && TOKEN_RE.test(token)) perMount.set(branchName, token);
-      }
-      mountTokens.set(projectId, perMount);
-    }
-  }
-  const workspaceHead = typeof message.workspaceHead === "string" && GIT_OBJECT_NAME_RE.test(message.workspaceHead) ? message.workspaceHead : void 0;
-  return { projectTokens, mountTokens, workspaceHead };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  parseProjectMirrorRefsTokensMessage,
-  planProjectMirrorObservationFetch,
-  projectMirrorFetchDecision
-});