@ricsam/r5d-worker 0.0.137 → 0.0.138

package/dist/mjs/inline-output.mjs

@@ -1,37 +0,0 @@
-const WORKER_INLINE_OUTPUT_MAX_BYTES = 8 * 1024 * 1024;
-async function collectWorkerInlineOutput(stream, maxBytes = WORKER_INLINE_OUTPUT_MAX_BYTES, signal) {
-  if (!stream) return "";
-  signal?.throwIfAborted();
-  const reader = stream.getReader();
-  const abort = () => {
-    void reader.cancel().catch(() => {
-    });
-  };
-  signal?.addEventListener("abort", abort, { once: true });
-  const decoder = new TextDecoder();
-  const parts = [];
-  let bytes = 0;
-  try {
-    while (true) {
-      const next = await reader.read();
-      signal?.throwIfAborted();
-      if (next.done) break;
-      bytes += next.value.byteLength;
-      if (bytes > maxBytes) {
-        void reader.cancel().catch(() => {
-        });
-        throw new Error(`Inline command output exceeded ${maxBytes} bytes. Use streaming execution for large output.`);
-      }
-      parts.push(decoder.decode(next.value, { stream: true }));
-    }
-    parts.push(decoder.decode());
-    return parts.join("");
-  } finally {
-    signal?.removeEventListener("abort", abort);
-    reader.releaseLock();
-  }
-}
-export {
-  WORKER_INLINE_OUTPUT_MAX_BYTES,
-  collectWorkerInlineOutput
-};

package/dist/mjs/managed-paths.mjs

