@ricsam/r5d-worker 0.0.137 → 0.0.139

package/dist/cjs/managed-paths.cjs

@@ -1,215 +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 managed_paths_exports = {};
-__export(managed_paths_exports, {
-  BRANCH_NAME_MAX_LENGTH: () => BRANCH_NAME_MAX_LENGTH,
-  BRANCH_NAME_PATTERN: () => BRANCH_NAME_PATTERN,
-  assertDisjointManagedRoots: () => assertDisjointManagedRoots,
-  assertPathInside: () => assertPathInside,
-  managedBranchPath: () => managedBranchPath,
-  managedProjectRoot: () => managedProjectRoot,
-  validateCheckoutPathSegments: () => validateCheckoutPathSegments,
-  validateManagedBranchName: () => validateManagedBranchName
-});
-module.exports = __toCommonJS(managed_paths_exports);
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-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 import_node_fs.default.lstatSync(targetPath);
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
-}
-function fsyncDirectory(directoryPath) {
-  const descriptor = import_node_fs.default.openSync(directoryPath, "r");
-  try {
-    import_node_fs.default.fsyncSync(descriptor);
-  } finally {
-    import_node_fs.default.closeSync(descriptor);
-  }
-}
-function fsyncCreatedDirectoryChain(directoryPath, preexistingAncestorPath) {
-  let current = import_node_path.default.resolve(directoryPath);
-  const ancestor = import_node_path.default.resolve(preexistingAncestorPath);
-  const relative = import_node_path.default.relative(ancestor, current);
-  if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
-    throw new Error(`Managed root escaped its durability ancestor: ${current}`);
-  }
-  while (true) {
-    fsyncDirectory(current);
-    if (current === ancestor) return;
-    current = import_node_path.default.dirname(current);
-  }
-}
-function canonicalizeManagedRoot(root) {
-  const resolvedRoot = import_node_path.default.resolve(root.rootPath);
-  let preexistingAncestor = resolvedRoot;
-  while (!lstatIfExists(preexistingAncestor)) {
-    const parent = import_node_path.default.dirname(preexistingAncestor);
-    if (parent === preexistingAncestor) {
-      throw new Error(`Could not find an existing ancestor for ${root.label} (${resolvedRoot})`);
-    }
-    preexistingAncestor = parent;
-  }
-  let canonicalPreexistingAncestor;
-  try {
-    canonicalPreexistingAncestor = import_node_fs.default.realpathSync(preexistingAncestor);
-    if (!import_node_fs.default.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 {
-    import_node_fs.default.mkdirSync(resolvedRoot, { recursive: true });
-  } catch (error) {
-    throw new Error(`Could not prepare ${root.label} (${resolvedRoot}) for overlap validation`, { cause: error });
-  }
-  const rootStats = import_node_fs.default.statSync(resolvedRoot, { bigint: true });
-  if (!rootStats.isDirectory()) {
-    throw new Error(`Managed root is not a directory: ${root.label} (${resolvedRoot})`);
-  }
-  const canonicalRoot = import_node_fs.default.realpathSync(resolvedRoot);
-  fsyncCreatedDirectoryChain(canonicalRoot, canonicalPreexistingAncestor);
-  return {
-    ...root,
-    rootPath: canonicalRoot,
-    identity: { device: rootStats.dev, inode: rootStats.ino }
-  };
-}
-function pathContains(root, candidate) {
-  const relative = import_node_path.default.relative(root, candidate);
-  return relative === "" || !relative.startsWith(`..${import_node_path.default.sep}`) && relative !== ".." && !import_node_path.default.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 = import_node_path.default.dirname(candidate.rootPath);
-  while (true) {
-    const stats = import_node_fs.default.statSync(ancestor, { bigint: true });
-    if (identitiesMatch(root.identity, { device: stats.dev, inode: stats.ino })) return true;
-    const parent = import_node_path.default.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 = import_node_path.default.resolve(root);
-  const resolvedCandidate = import_node_path.default.resolve(candidate);
-  const relative = import_node_path.default.relative(resolvedRoot, resolvedCandidate);
-  if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
-    throw new Error(`${label} escapes its managed root: ${candidate}`);
-  }
-}
-function assertNoSymlinkComponents(root, candidate) {
-  assertPathInside(root, candidate, "Checkout path");
-  const relative = import_node_path.default.relative(import_node_path.default.resolve(root), import_node_path.default.resolve(candidate));
-  let current = import_node_path.default.resolve(root);
-  for (const component of relative.split(import_node_path.default.sep).filter(Boolean)) {
-    current = import_node_path.default.join(current, component);
-    if (!import_node_fs.default.existsSync(current)) break;
-    if (import_node_fs.default.lstatSync(current).isSymbolicLink()) {
-      throw new Error(`Checkout path contains a symbolic link: ${current}`);
-    }
-  }
-}
-function managedProjectRoot(projectsRoot, checkoutPathSegments) {
-  const segments = validateCheckoutPathSegments(checkoutPathSegments);
-  const result = import_node_path.default.join(projectsRoot, ...segments);
-  assertNoSymlinkComponents(projectsRoot, result);
-  return result;
-}
-function managedBranchPath(projectsRoot, checkoutPathSegments, branchName) {
-  validateManagedBranchName(branchName);
-  const projectRoot = managedProjectRoot(projectsRoot, checkoutPathSegments);
-  const result = import_node_path.default.join(projectRoot, ...branchName.split("/"));
-  assertNoSymlinkComponents(projectRoot, result);
-  return result;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BRANCH_NAME_MAX_LENGTH,
-  BRANCH_NAME_PATTERN,
-  assertDisjointManagedRoots,
-  assertPathInside,
-  managedBranchPath,
-  managedProjectRoot,
-  validateCheckoutPathSegments,
-  validateManagedBranchName
-});

package/dist/cjs/plan-lint.cjs

@@ -1,165 +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 plan_lint_exports = {};
-__export(plan_lint_exports, {
-  formatPlanLintErrors: () => formatPlanLintErrors,
-  lintPlanContent: () => lintPlanContent,
-  lintPlans: () => lintPlans
-});
-module.exports = __toCommonJS(plan_lint_exports);
-var import_promises = __toESM(require("node:fs/promises"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-var import_picomatch = __toESM(require("picomatch"), 1);
-var import_plan_parser = require("./plan-parser.cjs");
-var import_plan_paths = require("./plan-paths.cjs");
-var import_plan_parser2 = require("./plan-parser.cjs");
-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 = (0, import_plan_parser.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(import_plan_parser.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 import_promises.default.readdir(plansDir, { withFileTypes: true });
-  } catch (error) {
-    if (error.code !== "ENOENT") throw error;
-    entries = [];
-  }
-  const matches = glob ? (0, import_picomatch.default)(glob) : null;
-  let lintedPlanCount = 0;
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(import_plan_paths.PLAN_EXTENSION)) continue;
-    const planId = entry.name.slice(0, -import_plan_paths.PLAN_EXTENSION.length);
-    if (!import_plan_parser2.PLAN_TASK_ID_REGEX.test(planId) || matches && !matches(entry.name) && !matches(planId)) continue;
-    const content = await import_promises.default.readFile(import_node_path.default.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");
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  formatPlanLintErrors,
-  lintPlanContent,
-  lintPlans
-});

package/dist/cjs/plan-parser.cjs

@@ -1,127 +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 plan_parser_exports = {};
-__export(plan_parser_exports, {
-  PLAN_TASKS_HEADING_REGEX: () => PLAN_TASKS_HEADING_REGEX,
-  PLAN_TASK_ID_REGEX: () => PLAN_TASK_ID_REGEX,
-  PLAN_TASK_LINE_REGEX: () => PLAN_TASK_LINE_REGEX,
-  createPlanMarkdown: () => createPlanMarkdown,
-  formatPlanTitle: () => formatPlanTitle,
-  getPlanMetadata: () => getPlanMetadata,
-  getTasksSectionRange: () => getTasksSectionRange,
-  parseMarkdownPlan: () => parseMarkdownPlan,
-  parsePlan: () => parsePlan,
-  updateTaskCheckbox: () => updateTaskCheckbox
-});
-module.exports = __toCommonJS(plan_parser_exports);
-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(" ");
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PLAN_TASKS_HEADING_REGEX,
-  PLAN_TASK_ID_REGEX,
-  PLAN_TASK_LINE_REGEX,
-  createPlanMarkdown,
-  formatPlanTitle,
-  getPlanMetadata,
-  getTasksSectionRange,
-  parseMarkdownPlan,
-  parsePlan,
-  updateTaskCheckbox
-});

package/dist/cjs/plan-paths.cjs

@@ -1,53 +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 plan_paths_exports = {};
-__export(plan_paths_exports, {
-  PLAN_EXTENSION: () => PLAN_EXTENSION,
-  assertPlanTarget: () => assertPlanTarget,
-  getWorkerPlanPath: () => getWorkerPlanPath,
-  getWorkerPlansPath: () => getWorkerPlansPath,
-  validatePlanId: () => validatePlanId
-});
-module.exports = __toCommonJS(plan_paths_exports);
-var import_plan_parser = require("./plan-parser.cjs");
-const PLAN_EXTENSION = ".plan.md";
-function validatePlanId(planId) {
-  if (!import_plan_parser.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}`;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PLAN_EXTENSION,
-  assertPlanTarget,
-  getWorkerPlanPath,
-  getWorkerPlansPath,
-  validatePlanId
-});