@ricsam/r5d-worker 0.0.136 → 0.0.138

package/dist/mjs/plan-parser.mjs

@@ -1,94 +0,0 @@
-const PLAN_TASK_ID_REGEX = /^[a-z0-9][a-z0-9-]*$/;
-const PLAN_TASK_LINE_REGEX = /^- \[( |x)\] ([a-z0-9][a-z0-9-]*): (.+)$/;
-const PLAN_TASKS_HEADING_REGEX = /^## Tasks\s*$/;
-function getPlanMetadata(content) {
-  const title = content.split(/\r?\n/).map((line) => line.match(/^# (.+)$/)?.[1]?.trim()).find((value) => Boolean(value));
-  return { title: title || "Untitled Plan" };
-}
-function getTasksSectionRange(content) {
-  const lines = content.split(/\r?\n/);
-  const startIndex = lines.findIndex((line) => PLAN_TASKS_HEADING_REGEX.test(line));
-  if (startIndex === -1) return null;
-  let endIndex = lines.length;
-  for (let index = startIndex + 1; index < lines.length; index += 1) {
-    if (/^##\s+/.test(lines[index] ?? "")) {
-      endIndex = index;
-      break;
-    }
-  }
-  return { startIndex, endIndex };
-}
-function parseMarkdownPlan(content, planId) {
-  const lines = content.split(/\r?\n/);
-  const { title } = getPlanMetadata(content);
-  const range = getTasksSectionRange(content);
-  const tasks = [];
-  if (range) {
-    for (let index = range.startIndex + 1; index < range.endIndex; index += 1) {
-      const line = lines[index] ?? "";
-      const match = line.match(PLAN_TASK_LINE_REGEX);
-      if (!match) continue;
-      const description = match[3].trim();
-      if (!description) continue;
-      tasks.push({
-        id: match[2],
-        description,
-        checked: match[1] === "x",
-        lineNumber: index + 1
-      });
-    }
-  }
-  const currentTask = tasks.find((task) => !task.checked) ?? null;
-  return {
-    id: planId,
-    title,
-    content,
-    tasks,
-    currentTask,
-    complete: tasks.length > 0 && tasks.every((task) => task.checked),
-    tasksStartLine: range ? range.startIndex + 1 : null,
-    tasksEndLine: range ? range.endIndex : null
-  };
-}
-const parsePlan = parseMarkdownPlan;
-function createPlanMarkdown(planId, title = formatPlanTitle(planId)) {
-  return `# ${title}
-
-Brief implementation notes.
-
-## Tasks
-`;
-}
-function updateTaskCheckbox(content, taskId, checked) {
-  if (!PLAN_TASK_ID_REGEX.test(taskId)) {
-    throw new Error(`Invalid task id: ${taskId}`);
-  }
-  const lines = content.split(/\r?\n/);
-  const range = getTasksSectionRange(content);
-  if (!range) {
-    throw new Error("Plan is missing a ## Tasks section.");
-  }
-  for (let index = range.startIndex + 1; index < range.endIndex; index += 1) {
-    const line = lines[index] ?? "";
-    const match = line.match(PLAN_TASK_LINE_REGEX);
-    if (!match || match[2] !== taskId) continue;
-    lines[index] = `- [${checked ? "x" : " "}] ${match[2]}: ${match[3].trim()}`;
-    return lines.join("\n");
-  }
-  throw new Error(`Task not found in plan: ${taskId}`);
-}
-function formatPlanTitle(planId) {
-  return planId.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
-}
-export {
-  PLAN_TASKS_HEADING_REGEX,
-  PLAN_TASK_ID_REGEX,
-  PLAN_TASK_LINE_REGEX,
-  createPlanMarkdown,
-  formatPlanTitle,
-  getPlanMetadata,
-  getTasksSectionRange,
-  parseMarkdownPlan,
-  parsePlan,
-  updateTaskCheckbox
-};

package/dist/mjs/plan-paths.mjs

@@ -1,25 +0,0 @@
-import { PLAN_TASK_ID_REGEX } from "./plan-parser.mjs";
-const PLAN_EXTENSION = ".plan.md";
-function validatePlanId(planId) {
-  if (!PLAN_TASK_ID_REGEX.test(planId)) throw new Error(`Invalid plan id: ${planId}`);
-}
-function assertPlanTarget(target) {
-  if (target.type === "workspace" && target.rootProfile !== "visible_projects") {
-    throw new Error("Ordinary plans are unavailable in canonical synchronization sessions");
-  }
-}
-function getWorkerPlansPath(target) {
-  assertPlanTarget(target);
-  return target.type === "project" ? "$R5D_ROOT/plans/$R5D_PROJECT_ID/$R5D_BRANCH_NAME" : "$R5D_ROOT/plans/workspace";
-}
-function getWorkerPlanPath(target, planId) {
-  validatePlanId(planId);
-  return `${getWorkerPlansPath(target)}/${planId}${PLAN_EXTENSION}`;
-}
-export {
-  PLAN_EXTENSION,
-  assertPlanTarget,
-  getWorkerPlanPath,
-  getWorkerPlansPath,
-  validatePlanId
-};

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

@@ -1,172 +0,0 @@
-import net from "node:net";
-import WebSocket, {} from "ws";
-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 WebSocket(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 === WebSocket.OPEN || relay.readyState === WebSocket.CONNECTING) relay.close();
-  };
-  const sendError = (message) => {
-    if (closing) return;
-    const payload = JSON.stringify({ type: "error", error: message });
-    if (relay.readyState === WebSocket.CONNECTING) {
-      closing = true;
-      if (resumeTimer) clearInterval(resumeTimer);
-      socket?.destroy();
-      relay.once("open", () => {
-        relay.send(payload);
-        relay.close();
-      });
-      return;
-    }
-    if (relay.readyState === WebSocket.OPEN) relay.send(payload);
-    cleanup();
-  };
-  const waitForRelayDrain = () => {
-    if (resumeTimer || relay.bufferedAmount <= RELAY_PAUSE_BYTES) return;
-    socket?.pause();
-    resumeTimer = setInterval(() => {
-      if (relay.readyState !== WebSocket.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 !== WebSocket.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 === WebSocket.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 = net.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);
-}
-export {
-  openWorkerPortForwardRelay
-};

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

@@ -1,178 +0,0 @@
-import { randomUUID } from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-const PROJECT_DELETED_CHECKOUTS_DIRECTORY = ".r5d-deleted";
-function isRealDirectory(candidate) {
-  try {
-    return fs.lstatSync(candidate).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function stageProjectCheckoutForDeletion(projectRoot, branchName, checkoutPath) {
-  const garbageRoot = path.join(projectRoot, PROJECT_DELETED_CHECKOUTS_DIRECTORY);
-  if (!isRealDirectory(checkoutPath)) throw new Error(`Cannot stage ${checkoutPath} for deletion: not a directory`);
-  fs.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 = path.join(garbageRoot, `${branchName.replace(/\//g, "__")}-${timestamp}-${randomUUID().slice(0, 8)}`);
-  fs.renameSync(checkoutPath, target);
-  return target;
-}
-function stageProjectForDeletion(projectsRoot, projectRoot) {
-  const root = path.resolve(projectsRoot);
-  const resolved = path.resolve(projectRoot);
-  const relative = path.relative(root, resolved);
-  const segments = relative.split(path.sep);
-  if (!relative || relative.startsWith("..") || path.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 = path.join(root, segments[0], PROJECT_DELETED_CHECKOUTS_DIRECTORY);
-  fs.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 = path.join(garbageRoot, `${segments[1]}-${timestamp}-${randomUUID().slice(0, 8)}`);
-  fs.renameSync(resolved, target);
-  return target;
-}
-function isStagedProjectCheckoutPath(projectsRoot, candidate) {
-  const relative = path.relative(path.resolve(projectsRoot), path.resolve(candidate));
-  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) return false;
-  const segments = relative.split(path.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 = path.resolve(projectsRoot);
-  const resolved = path.resolve(candidate);
-  if (!isStagedProjectCheckoutPath(root, resolved)) return null;
-  let current = root;
-  for (const segment of path.relative(root, path.dirname(resolved)).split(path.sep)) {
-    current = path.join(current, segment);
-    if (!isRealDirectory(current)) return null;
-  }
-  let stat;
-  try {
-    stat = fs.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 fs.readdirSync(directory, { withFileTypes: true }).map((entry) => entry.name).sort();
-  } catch {
-    return [];
-  }
-}
-function discoverStagedProjectCheckouts(projectsRoot) {
-  const root = path.resolve(projectsRoot);
-  const staged = [];
-  for (const namespace of realDirectoryEntries(root)) {
-    if (namespace.startsWith(".")) continue;
-    const namespaceGarbageRoot = path.join(root, namespace, PROJECT_DELETED_CHECKOUTS_DIRECTORY);
-    for (const entry of realDirectoryEntries(namespaceGarbageRoot)) {
-      const candidate = path.join(namespaceGarbageRoot, entry);
-      if (ownedStagedPath(root, candidate)) staged.push(candidate);
-    }
-    for (const project of realDirectoryEntries(path.join(root, namespace))) {
-      if (project.startsWith(".")) continue;
-      const garbageRoot = path.join(root, namespace, project, PROJECT_DELETED_CHECKOUTS_DIRECTORY);
-      for (const entry of realDirectoryEntries(garbageRoot)) {
-        const candidate = path.join(garbageRoot, entry);
-        if (ownedStagedPath(root, candidate)) staged.push(candidate);
-      }
-    }
-  }
-  return staged;
-}
-async function removeStagedProjectCheckout(stagedPath) {
-  if (fs.lstatSync(stagedPath).isSymbolicLink()) {
-    fs.unlinkSync(stagedPath);
-    return;
-  }
-  if (process.platform === "win32") {
-    await fs.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 (fs.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 = path.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 = path.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 (fs.existsSync(resolved) || isRealDirectory(path.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;
-  }
-}
-export {
-  PROJECT_DELETED_CHECKOUTS_DIRECTORY,
-  ProjectCheckoutGarbageCollector,
-  discoverStagedProjectCheckouts,
-  isStagedProjectCheckoutPath,
-  ownedStagedPath,
-  removeStagedProjectCheckout,
-  stageProjectCheckoutForDeletion,
-  stageProjectForDeletion
-};

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

@@ -1,56 +0,0 @@
-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 };
-}
-export {
-  parseProjectMirrorRefsTokensMessage,
-  planProjectMirrorObservationFetch,
-  projectMirrorFetchDecision
-};

package/dist/mjs/project-mirror-refs-token.mjs

@@ -1,53 +0,0 @@
-import { createHash } from "node:crypto";
-const PROJECT_MIRROR_REFS_TOKEN_NAMESPACES = ["refs/heads/", "refs/r5d/server-synced/"];
-const PROJECT_MIRROR_REF_PREFIX = "refs/r5d/mirror/";
-const PROJECT_SERVER_SYNCED_REF_PREFIX = "refs/r5d/server-synced/";
-const PROJECT_MIRROR_REF_LISTING_FORMAT = "--format=%(objectname) %(refname)";
-const GIT_OBJECT_NAME_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
-function hashProjectMirrorRefs(refs) {
-  const lines = refs.map(({ objectName, refname }) => `${objectName} ${refname}`).sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
-  return createHash("sha256").update(lines.join("\n")).digest("hex");
-}
-function parseProjectMirrorRefListing(output, options = {}) {
-  return output.split(/\r?\n/).filter(Boolean).map((row) => {
-    const separator = row.indexOf(" ");
-    const objectName = separator < 0 ? "" : row.slice(0, separator);
-    const refname = separator < 0 ? "" : row.slice(separator + 1);
-    if (!GIT_OBJECT_NAME_RE.test(objectName) || refname.length === 0 || options.namespaces !== void 0 && !options.namespaces.some((prefix) => refname.startsWith(prefix))) {
-      throw new Error(`Invalid ref listing row: ${row}`);
-    }
-    return { refname, objectName };
-  });
-}
-function canonicalizeLocalProjectMirrorRefs(refs) {
-  const canonical = [];
-  for (const { refname, objectName } of refs) {
-    if (refname.startsWith(PROJECT_MIRROR_REF_PREFIX)) {
-      canonical.push({ refname: `refs/heads/${refname.slice(PROJECT_MIRROR_REF_PREFIX.length)}`, objectName });
-    } else if (refname.startsWith(PROJECT_SERVER_SYNCED_REF_PREFIX)) {
-      canonical.push({ refname, objectName });
-    }
-  }
-  return canonical;
-}
-function projectMirrorMountRefs(refs, mount) {
-  const headRef = `refs/heads/${mount.branchName}`;
-  const handoffPrefix = `${PROJECT_SERVER_SYNCED_REF_PREFIX}${mount.branchId}/`;
-  return refs.filter(({ refname }) => refname === headRef || refname.startsWith(handoffPrefix));
-}
-function projectMirrorRefsTokens(refs, mounts) {
-  const mountTokens = /* @__PURE__ */ new Map();
-  for (const mount of mounts) mountTokens.set(mount.branchName, hashProjectMirrorRefs(projectMirrorMountRefs(refs, mount)));
-  return { project: hashProjectMirrorRefs(refs), mounts: mountTokens };
-}
-export {
-  PROJECT_MIRROR_REFS_TOKEN_NAMESPACES,
-  PROJECT_MIRROR_REF_LISTING_FORMAT,
-  PROJECT_MIRROR_REF_PREFIX,
-  PROJECT_SERVER_SYNCED_REF_PREFIX,
-  canonicalizeLocalProjectMirrorRefs,
-  hashProjectMirrorRefs,
-  parseProjectMirrorRefListing,
-  projectMirrorMountRefs,
-  projectMirrorRefsTokens
-};