@@ -1,174 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-const BRANCH_NAME_MAX_LENGTH = 45;
-const BRANCH_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*(?:\/[a-z0-9]+(?:-[a-z0-9]+)*)*$/;
-const PROJECT_SEGMENT_PATTERN = /^[a-z0-9._-]+$/;
-const WINDOWS_RESERVED_PATH_SEGMENT = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\..*)?$/i;
-const INTERNAL_PROJECT_PATH_SEGMENTS = /* @__PURE__ */ new Set([".r5d-retired-checkouts"]);
-function lstatIfExists(targetPath) {
-  try {
-    return fs.lstatSync(targetPath);
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
-}
-function fsyncDirectory(directoryPath) {
-  const descriptor = fs.openSync(directoryPath, "r");
-  try {
-    fs.fsyncSync(descriptor);
-  } finally {
-    fs.closeSync(descriptor);
-  }
-}
-function fsyncCreatedDirectoryChain(directoryPath, preexistingAncestorPath) {
-  let current = path.resolve(directoryPath);
-  const ancestor = path.resolve(preexistingAncestorPath);
-  const relative = path.relative(ancestor, current);
-  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-    throw new Error(`Managed root escaped its durability ancestor: ${current}`);
-  }
-  while (true) {
-    fsyncDirectory(current);
-    if (current === ancestor) return;
-    current = path.dirname(current);
-  }
-}
-function canonicalizeManagedRoot(root) {
-  const resolvedRoot = path.resolve(root.rootPath);
-  let preexistingAncestor = resolvedRoot;
-  while (!lstatIfExists(preexistingAncestor)) {
-    const parent = path.dirname(preexistingAncestor);
-    if (parent === preexistingAncestor) {
-      throw new Error(`Could not find an existing ancestor for ${root.label} (${resolvedRoot})`);
-    }
-    preexistingAncestor = parent;
-  }
-  let canonicalPreexistingAncestor;
-  try {
-    canonicalPreexistingAncestor = fs.realpathSync(preexistingAncestor);
-    if (!fs.statSync(canonicalPreexistingAncestor).isDirectory()) {
-      throw new Error("the nearest existing ancestor is not a directory");
-    }
-  } catch (error) {
-    throw new Error(`Could not validate the existing ancestor of ${root.label} (${resolvedRoot})`, { cause: error });
-  }
-  try {
-    fs.mkdirSync(resolvedRoot, { recursive: true });
-  } catch (error) {
-    throw new Error(`Could not prepare ${root.label} (${resolvedRoot}) for overlap validation`, { cause: error });
-  }
-  const rootStats = fs.statSync(resolvedRoot, { bigint: true });
-  if (!rootStats.isDirectory()) {
-    throw new Error(`Managed root is not a directory: ${root.label} (${resolvedRoot})`);
-  }
-  const canonicalRoot = fs.realpathSync(resolvedRoot);
-  fsyncCreatedDirectoryChain(canonicalRoot, canonicalPreexistingAncestor);
-  return {
-    ...root,
-    rootPath: canonicalRoot,
-    identity: { device: rootStats.dev, inode: rootStats.ino }
-  };
-}
-function pathContains(root, candidate) {
-  const relative = path.relative(root, candidate);
-  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
-}
-function identitiesMatch(left, right) {
-  return left.device === right.device && left.inode === right.inode;
-}
-function pathOrFilesystemContains(root, candidate) {
-  if (pathContains(root.rootPath, candidate.rootPath) || identitiesMatch(root.identity, candidate.identity)) {
-    return true;
-  }
-  let ancestor = path.dirname(candidate.rootPath);
-  while (true) {
-    const stats = fs.statSync(ancestor, { bigint: true });
-    if (identitiesMatch(root.identity, { device: stats.dev, inode: stats.ino })) return true;
-    const parent = path.dirname(ancestor);
-    if (parent === ancestor) return false;
-    ancestor = parent;
-  }
-}
-function assertDisjointManagedRoots(roots) {
-  const canonical = roots.map(canonicalizeManagedRoot);
-  for (let leftIndex = 0; leftIndex < canonical.length; leftIndex += 1) {
-    const left = canonical[leftIndex];
-    for (let rightIndex = leftIndex + 1; rightIndex < canonical.length; rightIndex += 1) {
-      const right = canonical[rightIndex];
-      if (pathOrFilesystemContains(left, right) || pathOrFilesystemContains(right, left)) {
-        throw new Error(`Managed roots overlap: ${left.label} (${left.rootPath}) and ${right.label} (${right.rootPath}) must be disjoint`);
-      }
-    }
-  }
-}
-function validateManagedBranchName(branchName) {
-  if (typeof branchName !== "string" || branchName.length === 0) {
-    throw new Error("Branch name is required");
-  }
-  if (branchName.length > BRANCH_NAME_MAX_LENGTH) {
-    throw new Error(`Branch name must be ${BRANCH_NAME_MAX_LENGTH} characters or fewer`);
-  }
-  if (!BRANCH_NAME_PATTERN.test(branchName)) {
-    throw new Error(`Invalid branch name from server: ${branchName}`);
-  }
-  const reserved = branchName.split("/").find((segment) => WINDOWS_RESERVED_PATH_SEGMENT.test(segment));
-  if (reserved) {
-    throw new Error(`Invalid branch name from server: reserved path segment '${reserved}'`);
-  }
-}
-function validateCheckoutPathSegments(value) {
-  if (!Array.isArray(value) || value.length !== 2) {
-    throw new Error("Invalid checkout path from server: expected namespace and project segments");
-  }
-  const segments = value;
-  for (const segment of segments) {
-    if (typeof segment !== "string" || !PROJECT_SEGMENT_PATTERN.test(segment) || segment !== segment.toLowerCase() || segment === "." || segment === ".." || segment === ".git" || INTERNAL_PROJECT_PATH_SEGMENTS.has(segment) || segment.endsWith(".") || WINDOWS_RESERVED_PATH_SEGMENT.test(segment)) {
-      throw new Error(`Invalid checkout path segment from server: ${String(segment)}`);
-    }
-  }
-  return [segments[0], segments[1]];
-}
-function assertPathInside(root, candidate, label) {
-  const resolvedRoot = path.resolve(root);
-  const resolvedCandidate = path.resolve(candidate);
-  const relative = path.relative(resolvedRoot, resolvedCandidate);
-  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-    throw new Error(`${label} escapes its managed root: ${candidate}`);
-  }
-}
-function assertNoSymlinkComponents(root, candidate) {
-  assertPathInside(root, candidate, "Checkout path");
-  const relative = path.relative(path.resolve(root), path.resolve(candidate));
-  let current = path.resolve(root);
-  for (const component of relative.split(path.sep).filter(Boolean)) {
-    current = path.join(current, component);
-    if (!fs.existsSync(current)) break;
-    if (fs.lstatSync(current).isSymbolicLink()) {
-      throw new Error(`Checkout path contains a symbolic link: ${current}`);
-    }
-  }
-}
-function managedProjectRoot(projectsRoot, checkoutPathSegments) {
-  const segments = validateCheckoutPathSegments(checkoutPathSegments);
-  const result = path.join(projectsRoot, ...segments);
-  assertNoSymlinkComponents(projectsRoot, result);
-  return result;
-}
-function managedBranchPath(projectsRoot, checkoutPathSegments, branchName) {
-  validateManagedBranchName(branchName);
-  const projectRoot = managedProjectRoot(projectsRoot, checkoutPathSegments);
-  const result = path.join(projectRoot, ...branchName.split("/"));
-  assertNoSymlinkComponents(projectRoot, result);
-  return result;
-}
-export {
-  BRANCH_NAME_MAX_LENGTH,
-  BRANCH_NAME_PATTERN,
-  assertDisjointManagedRoots,
-  assertPathInside,
-  managedBranchPath,
-  managedProjectRoot,
-  validateCheckoutPathSegments,
-  validateManagedBranchName
-};

