codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/contribution-service.js

@@ -0,0 +1,409 @@
+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 contribution_service_exports = {};
+__export(contribution_service_exports, {
+  acceptContributions: () => acceptContributions,
+  listContributions: () => listContributions,
+  listContributionsForBranch: () => listContributionsForBranch,
+  prepareContributorBranch: () => prepareContributorBranch,
+  promoteAttachmentToContribution: () => promoteAttachmentToContribution,
+  promoteItemToContribution: () => promoteItemToContribution
+});
+module.exports = __toCommonJS(contribution_service_exports);
+var import_node_child_process = require("node:child_process");
+var import_confined_fs = require("./confined-fs");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_yaml = require("yaml");
+var import_plans_home = require("./plans-home");
+function assertSafeBranchSegment(branch) {
+  if (typeof branch !== "string" || branch.length === 0 || branch.length > 255) {
+    throw new import_confined_fs.ConfinementError("Invalid branch name for a contributions directory");
+  }
+  if (branch.split(/[\\/]/).some((seg) => seg === ".." || seg === "." || seg === "")) {
+    throw new import_confined_fs.ConfinementError(
+      `Branch name "${branch}" contains a path segment that cannot be used as a directory`
+    );
+  }
+  if (import_node_path.default.isAbsolute(branch)) {
+    throw new import_confined_fs.ConfinementError(`Branch name "${branch}" looks like an absolute path`);
+  }
+  return branch;
+}
+function promoteItemToContribution(projectRoot, itemData) {
+  const branch = getCurrentBranch(projectRoot);
+  const contribDir = import_node_path.default.join(projectRoot, ".codetrellis", "contributions", assertSafeBranchSegment(branch), "items");
+  import_node_fs.default.mkdirSync(contribDir, { recursive: true });
+  removeOldPromotionFile(contribDir, itemData.uid);
+  const slug = slugify(itemData.title);
+  const fileName = `${slug}.yaml`;
+  const filePath = import_node_path.default.join(contribDir, fileName);
+  const relPath = import_node_path.default.relative(projectRoot, filePath);
+  const yamlContent = (0, import_yaml.stringify)({
+    uid: itemData.uid,
+    title: itemData.title,
+    kind: itemData.kind,
+    status: itemData.status ?? "pending",
+    body: itemData.body ?? null,
+    promotedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...itemData.attachments?.length ? { attachments: itemData.attachments } : {}
+  });
+  import_node_fs.default.writeFileSync(filePath, yamlContent, "utf-8");
+  updateContributionIndex(projectRoot, branch, {
+    uid: itemData.uid,
+    branch,
+    kind: "item",
+    title: itemData.title,
+    description: itemData.description,
+    filePath: relPath,
+    promotedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    uid: itemData.uid,
+    branch,
+    kind: "item",
+    title: itemData.title,
+    description: itemData.description,
+    filePath: relPath,
+    promotedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function promoteAttachmentToContribution(projectRoot, attachmentData) {
+  const branch = getCurrentBranch(projectRoot);
+  const contribDir = import_node_path.default.join(projectRoot, ".codetrellis", "contributions", assertSafeBranchSegment(branch), "attachments");
+  import_node_fs.default.mkdirSync(contribDir, { recursive: true });
+  const ext = import_node_path.default.extname(attachmentData.sourcePath) || ".bin";
+  const destName = `${attachmentData.uid}${ext}`;
+  const destPath = import_node_path.default.join(contribDir, destName);
+  const relPath = import_node_path.default.relative(projectRoot, destPath);
+  if (import_node_fs.default.existsSync(attachmentData.sourcePath)) {
+    import_node_fs.default.copyFileSync(attachmentData.sourcePath, destPath);
+  }
+  const metaPath = import_node_path.default.join(contribDir, `${attachmentData.uid}.meta.yaml`);
+  import_node_fs.default.writeFileSync(metaPath, (0, import_yaml.stringify)({
+    uid: attachmentData.uid,
+    label: attachmentData.label,
+    contentType: attachmentData.contentType ?? "application/octet-stream",
+    fileName: destName,
+    promotedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }), "utf-8");
+  updateContributionIndex(projectRoot, branch, {
+    uid: attachmentData.uid,
+    branch,
+    kind: "attachment",
+    title: attachmentData.label,
+    description: attachmentData.description,
+    filePath: relPath,
+    promotedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    uid: attachmentData.uid,
+    branch,
+    kind: "attachment",
+    title: attachmentData.label,
+    description: attachmentData.description,
+    filePath: relPath,
+    promotedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function listContributions(projectRoot) {
+  const branch = getCurrentBranch(projectRoot);
+  return listContributionsForBranch(projectRoot, branch);
+}
+function listContributionsForBranch(projectRoot, branch) {
+  const indexPath = import_node_path.default.join(projectRoot, ".codetrellis", "contributions", branch, "index.json");
+  if (!import_node_fs.default.existsSync(indexPath)) {
+    return { branch, total: 0, items: [] };
+  }
+  try {
+    const raw = import_node_fs.default.readFileSync(indexPath, "utf-8");
+    const items = JSON.parse(raw);
+    return { branch, total: items.length, items };
+  } catch {
+    return { branch, total: 0, items: [] };
+  }
+}
+function acceptContributions(projectRoot, branch, planSlug) {
+  projectRoot = (0, import_plans_home.plansHome)(projectRoot) ?? projectRoot;
+  const contribDir = import_node_path.default.join(
+    projectRoot,
+    ".codetrellis",
+    "contributions",
+    assertSafeBranchSegment(branch)
+  );
+  const planItemsDir = import_node_path.default.join(projectRoot, ".codetrellis", "plans", planSlug, "items");
+  const errors = [];
+  let accepted = 0;
+  if (!import_node_fs.default.existsSync(contribDir)) {
+    return { accepted: 0, planSlug, errors: ["No contributions found for this branch"] };
+  }
+  import_node_fs.default.mkdirSync(planItemsDir, { recursive: true });
+  const itemsDir = import_node_path.default.join(contribDir, "items");
+  if (import_node_fs.default.existsSync(itemsDir)) {
+    const files = import_node_fs.default.readdirSync(itemsDir).filter((f) => f.endsWith(".yaml"));
+    const existingCount = import_node_fs.default.readdirSync(planItemsDir).filter((f) => f.endsWith(".yaml")).length;
+    for (let i = 0; i < files.length; i++) {
+      try {
+        const src = import_node_path.default.join(itemsDir, files[i]);
+        const content = import_node_fs.default.readFileSync(src, "utf-8");
+        const parsed = (0, import_yaml.parse)(content);
+        delete parsed.promotedAt;
+        const sortNum = String(existingCount + i + 1).padStart(3, "0");
+        const slug = slugify(parsed.title ?? files[i].replace(".yaml", ""));
+        const destName = `${sortNum}-${slug}.yaml`;
+        const destPath = import_node_path.default.join(planItemsDir, destName);
+        import_node_fs.default.writeFileSync(destPath, (0, import_yaml.stringify)(parsed), "utf-8");
+        accepted++;
+      } catch (err) {
+        errors.push(`Failed to accept ${files[i]}: ${err}`);
+      }
+    }
+  }
+  const attDir = import_node_path.default.join(contribDir, "attachments");
+  if (import_node_fs.default.existsSync(attDir)) {
+    const planAttDir = import_node_path.default.join(projectRoot, ".codetrellis", "attachments");
+    import_node_fs.default.mkdirSync(planAttDir, { recursive: true });
+    const files = import_node_fs.default.readdirSync(attDir).filter((f) => !f.endsWith(".meta.yaml"));
+    for (const file of files) {
+      try {
+        const src = import_node_path.default.join(attDir, file);
+        const dest = import_node_path.default.join(planAttDir, file);
+        import_node_fs.default.copyFileSync(src, dest);
+        accepted++;
+      } catch (err) {
+        errors.push(`Failed to accept attachment ${file}: ${err}`);
+      }
+    }
+  }
+  try {
+    (0, import_confined_fs.removeWithin)(
+      import_node_path.default.join(projectRoot, ".codetrellis", "contributions"),
+      contribDir,
+      { recursive: true },
+      "contributions cleanup"
+    );
+  } catch (err) {
+    if (!(err instanceof import_confined_fs.ConfinementError)) {
+      const e = err;
+      if (e.code !== "ENOENT") throw err;
+    } else {
+      throw err;
+    }
+  }
+  return { accepted, planSlug, errors };
+}
+function prepareContributorBranch(projectRoot, planSlug, branchName, options) {
+  projectRoot = (0, import_plans_home.plansHome)(projectRoot) ?? projectRoot;
+  const planDir = import_node_path.default.join(projectRoot, ".codetrellis", "plans", planSlug);
+  if (!import_node_fs.default.existsSync(planDir)) {
+    throw new Error(`Plan directory not found: ${planDir}`);
+  }
+  const planYamlPath = import_node_path.default.join(planDir, "plan.yaml");
+  if (!import_node_fs.default.existsSync(planYamlPath)) {
+    throw new Error(`plan.yaml not found for ${planSlug}`);
+  }
+  const dirty = runGitArgs(
+    ["status", "--porcelain", "--", ".codetrellis/"],
+    projectRoot
+  ).trim();
+  if (dirty) {
+    const files = dirty.split("\n").slice(0, 5).map((l) => l.slice(3)).join(", ");
+    throw new Error(
+      `Uncommitted changes under .codetrellis/ would be committed onto the contributor branch and disappear from this one. Commit or stash them first: ${files}` + (dirty.split("\n").length > 5 ? " \u2026" : "")
+    );
+  }
+  const planYaml = import_node_fs.default.readFileSync(planYamlPath, "utf-8");
+  const planMeta = (0, import_yaml.parse)(planYaml);
+  const itemsDir = import_node_path.default.join(planDir, "items");
+  const items = readItemsRecursive(itemsDir);
+  const filteredItems = items.filter((item) => {
+    if (options?.includeItems?.length) {
+      return options.includeItems.includes(item.uid);
+    }
+    return (item.visibility ?? "shared") === "shared";
+  });
+  const cleanedItems = filteredItems.map((item) => stripPrivateContent(item));
+  runGitArgs(["checkout", "-b", branchName], projectRoot);
+  try {
+    const branchPlanDir = import_node_path.default.join(projectRoot, ".codetrellis", "plans", planSlug);
+    const branchItemsDir = import_node_path.default.join(branchPlanDir, "items");
+    if (import_node_fs.default.existsSync(branchItemsDir)) {
+      import_node_fs.default.rmSync(branchItemsDir, { recursive: true, force: true });
+    }
+    import_node_fs.default.mkdirSync(branchItemsDir, { recursive: true });
+    const cleanPlan = { ...planMeta };
+    delete cleanPlan.internalNotes;
+    import_node_fs.default.writeFileSync(planYamlPath, (0, import_yaml.stringify)(cleanPlan), "utf-8");
+    for (let i = 0; i < cleanedItems.length; i++) {
+      const item = cleanedItems[i];
+      const sortNum = String(i + 1).padStart(3, "0");
+      const slug = slugify(item.title ?? "item");
+      const fileName = `${sortNum}-${slug}.yaml`;
+      import_node_fs.default.writeFileSync(
+        import_node_path.default.join(branchItemsDir, fileName),
+        (0, import_yaml.stringify)(item),
+        "utf-8"
+      );
+    }
+    const contribDir = import_node_path.default.join(projectRoot, ".codetrellis", "contributions");
+    if (import_node_fs.default.existsSync(contribDir)) {
+      import_node_fs.default.rmSync(contribDir, { recursive: true, force: true });
+    }
+    runGitArgs(["add", ".codetrellis/"], projectRoot);
+    const message = `[cdev] prepare contributor branch: ${planSlug}
+
+Filtered to ${cleanedItems.length} shared items for external collaboration.`;
+    runGitArgs(["commit", "-m", message, "--allow-empty", "--", ".codetrellis/"], projectRoot);
+    const sha = runGitArgs(["rev-parse", "HEAD"], projectRoot).trim();
+    runGitArgs(["checkout", "-"], projectRoot);
+    return {
+      branch: branchName,
+      planSlug,
+      itemCount: cleanedItems.length,
+      commitHash: sha
+    };
+  } catch (err) {
+    try {
+      runGitArgs(["checkout", "-"], projectRoot);
+      runGitArgs(["branch", "-D", branchName], projectRoot);
+    } catch {
+    }
+    throw err;
+  }
+}
+function getCurrentBranch(projectRoot) {
+  try {
+    return runGitArgs(["rev-parse", "--abbrev-ref", "HEAD"], projectRoot).trim();
+  } catch {
+    return "detached";
+  }
+}
+function runGitArgs(args, cwd) {
+  return (0, import_node_child_process.execFileSync)("git", args, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 15e3
+  });
+}
+function removeOldPromotionFile(contribDir, uid) {
+  if (!import_node_fs.default.existsSync(contribDir)) return;
+  const files = import_node_fs.default.readdirSync(contribDir).filter((f) => f.endsWith(".yaml"));
+  for (const file of files) {
+    try {
+      const content = import_node_fs.default.readFileSync(import_node_path.default.join(contribDir, file), "utf-8");
+      if (content.includes(`uid: ${uid}`) || content.includes(`uid: "${uid}"`)) {
+        import_node_fs.default.unlinkSync(import_node_path.default.join(contribDir, file));
+        return;
+      }
+    } catch {
+    }
+  }
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+function updateContributionIndex(projectRoot, branch, contribution) {
+  const indexPath = import_node_path.default.join(projectRoot, ".codetrellis", "contributions", branch, "index.json");
+  let items = [];
+  if (import_node_fs.default.existsSync(indexPath)) {
+    try {
+      items = JSON.parse(import_node_fs.default.readFileSync(indexPath, "utf-8"));
+    } catch {
+    }
+  }
+  const idx = items.findIndex((i) => i.uid === contribution.uid);
+  if (idx >= 0) {
+    items[idx] = contribution;
+  } else {
+    items.push(contribution);
+  }
+  import_node_fs.default.mkdirSync(import_node_path.default.dirname(indexPath), { recursive: true });
+  import_node_fs.default.writeFileSync(indexPath, JSON.stringify(items, null, 2), "utf-8");
+}
+function readItemsRecursive(dir) {
+  const items = [];
+  if (!import_node_fs.default.existsSync(dir)) return items;
+  const entries = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = import_node_path.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const selfPath = import_node_path.default.join(fullPath, "_self.yaml");
+      if (import_node_fs.default.existsSync(selfPath)) {
+        try {
+          const parsed = (0, import_yaml.parse)(import_node_fs.default.readFileSync(selfPath, "utf-8"));
+          if (parsed) items.push(parsed);
+        } catch {
+        }
+      }
+      items.push(...readItemsRecursive(fullPath));
+    } else if (entry.name.endsWith(".yaml") && entry.name !== "_self.yaml") {
+      try {
+        const parsed = (0, import_yaml.parse)(import_node_fs.default.readFileSync(fullPath, "utf-8"));
+        if (parsed) items.push(parsed);
+      } catch {
+      }
+    }
+  }
+  return items;
+}
+function stripPrivateContent(item) {
+  const cleaned = { ...item };
+  delete cleaned.visibility;
+  delete cleaned.visibility_override;
+  delete cleaned.overrideParentVisibility;
+  if (Array.isArray(cleaned.attachments)) {
+    cleaned.attachments = cleaned.attachments.filter(
+      (att) => {
+        const value = att.value;
+        return !value?.startsWith("userdata://");
+      }
+    );
+    if (cleaned.attachments.length === 0) {
+      delete cleaned.attachments;
+    }
+  }
+  if (Array.isArray(cleaned.comments)) {
+    cleaned.comments = cleaned.comments.filter(
+      (c) => (c.visibility ?? "shared") === "shared"
+    );
+    if (cleaned.comments.length === 0) {
+      delete cleaned.comments;
+    }
+  }
+  return cleaned;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  acceptContributions,
+  listContributions,
+  listContributionsForBranch,
+  prepareContributorBranch,
+  promoteAttachmentToContribution,
+  promoteItemToContribution
+});

package/src/backend/services/coverage-service.js

@@ -0,0 +1,173 @@
+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 coverage_service_exports = {};
+__export(coverage_service_exports, {
+  emptyCoverageReport: () => emptyCoverageReport,
+  findNearMisses: () => findNearMisses,
+  getCoverageReport: () => getCoverageReport
+});
+module.exports = __toCommonJS(coverage_service_exports);
+var import_database = require("./database");
+const EMPTY = {
+  imports: { total: 0, resolved: 0, byLanguage: [] },
+  http: { routes: 0, calls: 0, edges: 0, unservedRoutes: 0, unmatchedCalls: 0, nearMisses: [] }
+};
+const MAX_NEAR_MISSES = 25;
+const LABEL_EXPR = `(c.method || ' ' || c.url_pattern)`;
+function scalar(sql) {
+  try {
+    const rows = (0, import_database.getDb)().exec(sql);
+    return rows[0]?.values[0]?.[0] ?? 0;
+  } catch {
+    return 0;
+  }
+}
+function findNearMisses(calls, routes) {
+  const out = [];
+  const byShape = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const segs = route.pattern.split("/");
+    const key = `${route.method} ${segs.length}`;
+    const bucket = byShape.get(key);
+    if (bucket) bucket.push({ route, segs });
+    else byShape.set(key, [{ route, segs }]);
+  }
+  for (const call of calls) {
+    const callSegs = call.pattern.split("/");
+    for (const { route, segs: routeSegs } of byShape.get(`${call.method} ${callSegs.length}`) ?? []) {
+      let differing = -1;
+      let ok = true;
+      for (let i = 0; i < callSegs.length; i++) {
+        if (callSegs[i] === routeSegs[i]) continue;
+        if (differing !== -1) {
+          ok = false;
+          break;
+        }
+        if (!routeSegs[i].startsWith(":") || callSegs[i] === "") {
+          ok = false;
+          break;
+        }
+        differing = i;
+      }
+      if (!ok || differing === -1) continue;
+      out.push({
+        method: call.method,
+        callPattern: call.pattern,
+        routePattern: route.pattern,
+        callFile: call.file,
+        routeFile: route.file,
+        callLine: call.line,
+        routeLine: route.line,
+        differingSegment: {
+          position: differing,
+          inCall: callSegs[differing],
+          inRoute: routeSegs[differing]
+        }
+      });
+      if (out.length >= MAX_NEAR_MISSES) return out;
+    }
+  }
+  return out;
+}
+function unpairedCallsites(kind) {
+  const side = kind === "http_call" ? "source_file_id" : "target_file_id";
+  try {
+    const rows = (0, import_database.getDb)().exec(`
+      SELECT c.method, c.url_pattern, f.relative_path, c.line
+      FROM callsites c
+      JOIN files f ON c.file_id = f.id
+      WHERE c.kind = '${kind}'
+        AND c.method IS NOT NULL AND c.url_pattern IS NOT NULL
+        AND NOT EXISTS (
+          SELECT 1 FROM cross_system_edges e
+          WHERE e.${side} = c.file_id AND e.label = ${LABEL_EXPR}
+        )
+    `);
+    return (rows[0]?.values ?? []).map((r) => ({
+      method: r[0],
+      pattern: r[1],
+      file: r[2] ?? "",
+      line: r[3] ?? null
+    }));
+  } catch {
+    return [];
+  }
+}
+function getCoverageReport() {
+  const db = (0, import_database.getDb)();
+  let byLanguage = [];
+  let total = 0;
+  let resolved = 0;
+  try {
+    const rows = db.exec(`
+      SELECT f.language,
+             COUNT(*) AS total,
+             SUM(CASE WHEN i.resolved_path IS NOT NULL THEN 1 ELSE 0 END) AS resolved
+      FROM imports i
+      JOIN files f ON i.file_id = f.id
+      GROUP BY f.language
+      ORDER BY total DESC
+    `);
+    byLanguage = (rows[0]?.values ?? []).map((r) => ({
+      language: r[0] || "unknown",
+      imports: r[1] || 0,
+      resolved: r[2] || 0
+    }));
+    for (const entry of byLanguage) {
+      total += entry.imports;
+      resolved += entry.resolved;
+    }
+  } catch {
+    byLanguage = [];
+  }
+  const routes = scalar(`SELECT COUNT(*) FROM callsites WHERE kind = 'http_route'`);
+  const calls = scalar(`SELECT COUNT(*) FROM callsites WHERE kind = 'http_call'`);
+  const edges = scalar(`SELECT COUNT(*) FROM cross_system_edges WHERE protocol = 'http'`);
+  const unservedRoutes = scalar(`
+    SELECT COUNT(*) FROM callsites c
+    WHERE c.kind = 'http_route'
+      AND c.method IS NOT NULL AND c.url_pattern IS NOT NULL
+      AND NOT EXISTS (
+        SELECT 1 FROM cross_system_edges e
+        WHERE e.target_file_id = c.file_id AND e.label = ${LABEL_EXPR}
+      )
+  `);
+  const unmatchedCalls = scalar(`
+    SELECT COUNT(*) FROM callsites c
+    WHERE c.kind = 'http_call'
+      AND c.method IS NOT NULL AND c.url_pattern IS NOT NULL
+      AND NOT EXISTS (
+        SELECT 1 FROM cross_system_edges e
+        WHERE e.source_file_id = c.file_id AND e.label = ${LABEL_EXPR}
+      )
+  `);
+  const nearMisses = unmatchedCalls > 0 && unservedRoutes > 0 ? findNearMisses(unpairedCallsites("http_call"), unpairedCallsites("http_route")) : [];
+  return {
+    imports: { total, resolved, byLanguage },
+    http: { routes, calls, edges, unservedRoutes, unmatchedCalls, nearMisses }
+  };
+}
+function emptyCoverageReport() {
+  return structuredClone(EMPTY);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  emptyCoverageReport,
+  findNearMisses,
+  getCoverageReport
+});