package/dist/mjs/plan-lint.mjs

@@ -1,129 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import picomatch from "picomatch";
-import { getTasksSectionRange, PLAN_TASK_LINE_REGEX } from "./plan-parser.mjs";
-import { PLAN_EXTENSION } from "./plan-paths.mjs";
-import { PLAN_TASK_ID_REGEX } from "./plan-parser.mjs";
-const LEGACY_SCHEMA_FIELD_REGEX = /^\s*(type|status|parent|phase|discovered_problem)\s*:/m;
-function lintPlanContent(planId, content) {
-  const errors = [];
-  const lines = content.split(/\r?\n/);
-  if (/^---(?:\r?\n|$)/.test(content)) {
-    errors.push({
-      planId,
-      severity: "error",
-      message: "YAML frontmatter is not supported. Use plain Markdown with a ## Tasks checklist.",
-      line: 1
-    });
-  }
-  if (LEGACY_SCHEMA_FIELD_REGEX.test(content)) {
-    errors.push({
-      planId,
-      severity: "error",
-      message: "Legacy plan schema fields are not supported. Remove type/status/parent/phase/discovered_problem metadata."
-    });
-  }
-  const titleLineIndex = lines.findIndex((line) => /^# .+\S\s*$/.test(line));
-  if (titleLineIndex === -1) {
-    errors.push({
-      planId,
-      severity: "error",
-      message: "Plan must start with or contain an H1 title, for example '# Implementation Plan'."
-    });
-  }
-  const range = getTasksSectionRange(content);
-  if (!range) {
-    errors.push({
-      planId,
-      severity: "error",
-      message: "Plan is missing a ## Tasks section."
-    });
-    return errors;
-  }
-  const taskIds = /* @__PURE__ */ new Set();
-  let taskCount = 0;
-  for (let index = range.startIndex + 1; index < range.endIndex; index += 1) {
-    const line = lines[index] ?? "";
-    if (line.trim() === "") continue;
-    const match = line.match(PLAN_TASK_LINE_REGEX);
-    if (!match || !match[3].trim()) {
-      errors.push({
-        planId,
-        severity: "error",
-        line: index + 1,
-        message: 'Malformed task line. Use "- [ ] task-id: Description" or "- [x] task-id: Description".'
-      });
-      continue;
-    }
-    taskCount += 1;
-    const taskId = match[2];
-    if (taskIds.has(taskId)) {
-      errors.push({
-        planId,
-        severity: "error",
-        line: index + 1,
-        message: `Duplicate task id "${taskId}".`
-      });
-    }
-    taskIds.add(taskId);
-  }
-  if (taskCount === 0) {
-    errors.push({
-      planId,
-      severity: "error",
-      message: "Plan must include at least one task in the ## Tasks section.",
-      line: range.startIndex + 1
-    });
-  }
-  return errors;
-}
-async function lintPlans(plansDir, glob) {
-  const errors = [];
-  let entries;
-  try {
-    entries = await fs.readdir(plansDir, { withFileTypes: true });
-  } catch (error) {
-    if (error.code !== "ENOENT") throw error;
-    entries = [];
-  }
-  const matches = glob ? picomatch(glob) : null;
-  let lintedPlanCount = 0;
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(PLAN_EXTENSION)) continue;
-    const planId = entry.name.slice(0, -PLAN_EXTENSION.length);
-    if (!PLAN_TASK_ID_REGEX.test(planId) || matches && !matches(entry.name) && !matches(planId)) continue;
-    const content = await fs.readFile(path.join(plansDir, entry.name), "utf8");
-    lintedPlanCount += 1;
-    errors.push(...lintPlanContent(planId, content));
-  }
-  return {
-    type: "plan_lint",
-    errors,
-    errorCount: errors.filter((error) => error.severity === "error").length,
-    warningCount: errors.filter((error) => error.severity === "warning").length,
-    lintedPlanCount
-  };
-}
-function formatPlanLintErrors(errors) {
-  if (errors.length === 0) return "";
-  const lines = ["## Plan Lint Errors", ""];
-  const byPlan = /* @__PURE__ */ new Map();
-  for (const error of errors) {
-    byPlan.set(error.planId, [...byPlan.get(error.planId) ?? [], error]);
-  }
-  for (const [planId, planErrors] of byPlan) {
-    lines.push(`### ${planId}.plan.md`);
-    for (const error of planErrors) {
-      const location = error.line ? ` line ${error.line}` : "";
-      lines.push(`- ${error.severity.toUpperCase()}${location}: ${error.message}`);
-    }
-    lines.push("");
-  }
-  lines.push("Fix these issues by editing the Markdown plan file.");
-  return lines.join("\n");
-}
-export {
-  formatPlanLintErrors,
-  lintPlanContent,
-  lintPlans
-};

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
-};