@danielsimonjr/repo-tools 2.2.7 → 2.4.0

package/dist/cli.js

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "@danielsimonjr/repo-tools",
-  version: "2.2.7",
+  version: "2.4.0",
   description: "One CLI for repository analysis: dependency graphs creation and query with per-export API facts, file chunking, and context compression. TypeScript on Bun, compiled to a single executable.",
   type: "module",
   license: "MIT",
@@ -55,10 +55,10 @@ var package_default = {
 
 // src/check/index.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync17 } from "node:fs";
-import { join as join20, resolve as resolve5 } from "node:path";
+import { join as join21, resolve as resolve6 } from "node:path";
 
 // src/config.ts
-import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { posix, resolve, win32 } from "node:path";
 
 // src/depgraph/api-surface.ts
@@ -662,13 +662,231 @@ function buildApiSurfaceReport(surface, files, stabilityTags) {
   };
 }
 
-// src/depgraph/exclude.ts
-import { statSync } from "node:fs";
+// src/depgraph/duplicates.ts
+import { readFileSync } from "node:fs";
 import { join as join2 } from "node:path";
 
-// src/depgraph/dirlist.ts
-import { existsSync, lstatSync, readdirSync } from "node:fs";
-import { join } from "node:path";
+// src/mask.ts
+var REGEX_KEYWORDS2 = new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "throw",
+  "case",
+  "do",
+  "else",
+  "yield",
+  "await"
+]);
+function regexCanStart(src, prev, afterStmtParen) {
+  if (prev < 0)
+    return true;
+  const c = src[prev] ?? "";
+  if (c === ")")
+    return afterStmtParen;
+  if (c === ">")
+    return src[prev - 1] === "=";
+  if ((c === "+" || c === "-") && src[prev - 1] === c)
+    return false;
+  if (/[([{},;:?=!&|+\-*%^~]/.test(c))
+    return true;
+  if (!/[\w$]/.test(c))
+    return false;
+  const word = /[\w$]+$/.exec(src.slice(Math.max(0, prev - 15), prev + 1))?.[0] ?? "";
+  return REGEX_KEYWORDS2.has(word) && !/[\w$.]/.test(src[prev - word.length] ?? "");
+}
+function regexBodyEnd(src, start2) {
+  let inClass = false;
+  for (let j = start2 + 1;j < src.length; j++) {
+    const c = src[j];
+    if (c === `
+` || c === "\r")
+      return -1;
+    if (c === "\\")
+      j += 1;
+    else if (c === "[")
+      inClass = true;
+    else if (c === "]")
+      inClass = false;
+    else if (c === "/" && !inClass)
+      return j;
+  }
+  return -1;
+}
+function scan(src) {
+  const out2 = [];
+  const push = (kind, start2, end) => {
+    if (end <= start2)
+      return;
+    const last = out2[out2.length - 1];
+    if (last && last.kind === kind && last.end === start2)
+      last.end = end;
+    else
+      out2.push({ kind, start: start2, end });
+  };
+  const templates = [];
+  let i2 = 0;
+  const n = src.length;
+  const readTemplateBody = () => {
+    const start2 = i2;
+    while (i2 < n) {
+      const c = src[i2];
+      if (c === "\\") {
+        i2 += 2;
+        continue;
+      }
+      if (c === "`") {
+        push("string", start2, i2);
+        push("code", i2, i2 + 1);
+        i2 += 1;
+        return;
+      }
+      if (c === "$" && src[i2 + 1] === "{") {
+        push("string", start2, i2);
+        push("code", i2, i2 + 2);
+        i2 += 2;
+        templates.push(0);
+        return;
+      }
+      i2 += 1;
+    }
+    push("string", start2, n);
+  };
+  let codeStart = 0;
+  let prev = -1;
+  const parenStmt = [];
+  let closedStmt = false;
+  const wordEndingAt = (index) => {
+    let end = index;
+    while (end > 0) {
+      const prev = src[end - 1] ?? "";
+      if (/\s/.test(prev)) {
+        end -= 1;
+        continue;
+      }
+      if (prev === "/" && src[end - 2] === "*") {
+        const open = src.lastIndexOf("/*", end - 2);
+        if (open === -1)
+          break;
+        end = open;
+        continue;
+      }
+      break;
+    }
+    return /[\w$]+$/.exec(src.slice(Math.max(0, end - 16), end))?.[0] ?? "";
+  };
+  while (i2 < n) {
+    const c = src[i2];
+    const next = src[i2 + 1];
+    if (c === "/" && next !== "/" && next !== "*" && regexCanStart(src, prev, closedStmt)) {
+      const close = regexBodyEnd(src, i2);
+      if (close !== -1) {
+        push("code", codeStart, i2 + 1);
+        push("string", i2 + 1, close);
+        i2 = close + 1;
+        while (i2 < n && /[a-z]/i.test(src[i2] ?? ""))
+          i2 += 1;
+        push("code", close, i2);
+        prev = i2 - 1;
+        closedStmt = false;
+        codeStart = i2;
+        continue;
+      }
+    }
+    if (c === "/" && next === "/") {
+      push("code", codeStart, i2);
+      const eol = src.indexOf(`
+`, i2);
+      const end = eol === -1 ? n : eol;
+      push("comment", i2, end);
+      i2 = end;
+      codeStart = i2;
+      continue;
+    }
+    if (c === "/" && next === "*") {
+      push("code", codeStart, i2);
+      const close = src.indexOf("*/", i2 + 2);
+      const end = close === -1 ? n : close + 2;
+      push("comment", i2, end);
+      i2 = end;
+      codeStart = i2;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      push("code", codeStart, i2 + 1);
+      let j = i2 + 1;
+      while (j < n && src[j] !== c && src[j] !== `
+`)
+        j += src[j] === "\\" ? 2 : 1;
+      const end = Math.min(j, n);
+      push("string", i2 + 1, end);
+      i2 = end < n && src[end] === c ? end + 1 : end;
+      push("code", end, i2);
+      prev = i2 - 1;
+      closedStmt = false;
+      codeStart = i2;
+      continue;
+    }
+    if (c === "`") {
+      push("code", codeStart, i2 + 1);
+      i2 += 1;
+      readTemplateBody();
+      prev = i2 - 1;
+      closedStmt = false;
+      codeStart = i2;
+      continue;
+    }
+    if (!/\s/.test(c ?? "")) {
+      if (c === "(") {
+        const word = wordEndingAt(i2);
+        parenStmt.push(word === "if" || word === "while" || word === "for" || word === "with");
+        closedStmt = false;
+      } else if (c === ")")
+        closedStmt = parenStmt.pop() === true;
+      else
+        closedStmt = false;
+      prev = i2;
+    }
+    if (templates.length > 0) {
+      const depth = templates.length - 1;
+      if (c === "{")
+        templates[depth] = (templates[depth] ?? 0) + 1;
+      else if (c === "}") {
+        if (templates[depth] === 0) {
+          templates.pop();
+          push("code", codeStart, i2 + 1);
+          i2 += 1;
+          readTemplateBody();
+          prev = i2 - 1;
+          closedStmt = false;
+          codeStart = i2;
+          continue;
+        }
+        templates[depth] = (templates[depth] ?? 1) - 1;
+      }
+    }
+    i2 += 1;
+  }
+  push("code", codeStart, n);
+  return out2;
+}
+function blank(text) {
+  return text.replace(/[^\r\n]/g, " ");
+}
+function blankCommentsAndStrings(src) {
+  return scan(src).map((s) => {
+    const text = src.slice(s.start, s.end);
+    return s.kind === "code" ? text : blank(text);
+  }).join("");
+}
+function stripComments(src) {
+  return scan(src).filter((s) => s.kind !== "comment").map((s) => src.slice(s.start, s.end)).join("");
+}
 
 // src/sort.ts
 function compareCodeUnits(a, b) {
@@ -680,79 +898,17 @@ function sortCodeUnits(values) {
   return [...values].sort(compareCodeUnits);
 }
 
-// src/depgraph/dirlist.ts
-var readdirHook = {
-  names: (dir) => readdirSync(dir),
-  entries: (dir) => readdirSync(dir, { withFileTypes: true })
-};
-function listNames(dir) {
-  return sortCodeUnits(readdirHook.names(dir));
+// src/depgraph/paths.ts
+import { join, relative } from "node:path";
+var OUTPUT_SUBDIR = "docs/architecture";
+function withoutTsExtension(path) {
+  return path.replace(/\.tsx?$/, "");
 }
-function listEntries(dir) {
-  return [...readdirHook.entries(dir)].sort((a, b) => compareCodeUnits(a.name, b.name));
+function toPosix(path) {
+  return path.replace(/\\/g, "/");
 }
-var linkLog = { skipped: new Set };
-function isLink(path) {
-  let link;
-  try {
-    link = lstatSync(path).isSymbolicLink();
-  } catch {
-    return false;
-  }
-  if (link)
-    linkLog.skipped.add(path);
-  return link;
-}
-function isLinkEntry(dir, entry) {
-  if (!entry.isSymbolicLink())
-    return false;
-  linkLog.skipped.add(join(dir, entry.name));
-  return true;
-}
-function isWalkable(dir) {
-  return existsSync(dir) && !isLink(dir);
-}
-
-// src/depgraph/exclude.ts
-var DEFAULT_EXCLUDE = [
-  "node_modules",
-  "dist",
-  "build",
-  "coverage",
-  ".git"
-];
-var TEST_DIR_NAMES = ["test", "tests"];
-function isSourceInput(name2) {
-  return (name2.endsWith(".ts") || name2.endsWith(".tsx")) && !name2.endsWith(".d.ts") && !/\.(test|spec)\.tsx?$/.test(name2);
-}
-function sourceTsFilesUnder(dir, skip = new Set(DEFAULT_EXCLUDE), files = []) {
-  if (!isWalkable(dir))
-    return files;
-  for (const entry of listNames(dir)) {
-    if (skip.has(entry))
-      continue;
-    const fullPath = join2(dir, entry);
-    if (isLink(fullPath))
-      continue;
-    if (statSync(fullPath).isDirectory())
-      sourceTsFilesUnder(fullPath, skip, files);
-    else if (isSourceInput(entry))
-      files.push(fullPath);
-  }
-  return files;
-}
-
-// src/depgraph/paths.ts
-import { join as join3, relative } from "node:path";
-var OUTPUT_SUBDIR = "docs/architecture";
-function withoutTsExtension(path) {
-  return path.replace(/\.tsx?$/, "");
-}
-function toPosix(path) {
-  return path.replace(/\\/g, "/");
-}
-function isSrcIndex(path) {
-  return path === "src/index.ts" || path.endsWith("/src/index.ts");
+function isSrcIndex(path) {
+  return path === "src/index.ts" || path.endsWith("/src/index.ts");
 }
 function relativePosix(root, path) {
   return toPosix(relative(root, path));
@@ -761,864 +917,761 @@ function maskRoot(text, root) {
   return text.split(root).join("<root>").split(toPosix(root)).join("<root>");
 }
 function outputDirOf(root) {
-  return join3(root, "docs", "architecture");
+  return join(root, "docs", "architecture");
 }
 
-// src/depgraph/reporters/banner.ts
-var VERIFICATION_MARKER = "<!-- repo-map:no-verification -->";
-var DEFAULT_REGENERATE_COMMAND = "repo-tools depgraph";
-function bannerFor(options) {
-  const command = options.command ?? DEFAULT_REGENERATE_COMMAND;
-  const marker = options.marker === undefined ? VERIFICATION_MARKER : options.marker;
-  const comment = `<!-- GENERATED FILE -- do not edit by hand.
-     Regenerate with \`${command}\`. -->
-
-`;
-  return marker === null ? comment : `${marker}
-${comment}`;
+// src/depgraph/duplicates.ts
+var RUNTIME_DUP_CATEGORIES = [
+  { cat: "function", key: "functions" },
+  { cat: "constant", key: "constants" },
+  { cat: "class", key: "classes" }
+];
+var TYPE_DUP_CATEGORIES = [
+  { cat: "interface", key: "interfaces" },
+  { cat: "type", key: "types" },
+  { cat: "enum", key: "enums" }
+];
+var DEFAULT_DISPATCH_CALLS = ["mathTyped"];
+function describeDispatchCalls(calls, code = false) {
+  const items = calls.map((call) => code ? `\`${call}(...)\`` : `${call}(...)`);
+  if (items.length <= 1)
+    return items.join("");
+  return `${items.slice(0, -1).join(", ")} or ${items[items.length - 1]}`;
+}
+function duplicateSymbolsNote(dispatchCalls = DEFAULT_DISPATCH_CALLS) {
+  const dispatch = dispatchCalls.length === 0 ? "DISPATCH_VARIANT (never set: no dispatch call is configured), " : `DISPATCH_VARIANT (>=2 ${describeDispatchCalls(dispatchCalls)} registrations of the ` + "same public name — distinct dispatch surfaces, not copy-paste bodies), ";
+  return "This report groups names by OWN definition, not by call graph, then classifies each " + "flagged name (see DupEntryTag): TRUE_DUPLICATE (the actionable merge targets), " + dispatch + "ALIAS_DELEGATION (a const-alias forward to an imported symbol, not an independent body — " + "excluded once fewer than 2 real bodies remain), and ALLOWLISTED (matches " + "duplicate-allowlist.json: for example hot-path is* guards, mirrors in another language, " + "per-package VERSION strings). NOT detected: same-file typed-dispatch overload polymorphism " + "for different argument shapes within one registration — a human still triages " + "TRUE_DUPLICATE entries using the defining files + public flags before merging anything.";
+}
+var DUPLICATE_SYMBOLS_NOTE = duplicateSymbolsNote();
+var DUP_ENTRY_TAG_SORT_ORDER = {
+  TRUE_DUPLICATE: 0,
+  DISPATCH_VARIANT: 1,
+  ALIAS_DELEGATION: 2,
+  ALLOWLISTED: 3
+};
+function loadDuplicateAllowlist(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    return parsed.entries ?? [];
+  } catch {
+    return [];
+  }
 }
-function withBanner(body2, options = {}) {
-  return bannerFor(options) + body2;
+function globMatchSingle(pattern, value) {
+  if (pattern === "*")
+    return true;
+  if (pattern.endsWith("/**"))
+    return value.startsWith(pattern.slice(0, -2));
+  if (pattern.endsWith("*"))
+    return value.startsWith(pattern.slice(0, -1));
+  return value === pattern;
 }
-
-// src/config.ts
-var CONFIG_FILE = "repo-tools.config.json";
-var DEFAULT_API_ENTRY = "src/index.ts";
-var ABSOLUTE_PATH_TEXT = "holds an absolute path; pass a path relative to the root";
-function isAbsolutePath(path) {
-  return posix.isAbsolute(path) || win32.isAbsolute(path);
+function findAllowlistMatch(allowlist, name2, filePath) {
+  return allowlist.find((e) => e.names.some((n) => globMatchSingle(n, name2)) && e.filesGlob.some((f) => globMatchSingle(f, filePath)));
 }
-function resolveUnderRoot(root, path) {
-  return resolve(root, path);
+function escapeRegExpLiteral(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var DEPGRAPH_KEYS = {
-  src: "src",
-  tests: "paths",
-  out: "path",
-  exclude: "names",
-  alsoExclude: "names",
-  strictOrphans: "boolean",
-  duplicateAllowlist: "path",
-  duplicateBaseline: "path",
-  coveragePolicy: "path",
-  regenerateCommand: "string",
-  verificationMarker: "string-or-null",
-  extensions: "paths"
-};
-var API_SURFACE_KEYS = {
-  out: "path-or-null",
-  entry: "path",
-  stabilityTags: "names"
-};
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function isDispatchVariantBody(code, name2, dispatchCalls = DEFAULT_DISPATCH_CALLS) {
+  if (dispatchCalls.length === 0)
+    return false;
+  const calls = dispatchCalls.map(escapeRegExpLiteral).join("|");
+  const re = new RegExp(`export\\s+const\\s+${escapeRegExpLiteral(name2)}\\s*(?::[^=]+)?=\\s*(?:${calls})\\s*(?:<[^>]*>)?\\s*\\(`);
+  return re.test(code);
 }
-function checkValue(key, kind, value, fail) {
-  const text = (v, what) => {
-    if (typeof v !== "string" || v === "")
-      throw fail(`'${key}' must be ${what}`);
-    return v;
-  };
-  const relPath = (v, what) => {
-    const p = text(v, what);
-    if (isAbsolutePath(p))
-      throw fail(`'${key}' ${ABSOLUTE_PATH_TEXT}`);
-    return p;
-  };
-  const list = (v, item, what) => {
-    if (!Array.isArray(v))
-      throw fail(`'${key}' must be ${what}`);
-    return v.map(item);
-  };
-  switch (kind) {
-    case "path":
-      return relPath(value, "a non-empty relative path");
-    case "path-or-null":
-      return value === null ? null : relPath(value, "a non-empty relative path or null");
-    case "paths":
-      return list(value, (x) => relPath(x, "a list of non-empty relative paths"), "a list of non-empty relative paths");
-    case "src":
-      if (value === "auto")
-        return value;
-      return list(value, (x) => relPath(x, '"auto" or a list of non-empty relative paths'), '"auto" or a list of non-empty relative paths');
-    case "names":
-      return list(value, (x) => text(x, "a list of non-empty strings"), "a list of non-empty strings");
-    case "boolean":
-      if (typeof value !== "boolean")
-        throw fail(`'${key}' must be true or false`);
-      return value;
-    case "string":
-      return text(value, "a non-empty string");
-    case "string-or-null":
-      return value === null ? null : text(value, "a non-empty string or null");
+function collectImportedLocalNames(code) {
+  const names = new Set;
+  const importRegex = /import\s+(?:type\s+)?(?:(?:\{([^}]+)\}|(\w+)|\*\s+as\s+(\w+))(?:\s*,\s*(?:\{([^}]+)\}|(\w+)))?)\s+from\s+['"][^'"]+['"]/g;
+  for (const m of code.matchAll(importRegex)) {
+    const named = m[1] || m[4] || "";
+    const def = m[2] || m[5] || "";
+    const ns = m[3] || "";
+    if (named) {
+      for (const item of named.split(",")) {
+        const trimmed = item.trim().replace(/^type\s+/, "");
+        if (!trimmed)
+          continue;
+        const parts2 = trimmed.split(/\s+as\s+/);
+        const local = (parts2[parts2.length - 1] ?? "").trim();
+        if (local)
+          names.add(local);
+      }
+    }
+    if (def)
+      names.add(def);
+    if (ns)
+      names.add(ns);
   }
+  return names;
 }
-function checkSection(prefix, object, keys, fail) {
-  const out2 = {};
-  for (const [name2, value] of Object.entries(object)) {
-    const kind = keys[name2];
-    if (kind === undefined)
-      throw fail(`unknown key '${prefix}${name2}'`);
-    out2[name2] = checkValue(`${prefix}${name2}`, kind, value, fail);
-  }
-  return out2;
+function isAliasDelegationBody(code, name2, importedLocalNames) {
+  const re = new RegExp(`export\\s+const\\s+${escapeRegExpLiteral(name2)}\\s*(?::[^=]+)?=\\s*([A-Za-z_$][\\w$]*)\\s*;`);
+  const m = code.match(re);
+  return !!m && importedLocalNames.has(m[1] ?? "");
 }
-var QUERY_KEYS = {
-  out: "path",
-  nodeRuntimes: "names"
-};
-function parseConfigSections(parsed, label) {
-  const fail = (message) => new Error(`config ${label}: ${message}`);
-  if (!isObject(parsed))
-    throw fail("the file must hold a JSON object");
-  for (const key of Object.keys(parsed)) {
-    if (key === "$schema")
-      continue;
-    if (key !== "depgraph" && key !== "map" && key !== "query") {
-      throw fail(`unknown key '${key}'`);
+function classifyDefiner(file, name2, category, allowlist, readRaw, dispatchCalls = DEFAULT_DISPATCH_CALLS) {
+  const allowMatch = findAllowlistMatch(allowlist, name2, file.path);
+  if (allowMatch)
+    return { tag: "ALLOWLISTED", reason: allowMatch.reason };
+  if (category === "constant") {
+    const raw = readRaw(file.path);
+    if (raw) {
+      const code = stripComments(raw);
+      if (isDispatchVariantBody(code, name2, dispatchCalls))
+        return { tag: "DISPATCH_VARIANT" };
+      if (isAliasDelegationBody(code, name2, collectImportedLocalNames(code))) {
+        return { tag: "ALIAS_DELEGATION" };
+      }
     }
   }
-  if (parsed.map !== undefined && parsed.depgraph !== undefined) {
-    throw fail("use the section 'map' or its old name 'depgraph', not both");
-  }
-  const sectionName = parsed.map !== undefined ? "map" : "depgraph";
-  const sections = { depgraph: {}, query: {} };
-  const section = parsed[sectionName];
-  if (section !== undefined) {
-    if (!isObject(section))
-      throw fail(`'${sectionName}' must be an object`);
-    const { apiSurface, ...rest } = section;
-    sections.depgraph = checkSection(`${sectionName}.`, rest, DEPGRAPH_KEYS, fail);
-    if (apiSurface !== undefined) {
-      if (!isObject(apiSurface))
-        throw fail(`'${sectionName}.apiSurface' must be an object`);
-      sections.depgraph.apiSurface = checkSection(`${sectionName}.apiSurface.`, apiSurface, API_SURFACE_KEYS, fail);
+  return { tag: "PLAIN" };
+}
+function collectOwnDefiners(files, categories) {
+  const byName = new Map;
+  for (const file of files) {
+    const reExported = new Set(file.exports.reExported);
+    for (const { cat, key } of categories) {
+      for (const name2 of file.exports[key]) {
+        if (reExported.has(name2))
+          continue;
+        if (key === "types" && file.exports.interfaces.includes(name2))
+          continue;
+        const list = byName.get(name2) ?? [];
+        list.push({ file, category: cat });
+        byName.set(name2, list);
+      }
     }
   }
-  const query = parsed.query;
-  if (query !== undefined) {
-    if (!isObject(query))
-      throw fail("'query' must be an object");
-    sections.query = checkSection("query.", query, QUERY_KEYS, fail);
-  }
-  return sections;
+  return byName;
 }
-function loadConfigSections(root, configPath) {
-  if (configPath !== undefined && isAbsolutePath(configPath)) {
-    throw new Error(`flag --config ${ABSOLUTE_PATH_TEXT}`);
-  }
-  const rel = configPath ?? CONFIG_FILE;
-  const label = `<root>/${rel.replace(/\\/g, "/")}`;
-  const path = resolveUnderRoot(root, rel);
-  if (configPath === undefined && !existsSync2(path))
-    return { depgraph: {}, query: {} };
-  let text;
-  try {
-    text = readFileSync(path, "utf8");
-  } catch {
-    throw new Error(`config ${label}: the file cannot be read`);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    throw new Error(`config ${label}: the file is not valid JSON`);
-  }
-  return parseConfigSections(parsed, label);
+function finalizeDuplicateEntry(name2, categories, definers, tag) {
+  const publicDefiners = definers.filter((d) => d.public);
+  const canonicalHint = publicDefiners.length === 1 ? publicDefiners[0]?.file ?? "" : publicDefiners.length > 1 ? "AMBIGUOUS" : "internal-only";
+  return { name: name2, category: [...categories].sort().join("+"), definers, canonicalHint, tag };
 }
-function loadConfigFile(root, configPath) {
-  return loadConfigSections(root, configPath).depgraph;
+function buildDuplicateEntries(byName, publicSurface, allowlist, readRaw, dispatchCalls = DEFAULT_DISPATCH_CALLS) {
+  const isFilePublic = (file, name2) => publicSurface.publicWildcardFiles.has(file.path) || publicSurface.publicNamed.has(`${file.path}::${name2}`);
+  const entries = [];
+  for (const [name2, defs] of byName) {
+    const byFile = new Map;
+    for (const d of defs)
+      if (!byFile.has(d.file.path))
+        byFile.set(d.file.path, d);
+    if (byFile.size < 2)
+      continue;
+    const categories = new Set;
+    const definers = [];
+    for (const { file, category } of byFile.values()) {
+      categories.add(category);
+      const { tag, reason } = classifyDefiner(file, name2, category, allowlist, readRaw, dispatchCalls);
+      definers.push({
+        file: file.path,
+        package: file.packageName ?? "unknown",
+        public: isFilePublic(file, name2),
+        tag,
+        ...reason ? { reason } : {}
+      });
+    }
+    definers.sort((a, b) => compareCodeUnits(a.file, b.file));
+    const nonAlias = definers.filter((d) => d.tag !== "ALIAS_DELEGATION");
+    if (nonAlias.length < 2) {
+      entries.push(finalizeDuplicateEntry(name2, categories, definers, "ALIAS_DELEGATION"));
+      continue;
+    }
+    const nonAllowlisted = nonAlias.filter((d) => d.tag !== "ALLOWLISTED");
+    let entryTag;
+    if (nonAllowlisted.length < 2) {
+      entryTag = "ALLOWLISTED";
+    } else {
+      const dispatchCount = nonAllowlisted.filter((d) => d.tag === "DISPATCH_VARIANT").length;
+      entryTag = dispatchCount >= 2 ? "DISPATCH_VARIANT" : "TRUE_DUPLICATE";
+    }
+    entries.push(finalizeDuplicateEntry(name2, categories, definers, entryTag));
+  }
+  entries.sort((a, b) => DUP_ENTRY_TAG_SORT_ORDER[a.tag] - DUP_ENTRY_TAG_SORT_ORDER[b.tag] || b.definers.length - a.definers.length || compareCodeUnits(a.name, b.name));
+  return entries;
 }
-function mergeQueryConfig(cli, file) {
-  return {
-    out: cli.out ?? file.query.out ?? file.depgraph.out ?? OUTPUT_SUBDIR,
-    nodeRuntimes: cli.nodeRuntimes ?? file.query.nodeRuntimes ?? []
+function tallyByTag(entries) {
+  const tally = {
+    TRUE_DUPLICATE: 0,
+    DISPATCH_VARIANT: 0,
+    ALIAS_DELEGATION: 0,
+    ALLOWLISTED: 0
   };
+  for (const e of entries)
+    tally[e.tag]++;
+  return tally;
 }
-var MAP_REGENERATE_COMMAND = "repo-tools map";
-function mergeMapConfig(cli, file) {
-  const merged = mergeDepgraphConfig(cli, file);
-  const inDocs = (name2) => `${OUTPUT_SUBDIR}/${name2}`;
+function detectDuplicateSymbols(files, publicSurface, root, allowlistPath = join2(outputDirOf(root), "duplicate-allowlist.json"), dispatchCalls = DEFAULT_DISPATCH_CALLS) {
+  const allowlist = loadDuplicateAllowlist(allowlistPath);
+  const cache = new Map;
+  const readRaw = (relPath) => {
+    let content = cache.get(relPath);
+    if (content === undefined) {
+      try {
+        content = readFileSync(join2(root, relPath), "utf-8");
+      } catch {
+        content = "";
+      }
+      cache.set(relPath, content);
+    }
+    return content;
+  };
   return {
-    ...merged,
-    duplicateAllowlist: cli.duplicateAllowlist ?? file.duplicateAllowlist ?? inDocs("duplicate-allowlist.json"),
-    duplicateBaseline: cli.duplicateBaseline ?? file.duplicateBaseline ?? inDocs("duplicate-baseline.json"),
-    coveragePolicy: cli.coveragePolicy ?? file.coveragePolicy ?? inDocs("coverage-policy.json"),
-    regenerateCommand: cli.regenerateCommand ?? file.regenerateCommand ?? MAP_REGENERATE_COMMAND
+    runtime: buildDuplicateEntries(collectOwnDefiners(files, RUNTIME_DUP_CATEGORIES), publicSurface, allowlist, readRaw, dispatchCalls),
+    types: buildDuplicateEntries(collectOwnDefiners(files, TYPE_DUP_CATEGORIES), publicSurface, allowlist, readRaw, dispatchCalls)
   };
 }
-function mergeDepgraphConfig(cli, file) {
-  const out2 = cli.out ?? file.out ?? OUTPUT_SUBDIR;
-  const inOut = (name2) => `${out2.replace(/[\\/]+$/, "")}/${name2}`;
+function buildDuplicateReport(dup, dispatchCalls = DEFAULT_DISPATCH_CALLS) {
+  const runtimeByTag = tallyByTag(dup.runtime);
+  const typeByTag = tallyByTag(dup.types);
   return {
-    src: cli.src ?? file.src ?? "auto",
-    tests: cli.tests ?? file.tests ?? [...TEST_DIR_NAMES],
-    out: out2,
-    exclude: cli.exclude ?? file.exclude ?? [...DEFAULT_EXCLUDE],
-    alsoExclude: cli.alsoExclude ?? file.alsoExclude ?? [],
-    strictOrphans: cli.strictOrphans ?? file.strictOrphans ?? false,
-    duplicateAllowlist: cli.duplicateAllowlist ?? file.duplicateAllowlist ?? inOut("duplicate-allowlist.json"),
-    duplicateBaseline: cli.duplicateBaseline ?? file.duplicateBaseline ?? inOut("duplicate-baseline.json"),
-    coveragePolicy: cli.coveragePolicy ?? file.coveragePolicy ?? inOut("coverage-policy.json"),
-    regenerateCommand: cli.regenerateCommand ?? file.regenerateCommand ?? DEFAULT_REGENERATE_COMMAND,
-    verificationMarker: cli.verificationMarker !== undefined ? cli.verificationMarker : file.verificationMarker !== undefined ? file.verificationMarker : VERIFICATION_MARKER,
-    apiSurface: {
-      out: cli.apiSurface?.out !== undefined ? cli.apiSurface.out : file.apiSurface?.out !== undefined ? file.apiSurface.out : null,
-      entry: cli.apiSurface?.entry ?? file.apiSurface?.entry ?? DEFAULT_API_ENTRY,
-      stabilityTags: cli.apiSurface?.stabilityTags ?? file.apiSurface?.stabilityTags ?? [...DEFAULT_STABILITY_TAGS]
+    note: duplicateSymbolsNote(dispatchCalls),
+    summary: {
+      runtimeDuplicates: runtimeByTag.TRUE_DUPLICATE,
+      typeDuplicates: typeByTag.TRUE_DUPLICATE,
+      runtimeByTag,
+      typeByTag
     },
-    extensions: cli.extensions ?? file.extensions ?? []
+    runtime: dup.runtime,
+    types: dup.types
   };
 }
-
-// src/depgraph/args.ts
-var SCAN_SCOPE_FLAGS = {
-  "--src": "the census finds the source files itself; the area of a file comes from its path",
-  "--tests": "a test file is found by its name or by its test/ or tests/ folder",
-  "--exclude": "the census reads the files that git tracks; list a file in .gitignore instead",
-  "--also-exclude": "the census reads the files that git tracks; list a file in .gitignore instead",
-  "--all": "the graph always holds every file; the disposition of each file shows reachability",
-  "-a": "the graph always holds every file; the disposition of each file shows reachability",
-  "--reachable-only": "the graph always holds every file; the disposition shows reachability",
-  "--include-tests": "the test coverage reports are always written",
-  "-t": "the test coverage reports are always written"
-};
-function scanScopeText(flag) {
-  return `flag ${flag} has no effect in 2.0.0: ${SCAN_SCOPE_FLAGS[flag]}`;
+var DUPLICATE_BASELINE_NOTE = "The accepted TRUE_DUPLICATE names of each kind, with their defining files. " + "`repo-tools depgraph --check-duplicates` fails only on a TRUE_DUPLICATE name that this file " + "does not hold. After a reviewed change, write it again with " + "`repo-tools depgraph --write-duplicate-baseline`.";
+function trueDuplicateNames(entries) {
+  const names = {};
+  const found = entries.filter((e) => e.tag === "TRUE_DUPLICATE").sort((a, b) => compareCodeUnits(a.name, b.name));
+  for (const e of found)
+    names[e.name] = e.definers.map((d) => d.file).sort(compareCodeUnits);
+  return names;
 }
-var BOOLEAN_FLAGS = {
-  "--all": "all",
-  "-a": "all",
-  "--include-tests": "includeTests",
-  "-t": "includeTests",
-  "--reachable-only": "reachableOnly",
-  "--strict-orphans": "strictOrphans",
-  "--strict-census": "strictCensus",
-  "--check-census": "checkCensus",
-  "--check-duplicates": "checkDuplicates",
-  "--no-regen": "noRegen",
-  "--write-duplicate-baseline": "writeDuplicateBaseline",
-  "--no-extensions": "noExtensions",
-  "--help": "help",
-  "-h": "help"
-};
-var VALUE_FLAGS = {
-  "--root": (_o, value, setRoot) => setRoot(value),
-  "--config": (o, value) => {
-    o.config = relativePath("--config", value);
-  },
-  "--src": (o, value) => {
-    o.settings.src = value === "auto" ? "auto" : pathList("--src", value);
-  },
-  "--tests": (o, value) => {
-    o.settings.tests = pathList("--tests", value);
-  },
-  "--out": (o, value) => {
-    o.settings.out = relativePath("--out", value);
-  },
-  "--exclude": (o, value) => {
-    o.settings.exclude = list("--exclude", value);
-  },
-  "--also-exclude": (o, value) => {
-    o.settings.alsoExclude = list("--also-exclude", value);
-  },
-  "--api-surface": (o, value) => {
-    o.settings.apiSurface = { ...o.settings.apiSurface, out: relativePath("--api-surface", value) };
-  },
-  "--api-entry": (o, value) => {
-    o.settings.apiSurface = { ...o.settings.apiSurface, entry: relativePath("--api-entry", value) };
-  },
-  "--stability-tags": (o, value) => {
-    o.settings.apiSurface = {
-      ...o.settings.apiSurface,
-      stabilityTags: list("--stability-tags", value)
-    };
+function buildDuplicateBaseline(report) {
+  return {
+    note: DUPLICATE_BASELINE_NOTE,
+    runtime: trueDuplicateNames(report.runtime),
+    types: trueDuplicateNames(report.types)
+  };
+}
+function findNewDuplicates(report, baseline) {
+  const found = [];
+  for (const kind of ["runtime", "types"]) {
+    const held = baseline[kind];
+    for (const [name2, files] of Object.entries(trueDuplicateNames(report[kind]))) {
+      if (!Object.hasOwn(held, name2))
+        found.push({ kind, name: name2, files });
+    }
   }
-};
-function list(flag, value) {
-  const items = value.split(",");
-  if (items.some((item) => item === ""))
-    throw new Error(`flag ${flag} holds an empty item`);
-  return items;
+  return found;
 }
-function pathList(flag, value) {
-  return list(flag, value).map((item) => relativePath(flag, item));
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function relativePath(flag, value) {
-  if (isAbsolutePath(value)) {
-    throw new Error(`flag ${flag} ${ABSOLUTE_PATH_TEXT}`);
+function asDuplicateEntries(parsed) {
+  if (!isRecord(parsed) || !Array.isArray(parsed.runtime) || !Array.isArray(parsed.types)) {
+    return null;
   }
-  return value;
+  const valid = (e) => isRecord(e) && typeof e.name === "string" && typeof e.tag === "string" && Array.isArray(e.definers) && e.definers.every((d) => isRecord(d) && typeof d.file === "string");
+  if (!parsed.runtime.every(valid) || !parsed.types.every(valid))
+    return null;
+  return parsed;
 }
-function parseDepgraphArgs(argv, cwd, command) {
-  const options = {
-    root: cwd,
-    settings: {},
-    includeTests: false,
-    all: false,
-    reachableOnly: false,
-    strictOrphans: false,
-    strictCensus: false,
-    checkCensus: false,
-    checkDuplicates: false,
-    noRegen: false,
-    writeDuplicateBaseline: false,
-    noExtensions: false,
-    help: false,
-    ignoredFlags: []
-  };
-  let rootSet = false;
-  const setRoot = (value) => {
-    if (rootSet)
-      throw new Error("the root is set twice (use --root=<path> or one positional path)");
-    rootSet = true;
-    options.root = value;
-  };
-  for (const arg of argv) {
-    if (!arg.startsWith("-")) {
-      setRoot(arg);
-      continue;
-    }
-    const eq = arg.indexOf("=");
-    const name2 = eq === -1 ? arg : arg.slice(0, eq);
-    const value = eq === -1 ? undefined : arg.slice(eq + 1);
-    if (command !== undefined && name2 in SCAN_SCOPE_FLAGS) {
-      if (command === "map")
-        throw new Error(scanScopeText(name2));
-      const takesValue = name2 in VALUE_FLAGS;
-      if (!takesValue && value !== undefined)
-        throw new Error(`flag ${name2} takes no value`);
-      if (takesValue && (value === undefined || value === "")) {
-        throw new Error(`flag ${name2} needs a value: ${name2}=<value>`);
-      }
-      options.ignoredFlags.push(name2);
-      continue;
-    }
-    const booleanKey = BOOLEAN_FLAGS[name2];
-    if (booleanKey !== undefined) {
-      if (value !== undefined)
-        throw new Error(`flag ${name2} takes no value`);
-      options[booleanKey] = true;
-      continue;
-    }
-    const apply = VALUE_FLAGS[name2];
-    if (apply !== undefined) {
-      if (value === undefined || value === "") {
-        throw new Error(`flag ${name2} needs a value: ${name2}=<value>`);
-      }
-      apply(options, value, setRoot);
-      continue;
-    }
-    throw new Error(`unknown flag '${name2}' (see repo-tools ${command ?? "depgraph"} --help)`);
-  }
-  checkModes(options);
-  return options;
-}
-function checkModes(options) {
-  if (options.noRegen && !options.checkDuplicates) {
-    throw new Error("flag --no-regen applies with --check-duplicates only");
-  }
-  const modes = [
-    options.checkCensus && "--check-census",
-    options.checkDuplicates && "--check-duplicates",
-    options.writeDuplicateBaseline && "--write-duplicate-baseline"
-  ].filter((mode) => mode !== false);
-  if (modes.length > 1) {
-    throw new Error(`flags ${modes.join(" and ")} are two modes; use one of them in a run`);
-  }
-}
-function wantsHelp(argv) {
-  return argv.includes("--help") || argv.includes("-h");
+function asBaselineNames(parsed) {
+  if (!isRecord(parsed))
+    return null;
+  const kind = (value) => value === undefined ? {} : isRecord(value) ? value : null;
+  const runtime = kind(parsed.runtime);
+  const types = kind(parsed.types);
+  return runtime && types ? { runtime, types } : null;
 }
 
-// src/map/command.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync15, statSync as statSync6 } from "node:fs";
-import { resolve as resolve4 } from "node:path";
-
-// src/depgraph/duplicates.ts
-import { readFileSync as readFileSync2 } from "node:fs";
+// src/depgraph/exclude.ts
+import { statSync } from "node:fs";
 import { join as join4 } from "node:path";
 
-// src/mask.ts
-var REGEX_KEYWORDS2 = new Set([
-  "return",
-  "typeof",
-  "instanceof",
-  "in",
-  "of",
-  "new",
-  "delete",
-  "void",
-  "throw",
-  "case",
-  "do",
-  "else",
-  "yield",
-  "await"
-]);
-function regexCanStart(src, prev, afterStmtParen) {
-  if (prev < 0)
-    return true;
-  const c = src[prev] ?? "";
-  if (c === ")")
-    return afterStmtParen;
-  if (c === ">")
-    return src[prev - 1] === "=";
-  if ((c === "+" || c === "-") && src[prev - 1] === c)
+// src/depgraph/dirlist.ts
+import { existsSync, lstatSync, readdirSync } from "node:fs";
+import { join as join3 } from "node:path";
+var readdirHook = {
+  names: (dir) => readdirSync(dir),
+  entries: (dir) => readdirSync(dir, { withFileTypes: true })
+};
+function listNames(dir) {
+  return sortCodeUnits(readdirHook.names(dir));
+}
+function listEntries(dir) {
+  return [...readdirHook.entries(dir)].sort((a, b) => compareCodeUnits(a.name, b.name));
+}
+var linkLog = { skipped: new Set };
+function isLink(path) {
+  let link;
+  try {
+    link = lstatSync(path).isSymbolicLink();
+  } catch {
     return false;
-  if (/[([{},;:?=!&|+\-*%^~]/.test(c))
-    return true;
-  if (!/[\w$]/.test(c))
+  }
+  if (link)
+    linkLog.skipped.add(path);
+  return link;
+}
+function isLinkEntry(dir, entry) {
+  if (!entry.isSymbolicLink())
     return false;
-  const word = /[\w$]+$/.exec(src.slice(Math.max(0, prev - 15), prev + 1))?.[0] ?? "";
-  return REGEX_KEYWORDS2.has(word) && !/[\w$.]/.test(src[prev - word.length] ?? "");
+  linkLog.skipped.add(join3(dir, entry.name));
+  return true;
 }
-function regexBodyEnd(src, start2) {
-  let inClass = false;
-  for (let j = start2 + 1;j < src.length; j++) {
-    const c = src[j];
-    if (c === `
-` || c === "\r")
-      return -1;
-    if (c === "\\")
-      j += 1;
-    else if (c === "[")
-      inClass = true;
-    else if (c === "]")
-      inClass = false;
-    else if (c === "/" && !inClass)
-      return j;
+function isWalkable(dir) {
+  return existsSync(dir) && !isLink(dir);
+}
+
+// src/depgraph/exclude.ts
+var DEFAULT_EXCLUDE = [
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".git"
+];
+var TEST_DIR_NAMES = ["test", "tests"];
+function isSourceInput(name2) {
+  return (name2.endsWith(".ts") || name2.endsWith(".tsx")) && !name2.endsWith(".d.ts") && !/\.(test|spec)\.tsx?$/.test(name2);
+}
+function sourceTsFilesUnder(dir, skip = new Set(DEFAULT_EXCLUDE), files = []) {
+  if (!isWalkable(dir))
+    return files;
+  for (const entry of listNames(dir)) {
+    if (skip.has(entry))
+      continue;
+    const fullPath = join4(dir, entry);
+    if (isLink(fullPath))
+      continue;
+    if (statSync(fullPath).isDirectory())
+      sourceTsFilesUnder(fullPath, skip, files);
+    else if (isSourceInput(entry))
+      files.push(fullPath);
   }
-  return -1;
+  return files;
 }
-function scan(src) {
-  const out2 = [];
-  const push = (kind, start2, end) => {
-    if (end <= start2)
-      return;
-    const last = out2[out2.length - 1];
-    if (last && last.kind === kind && last.end === start2)
-      last.end = end;
-    else
-      out2.push({ kind, start: start2, end });
+
+// src/depgraph/reporters/banner.ts
+var VERIFICATION_MARKER = "<!-- repo-map:no-verification -->";
+var DEFAULT_REGENERATE_COMMAND = "repo-tools depgraph";
+function bannerFor(options) {
+  const command = options.command ?? DEFAULT_REGENERATE_COMMAND;
+  const marker = options.marker === undefined ? VERIFICATION_MARKER : options.marker;
+  const comment = `<!-- GENERATED FILE -- do not edit by hand.
+     Regenerate with \`${command}\`. -->
+
+`;
+  return marker === null ? comment : `${marker}
+${comment}`;
+}
+function withBanner(body2, options = {}) {
+  return bannerFor(options) + body2;
+}
+
+// src/config.ts
+var CONFIG_FILE = "repo-tools.config.json";
+var DEFAULT_API_ENTRY = "src/index.ts";
+var ABSOLUTE_PATH_TEXT = "holds an absolute path; pass a path relative to the root";
+function isAbsolutePath(path) {
+  return posix.isAbsolute(path) || win32.isAbsolute(path);
+}
+function resolveUnderRoot(root, path) {
+  return resolve(root, path);
+}
+var DEPGRAPH_KEYS = {
+  src: "src",
+  tests: "paths",
+  out: "path",
+  exclude: "names",
+  alsoExclude: "names",
+  strictOrphans: "boolean",
+  dispatchCalls: "calls",
+  duplicateAllowlist: "path",
+  duplicateBaseline: "path",
+  coveragePolicy: "path",
+  regenerateCommand: "string",
+  verificationMarker: "string-or-null",
+  extensions: "paths"
+};
+var API_SURFACE_KEYS = {
+  out: "path-or-null",
+  entry: "path",
+  stabilityTags: "names"
+};
+var CALL_NAME = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/;
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function checkValue(key, kind, value, fail) {
+  const text = (v, what) => {
+    if (typeof v !== "string" || v === "")
+      throw fail(`'${key}' must be ${what}`);
+    return v;
   };
-  const templates = [];
-  let i2 = 0;
-  const n = src.length;
-  const readTemplateBody = () => {
-    const start2 = i2;
-    while (i2 < n) {
-      const c = src[i2];
-      if (c === "\\") {
-        i2 += 2;
-        continue;
-      }
-      if (c === "`") {
-        push("string", start2, i2);
-        push("code", i2, i2 + 1);
-        i2 += 1;
-        return;
-      }
-      if (c === "$" && src[i2 + 1] === "{") {
-        push("string", start2, i2);
-        push("code", i2, i2 + 2);
-        i2 += 2;
-        templates.push(0);
-        return;
-      }
-      i2 += 1;
-    }
-    push("string", start2, n);
+  const relPath = (v, what) => {
+    const p = text(v, what);
+    if (isAbsolutePath(p))
+      throw fail(`'${key}' ${ABSOLUTE_PATH_TEXT}`);
+    return p;
   };
-  let codeStart = 0;
-  let prev = -1;
-  const parenStmt = [];
-  let closedStmt = false;
-  const wordEndingAt = (index) => {
-    let end = index;
-    while (end > 0) {
-      const prev = src[end - 1] ?? "";
-      if (/\s/.test(prev)) {
-        end -= 1;
-        continue;
-      }
-      if (prev === "/" && src[end - 2] === "*") {
-        const open = src.lastIndexOf("/*", end - 2);
-        if (open === -1)
-          break;
-        end = open;
-        continue;
-      }
-      break;
-    }
-    return /[\w$]+$/.exec(src.slice(Math.max(0, end - 16), end))?.[0] ?? "";
+  const list = (v, item, what) => {
+    if (!Array.isArray(v))
+      throw fail(`'${key}' must be ${what}`);
+    return v.map(item);
   };
-  while (i2 < n) {
-    const c = src[i2];
-    const next = src[i2 + 1];
-    if (c === "/" && next !== "/" && next !== "*" && regexCanStart(src, prev, closedStmt)) {
-      const close = regexBodyEnd(src, i2);
-      if (close !== -1) {
-        push("code", codeStart, i2 + 1);
-        push("string", i2 + 1, close);
-        i2 = close + 1;
-        while (i2 < n && /[a-z]/i.test(src[i2] ?? ""))
-          i2 += 1;
-        push("code", close, i2);
-        prev = i2 - 1;
-        closedStmt = false;
-        codeStart = i2;
-        continue;
-      }
-    }
-    if (c === "/" && next === "/") {
-      push("code", codeStart, i2);
-      const eol = src.indexOf(`
-`, i2);
-      const end = eol === -1 ? n : eol;
-      push("comment", i2, end);
-      i2 = end;
-      codeStart = i2;
-      continue;
-    }
-    if (c === "/" && next === "*") {
-      push("code", codeStart, i2);
-      const close = src.indexOf("*/", i2 + 2);
-      const end = close === -1 ? n : close + 2;
-      push("comment", i2, end);
-      i2 = end;
-      codeStart = i2;
-      continue;
-    }
-    if (c === "'" || c === '"') {
-      push("code", codeStart, i2 + 1);
-      let j = i2 + 1;
-      while (j < n && src[j] !== c && src[j] !== `
-`)
-        j += src[j] === "\\" ? 2 : 1;
-      const end = Math.min(j, n);
-      push("string", i2 + 1, end);
-      i2 = end < n && src[end] === c ? end + 1 : end;
-      push("code", end, i2);
-      prev = i2 - 1;
-      closedStmt = false;
-      codeStart = i2;
-      continue;
-    }
-    if (c === "`") {
-      push("code", codeStart, i2 + 1);
-      i2 += 1;
-      readTemplateBody();
-      prev = i2 - 1;
-      closedStmt = false;
-      codeStart = i2;
-      continue;
-    }
-    if (!/\s/.test(c ?? "")) {
-      if (c === "(") {
-        const word = wordEndingAt(i2);
-        parenStmt.push(word === "if" || word === "while" || word === "for" || word === "with");
-        closedStmt = false;
-      } else if (c === ")")
-        closedStmt = parenStmt.pop() === true;
-      else
-        closedStmt = false;
-      prev = i2;
-    }
-    if (templates.length > 0) {
-      const depth = templates.length - 1;
-      if (c === "{")
-        templates[depth] = (templates[depth] ?? 0) + 1;
-      else if (c === "}") {
-        if (templates[depth] === 0) {
-          templates.pop();
-          push("code", codeStart, i2 + 1);
-          i2 += 1;
-          readTemplateBody();
-          prev = i2 - 1;
-          closedStmt = false;
-          codeStart = i2;
-          continue;
+  switch (kind) {
+    case "path":
+      return relPath(value, "a non-empty relative path");
+    case "path-or-null":
+      return value === null ? null : relPath(value, "a non-empty relative path or null");
+    case "paths":
+      return list(value, (x) => relPath(x, "a list of non-empty relative paths"), "a list of non-empty relative paths");
+    case "src":
+      if (value === "auto")
+        return value;
+      return list(value, (x) => relPath(x, '"auto" or a list of non-empty relative paths'), '"auto" or a list of non-empty relative paths');
+    case "names":
+      return list(value, (x) => text(x, "a list of non-empty strings"), "a list of non-empty strings");
+    case "calls":
+      return list(value, (x) => {
+        if (typeof x !== "string" || !CALL_NAME.test(x)) {
+          throw fail(`'${key}' must be a list of call names (identifiers joined by dots)`);
         }
-        templates[depth] = (templates[depth] ?? 1) - 1;
+        return x;
+      }, "a list of call names (identifiers joined by dots)");
+    case "boolean":
+      if (typeof value !== "boolean")
+        throw fail(`'${key}' must be true or false`);
+      return value;
+    case "string":
+      return text(value, "a non-empty string");
+    case "string-or-null":
+      return value === null ? null : text(value, "a non-empty string or null");
+    case "count":
+      if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+        throw fail(`'${key}' must be a whole number of 1 or more`);
       }
-    }
-    i2 += 1;
+      return value;
+    case "fraction":
+      if (typeof value !== "number" || !(value >= 0 && value <= 1)) {
+        throw fail(`'${key}' must be a number from 0 to 1`);
+      }
+      return value;
   }
-  push("code", codeStart, n);
-  return out2;
 }
-function blank(text) {
-  return text.replace(/[^\r\n]/g, " ");
+function checkSection(prefix, object, keys, fail) {
+  const out2 = {};
+  for (const [name2, value] of Object.entries(object)) {
+    const kind = keys[name2];
+    if (kind === undefined)
+      throw fail(`unknown key '${prefix}${name2}'`);
+    out2[name2] = checkValue(`${prefix}${name2}`, kind, value, fail);
+  }
+  return out2;
 }
-function blankCommentsAndStrings(src) {
-  return scan(src).map((s) => {
-    const text = src.slice(s.start, s.end);
-    return s.kind === "code" ? text : blank(text);
-  }).join("");
+var QUERY_KEYS = {
+  out: "path",
+  nodeRuntimes: "names"
+};
+var CLONES_KEYS = {
+  src: "src",
+  out: "path-or-null",
+  minNodes: "count",
+  shingleLength: "count",
+  nearThreshold: "fraction",
+  containmentThreshold: "fraction",
+  containmentMinShingles: "count",
+  rareShingleLimit: "count",
+  minSharedShingles: "count",
+  parseErrorList: "count"
+};
+function checkClonesFlag(label, key, value) {
+  return checkValue(label, CLONES_KEYS[key], value, (message) => new Error(message));
 }
-function stripComments(src) {
-  return scan(src).filter((s) => s.kind !== "comment").map((s) => src.slice(s.start, s.end)).join("");
+function parseConfigSections(parsed, label) {
+  const fail = (message) => new Error(`config ${label}: ${message}`);
+  if (!isObject(parsed))
+    throw fail("the file must hold a JSON object");
+  for (const key of Object.keys(parsed)) {
+    if (key === "$schema")
+      continue;
+    if (key !== "depgraph" && key !== "map" && key !== "query" && key !== "clones") {
+      throw fail(`unknown key '${key}'`);
+    }
+  }
+  if (parsed.map !== undefined && parsed.depgraph !== undefined) {
+    throw fail("use the section 'map' or its old name 'depgraph', not both");
+  }
+  const sectionName = parsed.map !== undefined ? "map" : "depgraph";
+  const sections = { depgraph: {}, query: {}, clones: {} };
+  const section = parsed[sectionName];
+  if (section !== undefined) {
+    if (!isObject(section))
+      throw fail(`'${sectionName}' must be an object`);
+    const { apiSurface, ...rest } = section;
+    sections.depgraph = checkSection(`${sectionName}.`, rest, DEPGRAPH_KEYS, fail);
+    if (apiSurface !== undefined) {
+      if (!isObject(apiSurface))
+        throw fail(`'${sectionName}.apiSurface' must be an object`);
+      sections.depgraph.apiSurface = checkSection(`${sectionName}.apiSurface.`, apiSurface, API_SURFACE_KEYS, fail);
+    }
+  }
+  const query = parsed.query;
+  if (query !== undefined) {
+    if (!isObject(query))
+      throw fail("'query' must be an object");
+    sections.query = checkSection("query.", query, QUERY_KEYS, fail);
+  }
+  const clones = parsed.clones;
+  if (clones !== undefined) {
+    if (!isObject(clones))
+      throw fail("'clones' must be an object");
+    sections.clones = checkSection("clones.", clones, CLONES_KEYS, fail);
+  }
+  return sections;
 }
-
-// src/depgraph/duplicates.ts
-var RUNTIME_DUP_CATEGORIES = [
-  { cat: "function", key: "functions" },
-  { cat: "constant", key: "constants" },
-  { cat: "class", key: "classes" }
-];
-var TYPE_DUP_CATEGORIES = [
-  { cat: "interface", key: "interfaces" },
-  { cat: "type", key: "types" },
-  { cat: "enum", key: "enums" }
-];
-var DUPLICATE_SYMBOLS_NOTE = "This report groups names by OWN definition, not by call graph, then classifies each " + "flagged name (see DupEntryTag): TRUE_DUPLICATE (the actionable merge targets), " + "DISPATCH_VARIANT (>=2 mathTyped(...) registrations of the same public name — distinct " + "dispatch surfaces, not copy-paste bodies), " + "ALIAS_DELEGATION (a const-alias forward to an imported symbol, not an independent body — " + "excluded once fewer than 2 real bodies remain), and ALLOWLISTED (matches " + "duplicate-allowlist.json: for example hot-path is* guards, mirrors in another language, " + "per-package VERSION strings). NOT detected: same-file typed-dispatch overload polymorphism for " + "different argument shapes within one registration — a human still triages TRUE_DUPLICATE " + "entries using the defining files + public flags before merging anything.";
-var DUP_ENTRY_TAG_SORT_ORDER = {
-  TRUE_DUPLICATE: 0,
-  DISPATCH_VARIANT: 1,
-  ALIAS_DELEGATION: 2,
-  ALLOWLISTED: 3
-};
-function loadDuplicateAllowlist(path) {
+function loadConfigSections(root, configPath) {
+  if (configPath !== undefined && isAbsolutePath(configPath)) {
+    throw new Error(`flag --config ${ABSOLUTE_PATH_TEXT}`);
+  }
+  const rel = configPath ?? CONFIG_FILE;
+  const label = `<root>/${rel.replace(/\\/g, "/")}`;
+  const path = resolveUnderRoot(root, rel);
+  if (configPath === undefined && !existsSync2(path))
+    return { depgraph: {}, query: {}, clones: {} };
+  let text;
+  try {
+    text = readFileSync2(path, "utf8");
+  } catch {
+    throw new Error(`config ${label}: the file cannot be read`);
+  }
+  let parsed;
   try {
-    const parsed = JSON.parse(readFileSync2(path, "utf-8"));
-    return parsed.entries ?? [];
+    parsed = JSON.parse(text);
   } catch {
-    return [];
+    throw new Error(`config ${label}: the file is not valid JSON`);
   }
+  return parseConfigSections(parsed, label);
 }
-function globMatchSingle(pattern, value) {
-  if (pattern === "*")
-    return true;
-  if (pattern.endsWith("/**"))
-    return value.startsWith(pattern.slice(0, -2));
-  if (pattern.endsWith("*"))
-    return value.startsWith(pattern.slice(0, -1));
-  return value === pattern;
-}
-function findAllowlistMatch(allowlist, name2, filePath) {
-  return allowlist.find((e) => e.names.some((n) => globMatchSingle(n, name2)) && e.filesGlob.some((f) => globMatchSingle(f, filePath)));
+function loadConfigFile(root, configPath) {
+  return loadConfigSections(root, configPath).depgraph;
 }
-function escapeRegExpLiteral(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function mergeQueryConfig(cli, file) {
+  return {
+    out: cli.out ?? file.query.out ?? file.depgraph.out ?? OUTPUT_SUBDIR,
+    nodeRuntimes: cli.nodeRuntimes ?? file.query.nodeRuntimes ?? []
+  };
 }
-function isDispatchVariantBody(code, name2) {
-  const re = new RegExp(`export\\s+const\\s+${escapeRegExpLiteral(name2)}\\s*(?::[^=]+)?=\\s*mathTyped\\s*(?:<[^>]*>)?\\s*\\(`);
-  return re.test(code);
+var MAP_REGENERATE_COMMAND = "repo-tools map";
+function mergeMapConfig(cli, file) {
+  const merged = mergeDepgraphConfig(cli, file);
+  const inDocs = (name2) => `${OUTPUT_SUBDIR}/${name2}`;
+  return {
+    ...merged,
+    duplicateAllowlist: cli.duplicateAllowlist ?? file.duplicateAllowlist ?? inDocs("duplicate-allowlist.json"),
+    duplicateBaseline: cli.duplicateBaseline ?? file.duplicateBaseline ?? inDocs("duplicate-baseline.json"),
+    coveragePolicy: cli.coveragePolicy ?? file.coveragePolicy ?? inDocs("coverage-policy.json"),
+    regenerateCommand: cli.regenerateCommand ?? file.regenerateCommand ?? MAP_REGENERATE_COMMAND
+  };
 }
-function collectImportedLocalNames(code) {
-  const names = new Set;
-  const importRegex = /import\s+(?:type\s+)?(?:(?:\{([^}]+)\}|(\w+)|\*\s+as\s+(\w+))(?:\s*,\s*(?:\{([^}]+)\}|(\w+)))?)\s+from\s+['"][^'"]+['"]/g;
-  for (const m of code.matchAll(importRegex)) {
-    const named = m[1] || m[4] || "";
-    const def = m[2] || m[5] || "";
-    const ns = m[3] || "";
-    if (named) {
-      for (const item of named.split(",")) {
-        const trimmed = item.trim().replace(/^type\s+/, "");
-        if (!trimmed)
-          continue;
-        const parts2 = trimmed.split(/\s+as\s+/);
-        const local = (parts2[parts2.length - 1] ?? "").trim();
-        if (local)
-          names.add(local);
-      }
-    }
-    if (def)
-      names.add(def);
-    if (ns)
-      names.add(ns);
-  }
-  return names;
+function mergeDepgraphConfig(cli, file) {
+  const out2 = cli.out ?? file.out ?? OUTPUT_SUBDIR;
+  const inOut = (name2) => `${out2.replace(/[\\/]+$/, "")}/${name2}`;
+  return {
+    src: cli.src ?? file.src ?? "auto",
+    tests: cli.tests ?? file.tests ?? [...TEST_DIR_NAMES],
+    out: out2,
+    exclude: cli.exclude ?? file.exclude ?? [...DEFAULT_EXCLUDE],
+    alsoExclude: cli.alsoExclude ?? file.alsoExclude ?? [],
+    strictOrphans: cli.strictOrphans ?? file.strictOrphans ?? false,
+    dispatchCalls: cli.dispatchCalls ?? file.dispatchCalls ?? [...DEFAULT_DISPATCH_CALLS],
+    duplicateAllowlist: cli.duplicateAllowlist ?? file.duplicateAllowlist ?? inOut("duplicate-allowlist.json"),
+    duplicateBaseline: cli.duplicateBaseline ?? file.duplicateBaseline ?? inOut("duplicate-baseline.json"),
+    coveragePolicy: cli.coveragePolicy ?? file.coveragePolicy ?? inOut("coverage-policy.json"),
+    regenerateCommand: cli.regenerateCommand ?? file.regenerateCommand ?? DEFAULT_REGENERATE_COMMAND,
+    verificationMarker: cli.verificationMarker !== undefined ? cli.verificationMarker : file.verificationMarker !== undefined ? file.verificationMarker : VERIFICATION_MARKER,
+    apiSurface: {
+      out: cli.apiSurface?.out !== undefined ? cli.apiSurface.out : file.apiSurface?.out !== undefined ? file.apiSurface.out : null,
+      entry: cli.apiSurface?.entry ?? file.apiSurface?.entry ?? DEFAULT_API_ENTRY,
+      stabilityTags: cli.apiSurface?.stabilityTags ?? file.apiSurface?.stabilityTags ?? [...DEFAULT_STABILITY_TAGS]
+    },
+    extensions: cli.extensions ?? file.extensions ?? []
+  };
 }
-function isAliasDelegationBody(code, name2, importedLocalNames) {
-  const re = new RegExp(`export\\s+const\\s+${escapeRegExpLiteral(name2)}\\s*(?::[^=]+)?=\\s*([A-Za-z_$][\\w$]*)\\s*;`);
-  const m = code.match(re);
-  return !!m && importedLocalNames.has(m[1] ?? "");
+
+// src/depgraph/args.ts
+var SCAN_SCOPE_FLAGS = {
+  "--src": "the census finds the source files itself; the area of a file comes from its path",
+  "--tests": "a test file is found by its name or by its test/ or tests/ folder",
+  "--exclude": "the census reads the files that git tracks; list a file in .gitignore instead",
+  "--also-exclude": "the census reads the files that git tracks; list a file in .gitignore instead",
+  "--all": "the graph always holds every file; the disposition of each file shows reachability",
+  "-a": "the graph always holds every file; the disposition of each file shows reachability",
+  "--reachable-only": "the graph always holds every file; the disposition shows reachability",
+  "--include-tests": "the test coverage reports are always written",
+  "-t": "the test coverage reports are always written"
+};
+function scanScopeText(flag) {
+  return `flag ${flag} has no effect in 2.0.0: ${SCAN_SCOPE_FLAGS[flag]}`;
 }
-function classifyDefiner(file, name2, category, allowlist, readRaw) {
-  const allowMatch = findAllowlistMatch(allowlist, name2, file.path);
-  if (allowMatch)
-    return { tag: "ALLOWLISTED", reason: allowMatch.reason };
-  if (category === "constant") {
-    const raw = readRaw(file.path);
-    if (raw) {
-      const code = stripComments(raw);
-      if (isDispatchVariantBody(code, name2))
-        return { tag: "DISPATCH_VARIANT" };
-      if (isAliasDelegationBody(code, name2, collectImportedLocalNames(code))) {
-        return { tag: "ALIAS_DELEGATION" };
-      }
-    }
+var BOOLEAN_FLAGS = {
+  "--all": "all",
+  "-a": "all",
+  "--include-tests": "includeTests",
+  "-t": "includeTests",
+  "--reachable-only": "reachableOnly",
+  "--strict-orphans": "strictOrphans",
+  "--strict-census": "strictCensus",
+  "--check-census": "checkCensus",
+  "--check-duplicates": "checkDuplicates",
+  "--no-regen": "noRegen",
+  "--write-duplicate-baseline": "writeDuplicateBaseline",
+  "--no-extensions": "noExtensions",
+  "--help": "help",
+  "-h": "help"
+};
+var VALUE_FLAGS = {
+  "--root": (_o, value, setRoot) => setRoot(value),
+  "--config": (o, value) => {
+    o.config = relativePath("--config", value);
+  },
+  "--src": (o, value) => {
+    o.settings.src = value === "auto" ? "auto" : pathList("--src", value);
+  },
+  "--tests": (o, value) => {
+    o.settings.tests = pathList("--tests", value);
+  },
+  "--out": (o, value) => {
+    o.settings.out = relativePath("--out", value);
+  },
+  "--exclude": (o, value) => {
+    o.settings.exclude = list("--exclude", value);
+  },
+  "--also-exclude": (o, value) => {
+    o.settings.alsoExclude = list("--also-exclude", value);
+  },
+  "--api-surface": (o, value) => {
+    o.settings.apiSurface = { ...o.settings.apiSurface, out: relativePath("--api-surface", value) };
+  },
+  "--api-entry": (o, value) => {
+    o.settings.apiSurface = { ...o.settings.apiSurface, entry: relativePath("--api-entry", value) };
+  },
+  "--stability-tags": (o, value) => {
+    o.settings.apiSurface = {
+      ...o.settings.apiSurface,
+      stabilityTags: list("--stability-tags", value)
+    };
   }
-  return { tag: "PLAIN" };
+};
+function list(flag, value) {
+  const items = value.split(",");
+  if (items.some((item) => item === ""))
+    throw new Error(`flag ${flag} holds an empty item`);
+  return items;
 }
-function collectOwnDefiners(files, categories) {
-  const byName = new Map;
-  for (const file of files) {
-    const reExported = new Set(file.exports.reExported);
-    for (const { cat, key } of categories) {
-      for (const name2 of file.exports[key]) {
-        if (reExported.has(name2))
-          continue;
-        if (key === "types" && file.exports.interfaces.includes(name2))
-          continue;
-        const list = byName.get(name2) ?? [];
-        list.push({ file, category: cat });
-        byName.set(name2, list);
-      }
-    }
-  }
-  return byName;
+function pathList(flag, value) {
+  return list(flag, value).map((item) => relativePath(flag, item));
 }
-function finalizeDuplicateEntry(name2, categories, definers, tag) {
-  const publicDefiners = definers.filter((d) => d.public);
-  const canonicalHint = publicDefiners.length === 1 ? publicDefiners[0]?.file ?? "" : publicDefiners.length > 1 ? "AMBIGUOUS" : "internal-only";
-  return { name: name2, category: [...categories].sort().join("+"), definers, canonicalHint, tag };
+function relativePath(flag, value) {
+  if (isAbsolutePath(value)) {
+    throw new Error(`flag ${flag} ${ABSOLUTE_PATH_TEXT}`);
+  }
+  return value;
 }
-function buildDuplicateEntries(byName, publicSurface, allowlist, readRaw) {
-  const isFilePublic = (file, name2) => publicSurface.publicWildcardFiles.has(file.path) || publicSurface.publicNamed.has(`${file.path}::${name2}`);
-  const entries = [];
-  for (const [name2, defs] of byName) {
-    const byFile = new Map;
-    for (const d of defs)
-      if (!byFile.has(d.file.path))
-        byFile.set(d.file.path, d);
-    if (byFile.size < 2)
+function parseDepgraphArgs(argv, cwd, command) {
+  const options = {
+    root: cwd,
+    settings: {},
+    includeTests: false,
+    all: false,
+    reachableOnly: false,
+    strictOrphans: false,
+    strictCensus: false,
+    checkCensus: false,
+    checkDuplicates: false,
+    noRegen: false,
+    writeDuplicateBaseline: false,
+    noExtensions: false,
+    help: false,
+    ignoredFlags: []
+  };
+  let rootSet = false;
+  const setRoot = (value) => {
+    if (rootSet)
+      throw new Error("the root is set twice (use --root=<path> or one positional path)");
+    rootSet = true;
+    options.root = value;
+  };
+  for (const arg of argv) {
+    if (!arg.startsWith("-")) {
+      setRoot(arg);
       continue;
-    const categories = new Set;
-    const definers = [];
-    for (const { file, category } of byFile.values()) {
-      categories.add(category);
-      const { tag, reason } = classifyDefiner(file, name2, category, allowlist, readRaw);
-      definers.push({
-        file: file.path,
-        package: file.packageName ?? "unknown",
-        public: isFilePublic(file, name2),
-        tag,
-        ...reason ? { reason } : {}
-      });
     }
-    definers.sort((a, b) => compareCodeUnits(a.file, b.file));
-    const nonAlias = definers.filter((d) => d.tag !== "ALIAS_DELEGATION");
-    if (nonAlias.length < 2) {
-      entries.push(finalizeDuplicateEntry(name2, categories, definers, "ALIAS_DELEGATION"));
+    const eq = arg.indexOf("=");
+    const name2 = eq === -1 ? arg : arg.slice(0, eq);
+    const value = eq === -1 ? undefined : arg.slice(eq + 1);
+    if (command !== undefined && name2 in SCAN_SCOPE_FLAGS) {
+      if (command === "map")
+        throw new Error(scanScopeText(name2));
+      const takesValue = name2 in VALUE_FLAGS;
+      if (!takesValue && value !== undefined)
+        throw new Error(`flag ${name2} takes no value`);
+      if (takesValue && (value === undefined || value === "")) {
+        throw new Error(`flag ${name2} needs a value: ${name2}=<value>`);
+      }
+      options.ignoredFlags.push(name2);
       continue;
     }
-    const nonAllowlisted = nonAlias.filter((d) => d.tag !== "ALLOWLISTED");
-    let entryTag;
-    if (nonAllowlisted.length < 2) {
-      entryTag = "ALLOWLISTED";
-    } else {
-      const dispatchCount = nonAllowlisted.filter((d) => d.tag === "DISPATCH_VARIANT").length;
-      entryTag = dispatchCount >= 2 ? "DISPATCH_VARIANT" : "TRUE_DUPLICATE";
+    const booleanKey = BOOLEAN_FLAGS[name2];
+    if (booleanKey !== undefined) {
+      if (value !== undefined)
+        throw new Error(`flag ${name2} takes no value`);
+      options[booleanKey] = true;
+      continue;
     }
-    entries.push(finalizeDuplicateEntry(name2, categories, definers, entryTag));
-  }
-  entries.sort((a, b) => DUP_ENTRY_TAG_SORT_ORDER[a.tag] - DUP_ENTRY_TAG_SORT_ORDER[b.tag] || b.definers.length - a.definers.length || compareCodeUnits(a.name, b.name));
-  return entries;
-}
-function tallyByTag(entries) {
-  const tally = {
-    TRUE_DUPLICATE: 0,
-    DISPATCH_VARIANT: 0,
-    ALIAS_DELEGATION: 0,
-    ALLOWLISTED: 0
-  };
-  for (const e of entries)
-    tally[e.tag]++;
-  return tally;
-}
-function detectDuplicateSymbols(files, publicSurface, root, allowlistPath = join4(outputDirOf(root), "duplicate-allowlist.json")) {
-  const allowlist = loadDuplicateAllowlist(allowlistPath);
-  const cache = new Map;
-  const readRaw = (relPath) => {
-    let content = cache.get(relPath);
-    if (content === undefined) {
-      try {
-        content = readFileSync2(join4(root, relPath), "utf-8");
-      } catch {
-        content = "";
+    const apply = VALUE_FLAGS[name2];
+    if (apply !== undefined) {
+      if (value === undefined || value === "") {
+        throw new Error(`flag ${name2} needs a value: ${name2}=<value>`);
       }
-      cache.set(relPath, content);
-    }
-    return content;
-  };
-  return {
-    runtime: buildDuplicateEntries(collectOwnDefiners(files, RUNTIME_DUP_CATEGORIES), publicSurface, allowlist, readRaw),
-    types: buildDuplicateEntries(collectOwnDefiners(files, TYPE_DUP_CATEGORIES), publicSurface, allowlist, readRaw)
-  };
-}
-function buildDuplicateReport(dup) {
-  const runtimeByTag = tallyByTag(dup.runtime);
-  const typeByTag = tallyByTag(dup.types);
-  return {
-    note: DUPLICATE_SYMBOLS_NOTE,
-    summary: {
-      runtimeDuplicates: runtimeByTag.TRUE_DUPLICATE,
-      typeDuplicates: typeByTag.TRUE_DUPLICATE,
-      runtimeByTag,
-      typeByTag
-    },
-    runtime: dup.runtime,
-    types: dup.types
-  };
-}
-var DUPLICATE_BASELINE_NOTE = "The accepted TRUE_DUPLICATE names of each kind, with their defining files. " + "`repo-tools depgraph --check-duplicates` fails only on a TRUE_DUPLICATE name that this file " + "does not hold. After a reviewed change, write it again with " + "`repo-tools depgraph --write-duplicate-baseline`.";
-function trueDuplicateNames(entries) {
-  const names = {};
-  const found = entries.filter((e) => e.tag === "TRUE_DUPLICATE").sort((a, b) => compareCodeUnits(a.name, b.name));
-  for (const e of found)
-    names[e.name] = e.definers.map((d) => d.file).sort(compareCodeUnits);
-  return names;
-}
-function buildDuplicateBaseline(report) {
-  return {
-    note: DUPLICATE_BASELINE_NOTE,
-    runtime: trueDuplicateNames(report.runtime),
-    types: trueDuplicateNames(report.types)
-  };
-}
-function findNewDuplicates(report, baseline) {
-  const found = [];
-  for (const kind of ["runtime", "types"]) {
-    const held = baseline[kind];
-    for (const [name2, files] of Object.entries(trueDuplicateNames(report[kind]))) {
-      if (!Object.hasOwn(held, name2))
-        found.push({ kind, name: name2, files });
+      apply(options, value, setRoot);
+      continue;
     }
+    throw new Error(`unknown flag '${name2}' (see repo-tools ${command ?? "depgraph"} --help)`);
   }
-  return found;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  checkModes(options);
+  return options;
 }
-function asDuplicateEntries(parsed) {
-  if (!isRecord(parsed) || !Array.isArray(parsed.runtime) || !Array.isArray(parsed.types)) {
-    return null;
+function checkModes(options) {
+  if (options.noRegen && !options.checkDuplicates) {
+    throw new Error("flag --no-regen applies with --check-duplicates only");
+  }
+  const modes = [
+    options.checkCensus && "--check-census",
+    options.checkDuplicates && "--check-duplicates",
+    options.writeDuplicateBaseline && "--write-duplicate-baseline"
+  ].filter((mode) => mode !== false);
+  if (modes.length > 1) {
+    throw new Error(`flags ${modes.join(" and ")} are two modes; use one of them in a run`);
   }
-  const valid = (e) => isRecord(e) && typeof e.name === "string" && typeof e.tag === "string" && Array.isArray(e.definers) && e.definers.every((d) => isRecord(d) && typeof d.file === "string");
-  if (!parsed.runtime.every(valid) || !parsed.types.every(valid))
-    return null;
-  return parsed;
 }
-function asBaselineNames(parsed) {
-  if (!isRecord(parsed))
-    return null;
-  const kind = (value) => value === undefined ? {} : isRecord(value) ? value : null;
-  const runtime = kind(parsed.runtime);
-  const types = kind(parsed.types);
-  return runtime && types ? { runtime, types } : null;
+function wantsHelp(argv) {
+  return argv.includes("--help") || argv.includes("-h");
 }
 
+// src/map/command.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync15, statSync as statSync6 } from "node:fs";
+import { resolve as resolve5 } from "node:path";
+
 // src/depgraph/extensions.ts
-import { existsSync as existsSync3, lstatSync as lstatSync2, realpathSync, statSync as statSync2 } from "node:fs";
-import { basename, dirname as dirname2, isAbsolute, join as join5, relative as relative2, resolve as resolve2, sep } from "node:path";
+import { existsSync as existsSync3, statSync as statSync2 } from "node:fs";
+import { isAbsolute, relative as relative2, resolve as resolve3, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/io.ts
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { lstatSync as lstatSync2, mkdirSync, realpathSync, writeFileSync } from "node:fs";
+import { basename, dirname, join as join5, resolve as resolve2 } from "node:path";
 function writeLf(path, text) {
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, text.replace(/\r\n?/g, `
@@ -1636,6 +1689,22 @@ function toJson(value) {
   return `${JSON.stringify(value, null, 2)}
 `;
 }
+function realPath(path) {
+  let existing = resolve2(path);
+  const rest = [];
+  while (!lstatSync2(existing, { throwIfNoEntry: false })) {
+    const up = dirname(existing);
+    if (up === existing)
+      return;
+    rest.unshift(basename(existing));
+    existing = up;
+  }
+  try {
+    return join5(realpathSync.native(existing), ...rest);
+  } catch {
+    return;
+  }
+}
 
 // src/depgraph/extensions.ts
 var MASK = Object.freeze({ blankCommentsAndStrings, stripComments });
@@ -1716,27 +1785,11 @@ function outsideText(folder, path) {
   const rel = relative2(folder, path);
   return rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || rel.startsWith("../") || isAbsolute(rel);
 }
-function realPath(path) {
-  let existing = resolve2(path);
-  const rest = [];
-  while (!lstatSync2(existing, { throwIfNoEntry: false })) {
-    const up = dirname2(existing);
-    if (up === existing)
-      return;
-    rest.unshift(basename(existing));
-    existing = up;
-  }
-  try {
-    return join5(realpathSync.native(existing), ...rest);
-  } catch {
-    return;
-  }
-}
 function outputPath(outputDir, relPath) {
   if (typeof relPath !== "string" || relPath === "" || isAbsolutePath(relPath)) {
     throw new Error("write: the path must be relative to the output folder");
   }
-  const path = resolve2(outputDir, relPath);
+  const path = resolve3(outputDir, relPath);
   if (outsideText(outputDir, path)) {
     throw new Error("write: the path must stay in the output folder");
   }
@@ -1749,8 +1802,8 @@ function outputPath(outputDir, relPath) {
 }
 
 // src/map/artifacts.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync9, statSync as statSync5, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename as basename4, dirname as dirname6, join as join12 } from "node:path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync10, statSync as statSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename as basename4, dirname as dirname5, join as join13 } from "node:path";
 
 // src/map/cycles.ts
 function sccContaining(start2, eligible, edges, reverseEdges) {
@@ -1890,7 +1943,7 @@ function stronglyConnectedComponents(graph) {
 }
 
 // src/depgraph/resolver.ts
-import { dirname as dirname3, join as join6 } from "node:path";
+import { dirname as dirname2, join as join6 } from "node:path";
 function distToSrc(path) {
   const m = /(^|\/)dist\/(?:src\/)?/.exec(path);
   if (!m)
@@ -1901,7 +1954,7 @@ function distToSrc(path) {
   return `${before}${m[1]}src/${path.slice(m.index + m[0].length)}`;
 }
 function resolveCandidates(fromPath, spec) {
-  const base = toPosix(join6(dirname3(fromPath), spec));
+  const base = toPosix(join6(dirname2(fromPath), spec));
   let candidates;
   if (base.endsWith(".js")) {
     const stem = base.slice(0, -3);
@@ -2035,7 +2088,7 @@ function filesInCycles(components) {
 
 // src/depgraph/roots.ts
 import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
-import { dirname as dirname4, join as join7 } from "node:path";
+import { dirname as dirname3, join as join7 } from "node:path";
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -2118,7 +2171,7 @@ function seedTsconfigEntries(root, pkgDir, cfgRel, add) {
   } catch {
     return;
   }
-  const cfgDir = dirname4(join7(pkgDir, cfgRel));
+  const cfgDir = dirname3(join7(pkgDir, cfgRel));
   const seedPath = (p) => {
     if (p.includes("*")) {
       const base = join7(root, cfgDir, p.replace(/\/?\*.*$/, ""));
@@ -2312,7 +2365,7 @@ function htmlReferencedEntries(root) {
       const src = m[1] ?? "";
       if (/^(?:[a-z][a-z0-9+.-]*:|\/\/)/i.test(src) || !/\.[cm]?[jt]sx?$/.test(src))
         continue;
-      const fromPage = toPosix(join7(dirname4(page), src)).replace(/^\.\//, "");
+      const fromPage = toPosix(join7(dirname3(page), src)).replace(/^\.\//, "");
       const candidates = src.startsWith("/") ? [src.slice(1), fromPage] : [fromPage];
       const found = candidates.find((c) => existsSync4(join7(root, c)));
       if (found !== undefined && !out2.includes(found))
@@ -2332,7 +2385,7 @@ function runtimeLaunchedEntries(root, parsed) {
       continue;
     }
     for (const m of code.matchAll(/new\s+URL\(\s*['"`](\.[^'"`]*?\.m?js)['"`]\s*,\s*import\.meta\.url/g)) {
-      const sibling = toPosix(join7(dirname4(file.path), m[1] ?? ""));
+      const sibling = toPosix(join7(dirname3(file.path), m[1] ?? ""));
       const tsPath = sibling.replace(/\.m?js$/, ".ts");
       if (known.has(tsPath))
         out2.add(tsPath);
@@ -6198,7 +6251,7 @@ import { readFileSync as readFileSync5 } from "node:fs";
 import { join as join9, posix as posix2 } from "node:path";
 
 // src/depgraph/description.ts
-import { basename as basename2, dirname as dirname5 } from "node:path";
+import { basename as basename2, dirname as dirname4 } from "node:path";
 var RULE_LINE = /^[=\-*~#_]{3,}$/;
 function extractDescription(content) {
   const jsdocMatch = content.match(/\/\*\*\s*\n([^*]*(?:\*(?!\/)[^*]*)*)\*\//);
@@ -6233,7 +6286,7 @@ function generateFallbackDescription(file) {
   const fileName = withoutTsExtension(basename2(file.path));
   if (fileName === "index") {
     if (file.exports.reExported.length > 0) {
-      const pkgName = file.packageName || dirname5(file.path).split("/").pop() || "";
+      const pkgName = file.packageName || dirname4(file.path).split("/").pop() || "";
       return `Package entry point for ${pkgName || "module"} (re-exports ${file.exports.reExported.length} symbols)`;
     }
     if (file.exports.named.length > 0) {
@@ -6447,6 +6500,26 @@ function isReparsePoint(path) {
     return false;
   }
 }
+function rglobParts(root, suffix) {
+  const found = [];
+  const go = (dir, parts2) => {
+    let entries;
+    try {
+      entries = readdirHook.entries(dir);
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = join10(dir, e.name);
+      if (e.isDirectory() && !isReparsePoint(full))
+        go(full, [...parts2, e.name]);
+      else if (e.name.endsWith(suffix))
+        found.push([...parts2, e.name]);
+    }
+  };
+  go(root, []);
+  return found.sort((a, b) => compareCodeUnits(a.join("/"), b.join("/")));
+}
 function entries(dir) {
   try {
     return readdirHook.entries(dir);
@@ -6668,8 +6741,8 @@ function discover(root, language = detectLanguage(root), skippedLinks) {
 }
 
 // src/map/graph.ts
-import { readFileSync as readFileSync8, statSync as statSync4 } from "node:fs";
-import { basename as basename3, join as join11, resolve as resolve3 } from "node:path";
+import { readFileSync as readFileSync9, statSync as statSync4 } from "node:fs";
+import { basename as basename3, join as join12, resolve as resolve4 } from "node:path";
 
 // node_modules/smol-toml/dist/error.js
 /*!
@@ -10977,6 +11050,20 @@ function parserFor(name2) {
   return parser;
 }
 
+// src/map/package-field.ts
+import { readFileSync as readFileSync8 } from "node:fs";
+import { join as join11 } from "node:path";
+function packageField(root, key) {
+  let pkg = null;
+  try {
+    pkg = JSON.parse(readFileSync8(join11(root, "package.json"), "utf8"));
+  } catch {}
+  if (typeof pkg !== "object" || pkg === null || Array.isArray(pkg))
+    return null;
+  const value = pkg[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
 // src/map/parsing.ts
 function emptyModule() {
   return {
@@ -11044,6 +11131,7 @@ function importClauseNames(clause) {
   return names;
 }
 var hasChild = (node, type) => node.children.some((c) => c.type === type);
+var allInlineTyped = (specifiers) => specifiers.length > 0 && specifiers.every((s) => hasChild(s, "type"));
 function isTypeOnlyImport(stmt, clause) {
   if (hasChild(stmt, "type"))
     return true;
@@ -11052,10 +11140,7 @@ function isTypeOnlyImport(stmt, clause) {
   const kids = clause.children.filter((c) => c.type !== ",");
   if (kids.length !== 1 || kids[0]?.type !== "named_imports")
     return false;
-  const specifiers = kids[0].children.filter((c) => c.type === "import_specifier");
-  if (specifiers.length === 0)
-    return false;
-  return specifiers.every((s) => hasChild(s, "type"));
+  return allInlineTyped(kids[0].children.filter((c) => c.type === "import_specifier"));
 }
 function defaultExportKindAndLocal(stmt) {
   for (const c of stmt.children) {
@@ -11120,11 +11205,10 @@ function exportClauseSourceNames(clause) {
 function isTypeOnlyExport(stmt, clause) {
   if (hasChild(stmt, "type"))
     return true;
-  const specifiers = clause.children.filter((c) => c.type === "export_specifier");
-  if (specifiers.length === 0)
-    return false;
-  return specifiers.every((s) => hasChild(s, "type"));
+  return allInlineTyped(clause.children.filter((c) => c.type === "export_specifier"));
 }
+var GAP = String.raw`(?:\s|/\*[\s\S]*?\*/)`;
+var EXPORT_TYPE_STAR = new RegExp(String.raw`^export${GAP}+type${GAP}*\*`, "u");
 function stripChars(text, chars) {
   let a = 0;
   let b = text.length;
@@ -11243,6 +11327,7 @@ function parseTs(source, path = "") {
         const nsExport = node.children.find((c) => c.type === "namespace_export");
         let names = [];
         let typeOnly = false;
+        const typeStar = hasChild(node, "type") || EXPORT_TYPE_STAR.test(node.text);
         if (clause) {
           names = exportClauseSourceNames(clause);
           typeOnly = isTypeOnlyExport(node, clause);
@@ -11250,11 +11335,12 @@ function parseTs(source, path = "") {
             mod.reExports.push(name2);
         } else if (nsExport) {
           names = ["*"];
+          typeOnly = typeStar;
           for (const [name2] of exportEntries(node))
             mod.reExports.push(name2);
         } else {
-          const typeStar = hasChild(node, "type") ? "type " : "";
-          mod.reExports.push(`${typeStar}* from ${specifierOf(spec)}`);
+          typeOnly = typeStar;
+          mod.reExports.push(`${typeStar ? "type " : ""}* from ${specifierOf(spec)}`);
         }
         mod.imports.push({ specifier: specifierOf(spec), names, typeOnly, reExport: true });
       }
@@ -12362,7 +12448,7 @@ var STRING_LITERAL = /['"]([^'"\n]*)['"]/g;
 var PATH_SEGMENT = new RegExp(`^(?:${W}|[.-])+$`, "u");
 var lstripDotSlash = (text) => text.replace(/^[./]+/, "");
 function launcherEntry(root, spec, known) {
-  const path = join11(root, lstripDotSlash(spec.replaceAll("\\", "/")));
+  const path = join12(root, lstripDotSlash(spec.replaceAll("\\", "/")));
   let text;
   try {
     const st = statSync4(path);
@@ -12410,7 +12496,7 @@ var isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 function packageJsonRoots(root, known) {
   let pkg;
   try {
-    pkg = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(readFileSync8(join11(root, "package.json"))));
+    pkg = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(readFileSync9(join12(root, "package.json"))));
   } catch {
     return [[], []];
   }
@@ -12458,7 +12544,7 @@ var PYTHON_FALLBACK_ROOTS = [
 ];
 function pythonRoots(root, known) {
   const warnings = [];
-  const pyproject = join11(root, "pyproject.toml");
+  const pyproject = join12(root, "pyproject.toml");
   let isFile = false;
   try {
     isFile = statSync4(pyproject).isFile();
@@ -12509,31 +12595,11 @@ function pythonRoots(root, known) {
 }
 var CSHARP_MAIN = new RegExp(`${B}static${S}+(?:async${S}+)?[^${SPACE_BODY}(){};]+${S}+Main${S}*\\(`, "u");
 var CSPROJ_EXE = new RegExp(`<OutputType>${S}*(Exe|WinExe)${S}*</OutputType>`, "iu");
-function rglobParts(root, suffix) {
-  const found = [];
-  const go = (dir, parts2) => {
-    let entries;
-    try {
-      entries = readdirHook.entries(dir);
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      const full = join11(dir, e.name);
-      if (e.isDirectory() && !isReparsePoint(full))
-        go(full, [...parts2, e.name]);
-      else if (e.name.endsWith(suffix))
-        found.push([...parts2, e.name]);
-    }
-  };
-  go(root, []);
-  return found.sort((a, b) => compareCodeUnits(a.join("/"), b.join("/")));
-}
 function csharpRoots(root, known) {
   const warnings = [];
   const declaresMain = (rel) => {
     try {
-      return CSHARP_MAIN.test(readSource(join11(root, rel)));
+      return CSHARP_MAIN.test(readSource(join12(root, rel)));
     } catch {
       return false;
     }
@@ -12544,7 +12610,7 @@ function csharpRoots(root, known) {
       continue;
     let text;
     try {
-      text = readSource(join11(root, ...parts2));
+      text = readSource(join12(root, ...parts2));
     } catch (error) {
       warnings.push(`could not read ${parts2.join("/")} (${error instanceof Error ? error.message : String(error)})`);
       continue;
@@ -12566,7 +12632,7 @@ function csharpRoots(root, known) {
       if (program.length > 0)
         roots.push(program[0]);
       else {
-        warnings.push(`${projDir || basename3(resolve3(root))} declares OutputType Exe but no file in it declares ` + "Main and none is named Program.cs; it contributes no root");
+        warnings.push(`${projDir || basename3(resolve4(root))} declares OutputType Exe but no file in it declares ` + "Main and none is named Program.cs; it contributes no root");
       }
     }
     if (roots.length > 0)
@@ -12602,7 +12668,7 @@ function workspaceRoots(root, known) {
       continue;
     const prefix = `${ws.directory}/`;
     const local = new Set([...known].filter((p) => p.startsWith(prefix)).map((p) => p.slice(prefix.length)));
-    const [found, pkgWarnings] = packageJsonRoots(join11(root, ws.directory), local);
+    const [found, pkgWarnings] = packageJsonRoots(join12(root, ws.directory), local);
     const pkgRoots = found.map((p) => prefix + p);
     for (const entry of ws.extraEntries)
       if (known.has(entry))
@@ -12651,7 +12717,7 @@ async function buildGraph(root) {
   const parsed = new Map;
   const sources = new Map;
   for (const f of found) {
-    const text = readSource(join11(root, f.path)).replace(/\r\n?/g, `
+    const text = readSource(join12(root, f.path)).replace(/\r\n?/g, `
 `);
     sources.set(f.path, text);
     parsed.set(f.path, read(text, f.path));
@@ -12781,7 +12847,7 @@ async function buildGraph(root) {
     warnings.push("could not determine any entry-point roots: no package.json main/module/bin/exports resolved " + "to a known source file, and no src/index.* fallback was found -- every 'src' file will show " + "as orphan or test-only rather than build-entry");
   }
   const graph = newRepoGraph({
-    name: basename3(resolve3(root)),
+    name: packageField(root, "name") ?? basename3(resolve4(root)),
     files,
     roots,
     warnings,
@@ -12885,7 +12951,7 @@ function pyJsonDumps(data) {
   return out2;
 }
 function writeJson(path, data) {
-  mkdirSync2(dirname6(path), { recursive: true });
+  mkdirSync2(dirname5(path), { recursive: true });
   writeFileSync2(path, `${pyJsonDumps(data)}
 `);
   return path;
@@ -12968,11 +13034,11 @@ function emitDependencyGraph(graph, outDir, options = {}) {
     ...graph.language === "typescript" ? exportKindStats(graph) : {}
   });
   data.warnings = [...graph.warnings];
-  return writeJson(join12(outDir, "dependency-graph.json"), data);
+  return writeJson(join13(outDir, "dependency-graph.json"), data);
 }
 function readJson(path) {
   try {
-    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(readFileSync9(path)));
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(readFileSync10(path)));
   } catch {
     return null;
   }
@@ -12982,7 +13048,7 @@ var PNPM_ITEM = new RegExp(`(?<=^|\\n)${S}*-${S}*['"]?([^'"${SPACE_BODY}#]+)['"]
 function pnpmWorkspacePatterns(root) {
   let text;
   try {
-    text = readSource(join12(root, "pnpm-workspace.yaml")).replace(/\r\n?/g, `
+    text = readSource(join13(root, "pnpm-workspace.yaml")).replace(/\r\n?/g, `
 `);
   } catch {
     return [];
@@ -13012,29 +13078,9 @@ function normalizeWorkspacePatterns(raw) {
     ]
   ];
 }
-function csprojParts(root) {
-  const found = [];
-  const go = (dir, parts2) => {
-    let entries;
-    try {
-      entries = readdirHook.entries(dir);
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      const full = join12(dir, e.name);
-      if (e.isDirectory() && !isReparsePoint(full))
-        go(full, [...parts2, e.name]);
-      else if (e.name.endsWith(".csproj"))
-        found.push([...parts2, e.name]);
-    }
-  };
-  go(root, []);
-  return found.sort((a, b) => compareCodeUnits(a.join("/"), b.join("/")));
-}
 function csprojMap(root) {
   const projects = new Map;
-  for (const parts2 of csprojParts(root)) {
+  for (const parts2 of rglobParts(root, ".csproj")) {
     if (parts2.some((p) => p === "obj" || p === "bin"))
       continue;
     const name2 = parts2.at(-1);
@@ -13052,13 +13098,13 @@ function csprojMap(root) {
 }
 function subdirs(dir) {
   try {
-    return readdirHook.entries(dir).filter((e) => e.isDirectory() || e.isSymbolicLink() && statSync5(join12(dir, e.name)).isDirectory()).map((e) => e.name).sort(compareCodeUnits);
+    return readdirHook.entries(dir).filter((e) => e.isDirectory() || e.isSymbolicLink() && statSync5(join13(dir, e.name)).isDirectory()).map((e) => e.name).sort(compareCodeUnits);
   } catch {
     return [];
   }
 }
 function workspaceMap(root) {
-  const pkg = readJson(join12(root, "package.json"));
+  const pkg = readJson(join13(root, "package.json"));
   if (!isObject3(pkg)) {
     return [
       new Map,
@@ -13092,18 +13138,18 @@ function workspaceMap(root) {
       const parent = pattern.slice(0, -2);
       let isDir = false;
       try {
-        isDir = statSync5(join12(root, parent)).isDirectory();
+        isDir = statSync5(join13(root, parent)).isDirectory();
       } catch {
         isDir = false;
       }
       if (!isDir)
         continue;
-      candidates = subdirs(join12(root, parent)).map((d) => parent ? `${parent}/${d}` : d);
+      candidates = subdirs(join13(root, parent)).map((d) => parent ? `${parent}/${d}` : d);
     } else {
       candidates = [pattern];
     }
     for (const relCand of candidates) {
-      const sub = readJson(join12(root, relCand, "package.json"));
+      const sub = readJson(join13(root, relCand, "package.json"));
       if (!isObject3(sub)) {
         warnings.push(`emit_file_inventory: workspace candidate '${relCand}' (matched by '${pattern}') has no readable package.json -- skipped, its files will report package '(root)'`);
         continue;
@@ -13163,7 +13209,7 @@ function emitFileInventory(graph, outDir) {
   }));
   const byDisposition = Object.fromEntries(DISPOSITIONS.map((d) => [d, 0]));
   Object.assign(byDisposition, counter(files.map((f) => f.disposition)));
-  return writeJson(join12(outDir, "file-inventory.json"), {
+  return writeJson(join13(outDir, "file-inventory.json"), {
     totalFiles: files.length,
     byDisposition,
     byArea: counter(files.map((f) => f.area)),
@@ -13197,7 +13243,7 @@ function readSourceText(rootPath, rel) {
   if (rootPath === null)
     return null;
   try {
-    return readSource(join12(rootPath, rel)).replace(/\r\n?/g, `
+    return readSource(join13(rootPath, rel)).replace(/\r\n?/g, `
 `);
   } catch {
     return null;
@@ -13352,7 +13398,7 @@ function emitDuplicateSymbols(graph, outDir, options = {}) {
       duplicates[sym] = paths;
   }
   const summary = { duplicateCount: Object.keys(duplicates).length, totalSymbols: owners.size };
-  const path = join12(outDir, "duplicate-symbols.json");
+  const path = join13(outDir, "duplicate-symbols.json");
   const root = graph.rootPath;
   if (graph.language !== "typescript" || root === null) {
     const reason = root === null ? "This graph has no root folder to read the definitions from." : `This repository reads as ${graph.language}.`;
@@ -13368,7 +13414,7 @@ function emitDuplicateSymbols(graph, outDir, options = {}) {
   const rootEntries = workspaces.size > 0 ? [] : rootPackageEntries(root);
   const surface = computePublicSurface(records, root, workspaces, rootEntries);
   const definers = records.filter((r) => !/\.d\.[cm]?ts$/.test(r.path));
-  const report = buildDuplicateReport(detectDuplicateSymbols(definers, surface, root, options.allowlistPath ?? join12(root, "docs", "architecture", "duplicate-allowlist.json")));
+  const report = buildDuplicateReport(detectDuplicateSymbols(definers, surface, root, options.allowlistPath ?? join13(root, "docs", "architecture", "duplicate-allowlist.json"), options.dispatchCalls), options.dispatchCalls);
   return writeJson(path, {
     note: DUPLICATES_CLASSIFIED_NOTE,
     classificationNote: report.note,
@@ -13384,7 +13430,7 @@ function emitUnusedAnalysis(graph, outDir) {
   const [unreferenced, referencedInModule, unclassified] = classifyUnusedExports(graph);
   const notes = unreferencedAnywhereNotes(graph, unreferenced);
   const noImporter = noImporterFiles(graph);
-  return writeJson(join12(outDir, "unused-analysis.json"), {
+  return writeJson(join13(outDir, "unused-analysis.json"), {
     caveats: caveatsFor(graph),
     summary: {
       unusedExportCount: countAll(unreferenced) + countAll(referencedInModule) + countAll(unclassified),
@@ -13402,16 +13448,16 @@ function emitUnusedAnalysis(graph, outDir) {
 }
 
 // src/map/coverage.ts
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 
 // src/depgraph/coverage.ts
-import { existsSync as existsSync6, readFileSync as readFileSync10 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync11 } from "node:fs";
+import { join as join14 } from "node:path";
 function loadCoveragePolicy(policyPath) {
   if (!existsSync6(policyPath))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync10(policyPath, "utf8"));
+    const parsed = JSON.parse(readFileSync11(policyPath, "utf8"));
     if (!parsed.categories || typeof parsed.categories !== "object")
       return null;
     return parsed;
@@ -13511,7 +13557,7 @@ function traceReExports(importedPath, reExportMap) {
     result.add(source);
   return result;
 }
-function analyzeTestCoverage(graphFiles, testFiles, root, policyPath = join13(outputDirOf(root), "coverage-policy.json")) {
+function analyzeTestCoverage(graphFiles, testFiles, root, policyPath = join14(outputDirOf(root), "coverage-policy.json")) {
   const sourceFiles = graphFiles.filter((f) => !f.path.endsWith(".d.ts"));
   const sourceFilePaths = new Set(sourceFiles.map((f) => f.path));
   const coverageMap = new Map;
@@ -13650,10 +13696,10 @@ function generateTestCoverageMarkdown(coverage, options = {}) {
   }
   lines.push("---");
   lines.push("");
-  lines.push("## Source Files Without Test Coverage");
+  lines.push("## Source Files Not Imported By A Test");
   lines.push("");
   if (coverage.untestedFiles.length === 0) {
-    lines.push("**All source files have test coverage!** \uD83C\uDF89");
+    lines.push("**Every source file is imported by a test file.** \uD83C\uDF89");
   } else {
     lines.push(`The following ${coverage.untestedFiles.length} source files are not directly imported by any test file:`);
     lines.push("");
@@ -13677,7 +13723,7 @@ function generateTestCoverageMarkdown(coverage, options = {}) {
   }
   lines.push("---");
   lines.push("");
-  lines.push("## Source Files With Test Coverage");
+  lines.push("## Source Files Imported By A Test");
   lines.push("");
   lines.push("| Source File | Test Files |");
   lines.push("|-------------|------------|");
@@ -13741,7 +13787,7 @@ function generateTestCoverageJson(coverage, options = {}) {
 
 // src/map/reports.ts
 import { readFileSync as readFileSync12 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 
 // src/depgraph/reporters/json.ts
 function modulesJsonOf(modules) {
@@ -13958,10 +14004,14 @@ function fileSection(lines, path, file) {
   lines.push("---");
   lines.push("");
 }
-function summaryRowsOf(stats) {
+var DEPGRAPH_LABELS = {
+  files: "Total TypeScript Files",
+  modules: "Total Modules"
+};
+function summaryRowsOf(stats, labels = DEPGRAPH_LABELS) {
   const rows = [
-    ["Total TypeScript Files", stats.totalTypeScriptFiles],
-    ["Total Modules", stats.totalModules],
+    [labels.files, stats.totalTypeScriptFiles],
+    [labels.modules, stats.totalModules],
     ["Total Lines of Code", stats.totalLinesOfCode],
     ["Total Exports", stats.totalExports],
     ["Total Re-exports", stats.totalReExports],
@@ -14104,20 +14154,12 @@ function generateYaml(json, dumpFn = dump) {
 }
 
 // src/map/layers.ts
-import { readFileSync as readFileSync11 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 function projectIdentity(root, graph) {
-  let pkg = null;
-  try {
-    pkg = JSON.parse(readFileSync11(join14(root, "package.json"), "utf8"));
-  } catch {}
-  const field = (key) => {
-    if (typeof pkg !== "object" || pkg === null || Array.isArray(pkg))
-      return null;
-    const value = pkg[key];
-    return typeof value === "string" && value.length > 0 ? value : null;
+  return {
+    name: packageField(root, "name") ?? graph.name,
+    version: packageField(root, "version") ?? "unknown"
   };
-  return { name: field("name") ?? graph.name, version: field("version") ?? "unknown" };
 }
 function subsystemView(graph, root, warn = () => {}) {
   const records = toParsedFiles(graph, root);
@@ -14129,7 +14171,7 @@ function subsystemView(graph, root, warn = () => {}) {
 }
 function emitDependencyLayers(graph, root, outDir, view = subsystemView(graph, root)) {
   const identity = projectIdentity(root, graph);
-  return writeJson(join14(outDir, "dependency-layers.json"), {
+  return writeJson(join15(outDir, "dependency-layers.json"), {
     metadata: {
       name: identity.name,
       version: identity.version,
@@ -14168,33 +14210,14 @@ function statisticsFromCore(core, subsystems) {
     unusedExportsCount: num("unusedExportsCount")
   };
 }
-function summaryRows(stats) {
-  const rows = [
-    ["Total Source Files", stats.totalTypeScriptFiles],
-    ["Subsystems", stats.totalModules],
-    ["Total Lines of Code", stats.totalLinesOfCode],
-    ["Total Exports", stats.totalExports],
-    ["Total Re-exports", stats.totalReExports],
-    ["Total Classes", stats.totalClasses],
-    ["Total Interfaces", stats.totalInterfaces],
-    ["Total Functions", stats.totalFunctions],
-    ["Total Type Guards", stats.totalTypeGuards],
-    ["Total Enums", stats.totalEnums],
-    ["Type-only Imports", stats.totalTypeOnlyImports],
-    ["Runtime Cyclic Components", stats.runtimeCyclicComponents],
-    ["Type-only Cyclic Components", stats.typeOnlyCyclicComponents],
-    ["Files in Runtime Cycles", stats.runtimeFilesInCycles],
-    ["Files in Type-only Cycles", stats.typeOnlyFilesInCycles]
-  ];
-  return rows.filter((r) => r[1] !== undefined);
-}
+var SUMMARY_LABELS = { files: "Total Source Files", modules: "Subsystems" };
 function emitSubsystemReports(graph, root, outDir, corePath, options = {}) {
   const view = options.view ?? subsystemView(graph, root);
   const core = JSON.parse(readFileSync12(corePath, "utf8"));
   const stats = statisticsFromCore(core.statistics, Object.keys(view.modules).length);
   const identity = projectIdentity(root, graph);
   const banner = { command: MAP_REGENERATE_COMMAND, ...options.banner };
-  const markdown = generateMarkdown(view.records, view.modules, stats, view.cycles, buildDependencyMatrix(view.records), identity, summaryRows(stats));
+  const markdown = generateMarkdown(view.records, view.modules, stats, view.cycles, buildDependencyMatrix(view.records), identity, summaryRowsOf(stats, SUMMARY_LABELS));
   const written = [
     ["DEPENDENCY_GRAPH.md", withBanner(markdown, banner)],
     ["dependency-graph.yaml", generateYaml(core)],
@@ -14204,7 +14227,7 @@ function emitSubsystemReports(graph, root, outDir, corePath, options = {}) {
     ]
   ];
   return written.map(([name2, text]) => {
-    const path = join15(outDir, name2);
+    const path = join16(outDir, name2);
     writeReport(path, text);
     return path;
   });
@@ -14222,9 +14245,9 @@ function isTestFile(path, language, area) {
 function emitTestCoverage(graph, root, outDir, options = {}) {
   const sources = toParsedFiles(graph, root);
   const tests = toParsedFiles(graph, root, { allAreas: true, loadEdges: true }).filter((r) => isTestFile(r.path, graph.language, graph.files.get(r.path)?.area ?? ""));
-  const coverage = analyzeTestCoverage(sources, tests, root, options.policyPath ?? join16(root, "docs", "architecture", "coverage-policy.json"));
-  const mdPath = join16(outDir, "TEST_COVERAGE.md");
-  const jsonPath = join16(outDir, "test-coverage.json");
+  const coverage = analyzeTestCoverage(sources, tests, root, options.policyPath ?? join17(root, "docs", "architecture", "coverage-policy.json"));
+  const mdPath = join17(outDir, "TEST_COVERAGE.md");
+  const jsonPath = join17(outDir, "test-coverage.json");
   const namespaceImportBasis = !importsNameSymbols(graph.language);
   const markdown = generateTestCoverageMarkdown(coverage, {
     expectedTestHint: graph.language === "typescript" && tests.some((t) => t.path.startsWith("tests/unit/")),
@@ -14238,7 +14261,7 @@ function emitTestCoverage(graph, root, outDir, options = {}) {
 
 // src/map/markdown.ts
 import { readFileSync as readFileSync13 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 
 // src/depgraph/reporters/duplicates.ts
 function summaryTable(byTag, total) {
@@ -14278,7 +14301,7 @@ function renderTaggedSection(title, entries, tag) {
 
 ${renderTable(entries.filter((e) => e.tag === tag))}`;
 }
-function generateDuplicateSymbolsMarkdown(report) {
+function generateDuplicateSymbolsMarkdown(report, dispatchCalls = DEFAULT_DISPATCH_CALLS) {
   let md = `# Duplicate Symbols
 
 `;
@@ -14286,9 +14309,14 @@ function generateDuplicateSymbolsMarkdown(report) {
   md += "A file that only re-exports the name does not count. ";
   md += "Each name carries one tag (see `DupEntryTag`), so the actionable subset is clear:\n\n";
   md += "- `TRUE_DUPLICATE`: a real merge target.\n";
-  md += "- `DISPATCH_VARIANT`: two or more `mathTyped(...)` registrations of the same public name. ";
-  md += `The registrations are distinct dispatch surfaces, not copy-paste bodies.
+  if (dispatchCalls.length === 0) {
+    md += "- `DISPATCH_VARIANT`: never set, because no dispatch call is configured.\n";
+  } else {
+    md += `- \`DISPATCH_VARIANT\`: two or more ${describeDispatchCalls(dispatchCalls, true)} `;
+    md += "registrations of the same public name. ";
+    md += `The registrations are distinct dispatch surfaces, not copy-paste bodies.
 `;
+  }
   md += "- `ALIAS_DELEGATION`: a `const X = importedY` forward. ";
   md += `The entry is excluded once fewer than two real bodies remain.
 `;
@@ -14383,7 +14411,7 @@ function inventoryMarkdown(inv, language) {
   return lines.join(`
 `);
 }
-function duplicatesMarkdown(dup) {
+function duplicatesMarkdown(dup, dispatchCalls = DEFAULT_DISPATCH_CALLS) {
   if (Array.isArray(dup.runtime) && Array.isArray(dup.types)) {
     const report = {
       note: dup.classificationNote,
@@ -14396,7 +14424,7 @@ function duplicatesMarkdown(dup) {
       runtime: dup.runtime,
       types: dup.types
     };
-    return generateDuplicateSymbolsMarkdown(report);
+    return generateDuplicateSymbolsMarkdown(report, dispatchCalls);
   }
   const lines = ["# Duplicate Symbols", ""];
   lines.push(`> **Note:** ${dup.note}`, "", `> ${dup.classificationNote}`, "");
@@ -14467,17 +14495,17 @@ function unusedMarkdown(unused, graph) {
   return lines.join(`
 `);
 }
-function emitMarkdownReports(outDir, banner = {}) {
-  const read = (name2) => JSON.parse(readFileSync13(join17(outDir, name2), "utf8"));
+function emitMarkdownReports(outDir, banner = {}, dispatchCalls = DEFAULT_DISPATCH_CALLS) {
+  const read = (name2) => JSON.parse(readFileSync13(join18(outDir, name2), "utf8"));
   const graph = read("dependency-graph.json");
   const bannerOptions = { command: MAP_REGENERATE_COMMAND, ...banner };
   const reports = [
     ["FILE_INVENTORY.md", inventoryMarkdown(read("file-inventory.json"), graph.metadata.language)],
-    ["duplicate-symbols.md", duplicatesMarkdown(read("duplicate-symbols.json"))],
+    ["duplicate-symbols.md", duplicatesMarkdown(read("duplicate-symbols.json"), dispatchCalls)],
     ["unused-analysis.md", unusedMarkdown(read("unused-analysis.json"), graph)]
   ];
   return reports.map(([name2, body2]) => {
-    const path = join17(outDir, name2);
+    const path = join18(outDir, name2);
     writeReport(path, withBanner(body2, bannerOptions));
     return path;
   });
@@ -14485,7 +14513,7 @@ function emitMarkdownReports(outDir, banner = {}) {
 
 // src/map/surfaces.ts
 import { readFileSync as readFileSync14 } from "node:fs";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 
 // src/depgraph/reporters/surfaces.ts
 function packageKeyOf(moduleKey) {
@@ -14520,7 +14548,7 @@ function emitApiSurface(graph, root, outPath, entry, stabilityTags) {
   if (graph.language === "typescript") {
     const load = (p) => {
       try {
-        return readFileSync14(join18(root, p), "utf8");
+        return readFileSync14(join19(root, p), "utf8");
       } catch {
         return null;
       }
@@ -14566,7 +14594,7 @@ function sortedSurfaces(map) {
   return out2;
 }
 function emitExportSurfaces(graph, root, outDir) {
-  const path = join18(outDir, "package-export-surfaces.json");
+  const path = join19(outDir, "package-export-surfaces.json");
   if (graph.language === "typescript") {
     const records = toParsedFiles(graph, root);
     const workspaces = detectWorkspaces(root);
@@ -14694,7 +14722,7 @@ async function runMap(argv, io, command = "map") {
 `);
     if (options.strictOrphans)
       options.settings.strictOrphans = true;
-    root = resolve4(options.root);
+    root = resolve5(options.root);
     if (!isDirectory(root))
       throw new Error("the root <root> is not an existing directory");
     const fileSettings = loadConfigFile(root, options.config);
@@ -14761,13 +14789,14 @@ async function runPipeline(root, options, config, io) {
   const corePath = emitDependencyGraph(graph, outDir);
   written.push(corePath, emitFileInventory(graph, outDir));
   written.push(emitDuplicateSymbols(graph, outDir, {
-    allowlistPath: resolveUnderRoot(root, config.duplicateAllowlist)
+    allowlistPath: resolveUnderRoot(root, config.duplicateAllowlist),
+    dispatchCalls: config.dispatchCalls
   }));
   written.push(emitUnusedAnalysis(graph, outDir));
   const view = subsystemView(graph, root);
   written.push(emitDependencyLayers(graph, root, outDir, view));
   written.push(...emitSubsystemReports(graph, root, outDir, corePath, { view, banner }));
-  written.push(...emitMarkdownReports(outDir, banner));
+  written.push(...emitMarkdownReports(outDir, banner, config.dispatchCalls));
   written.push(...emitTestCoverage(graph, root, outDir, {
     policyPath: resolveUnderRoot(root, config.coveragePolicy),
     policyNote: config.coveragePolicy.replace(/\\/g, "/"),
@@ -14971,7 +15000,7 @@ function parseClaims(markdown) {
 // src/check/metrics.ts
 import { mkdtempSync, readFileSync as readFileSync16, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 var readReport = (path) => JSON.parse(readFileSync16(path, "utf8"));
 function section(report, key) {
   const value = report[key];
@@ -14989,11 +15018,14 @@ function addScalars(into, source) {
 }
 async function collectMetrics(root, options = {}) {
   const graph = await graphOf(root);
-  const scratch = mkdtempSync(join19(options.scratchBase ?? tmpdir(), "repo-tools-check-"));
+  const scratch = mkdtempSync(join20(options.scratchBase ?? tmpdir(), "repo-tools-check-"));
   try {
     const dep = readReport(emitDependencyGraph(graph, scratch));
     const inventory = readReport(emitFileInventory(graph, scratch));
-    const duplicates = readReport(emitDuplicateSymbols(graph, scratch, options.allowlistPath === undefined ? {} : { allowlistPath: options.allowlistPath }));
+    const duplicates = readReport(emitDuplicateSymbols(graph, scratch, {
+      ...options.allowlistPath === undefined ? {} : { allowlistPath: options.allowlistPath },
+      ...options.dispatchCalls === undefined ? {} : { dispatchCalls: options.dispatchCalls }
+    }));
     const unused = readReport(emitUnusedAnalysis(graph, scratch));
     const metrics = new Map;
     addScalars(metrics, section(dep, "metadata"));
@@ -15191,7 +15223,7 @@ function readDocs(dir, label) {
   return names.map((name2) => {
     let bytes;
     try {
-      bytes = readFileSync17(join20(dir, name2));
+      bytes = readFileSync17(join21(dir, name2));
     } catch {
       throw new Error(`cannot read ${label}/${name2}`);
     }
@@ -15218,16 +15250,17 @@ async function run2(argv, io) {
   const stderr = (text) => io.stderr(root ? maskRoot(text, root) : text);
   try {
     const options = parseCheckArgs(argv, process.cwd());
-    root = resolve5(options.root);
+    root = resolve6(options.root);
     if (!isDirectory(root))
       throw new Error("the root <root> is not an existing directory");
     if (options.docs === undefined)
       throw new Error("flag --docs is required: --docs=<dir>");
     const config = mergeMapConfig({}, loadConfigFile(root, options.config));
     const label = isAbsolutePath(options.docs) ? "<docs>" : `<root>/${options.docs.replace(/\\/g, "/")}`;
-    const docs = readDocs(resolve5(root, options.docs), label);
+    const docs = readDocs(resolve6(root, options.docs), label);
     const measured = await collectMetrics(root, {
-      allowlistPath: resolve5(root, config.duplicateAllowlist)
+      allowlistPath: resolve6(root, config.duplicateAllowlist),
+      dispatchCalls: config.dispatchCalls
     });
     const markers = [NO_VERIFICATION_MARKER];
     if (config.verificationMarker !== null && !markers.includes(config.verificationMarker)) {
@@ -15259,12 +15292,12 @@ import {
   statSync as statSync7,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { basename as basename7, dirname as dirname7, extname as extname2, isAbsolute as isAbsolute3, join as join21, relative as relative4, resolve as resolve7, sep as sep3 } from "node:path";
+import { basename as basename7, dirname as dirname6, extname as extname2, isAbsolute as isAbsolute3, join as join22, relative as relative4, resolve as resolve8, sep as sep3 } from "node:path";
 
 // src/chunk/manifest.ts
 import { createHash } from "node:crypto";
 import { readFileSync as readFileSync18 } from "node:fs";
-import { posix as posix3, relative as relative3, resolve as resolve6, sep as sep2, win32 as win322 } from "node:path";
+import { posix as posix3, relative as relative3, resolve as resolve7, sep as sep2, win32 as win322 } from "node:path";
 
 // src/chunk/splitters.ts
 import { extname } from "node:path";
@@ -15895,7 +15928,7 @@ function relativeSource(manifestDir, sourcePath) {
   return relative3(manifestDir, sourcePath).split(sep2).join("/");
 }
 function resolveSource(manifestDir, sourceFile) {
-  return resolve6(manifestDir, sourceFile);
+  return resolve7(manifestDir, sourceFile);
 }
 function readManifest(path) {
   return validateManifest(JSON.parse(readFileSync18(path, "utf8")));
@@ -16114,34 +16147,18 @@ function isOutsideText(folder, path) {
   const rel = relative4(folder, path);
   return rel === ".." || rel.startsWith(`..${sep3}`) || isAbsolute3(rel);
 }
-function realPath2(path) {
-  let existing = resolve7(path);
-  const rest = [];
-  while (!lstatSync4(existing, { throwIfNoEntry: false })) {
-    const up = dirname7(existing);
-    if (up === existing)
-      return;
-    rest.unshift(basename7(existing));
-    existing = up;
-  }
-  try {
-    return join21(realpathSync2.native(existing), ...rest);
-  } catch {
-    return;
-  }
-}
 function isOutside(folder, path) {
   if (isOutsideText(folder, path))
     return true;
-  const realFolder = realPath2(folder);
-  const realTarget = realPath2(path);
+  const realFolder = realPath(folder);
+  const realTarget = realPath(path);
   return realFolder === undefined || realTarget === undefined || isOutsideText(realFolder, realTarget);
 }
 function isInside(folder, path) {
   if (!isOutsideText(folder, path))
     return true;
-  const realFolder = realPath2(folder);
-  const realTarget = realPath2(path);
+  const realFolder = realPath(folder);
+  const realTarget = realPath(path);
   return realFolder !== undefined && realTarget !== undefined && !isOutsideText(realFolder, realTarget);
 }
 function chunkFolderError(chunksDir, paths) {
@@ -16154,11 +16171,11 @@ function chunkFolderError(chunksDir, paths) {
   return;
 }
 function outsideError(sourcePath, chunksDir, remedy) {
-  return `Error: the source file ${sourcePath} is outside ${dirname7(chunksDir)}, the parent folder of the chunk folder. ${remedy}
+  return `Error: the source file ${sourcePath} is outside ${dirname6(chunksDir)}, the parent folder of the chunk folder. ${remedy}
 `;
 }
 function readChunk(chunksDir, filename) {
-  const chunkPath = join21(chunksDir, filename);
+  const chunkPath = join22(chunksDir, filename);
   const stat = lstatSync4(chunkPath, { throwIfNoEntry: false });
   if (!stat)
     return;
@@ -16192,7 +16209,7 @@ function split(inputFile, options, io) {
   const log = lineWriter(io);
   const maxLines = options.maxLines ?? 500;
   const dryRun = options.dryRun ?? false;
-  const absoluteInput = resolve7(inputFile);
+  const absoluteInput = resolve8(inputFile);
   if (!existsSync8(absoluteInput)) {
     io.stderr(`Error: File not found: ${absoluteInput}
 `);
@@ -16209,7 +16226,7 @@ function split(inputFile, options, io) {
   const content = readFileSync19(absoluteInput, "utf8");
   const sourceHash = contentHash(content);
   const baseName = basename7(inputFile, extname2(inputFile));
-  const outputDir = options.output ? resolve7(options.output) : join21(dirname7(absoluteInput), `${baseName}_chunks`);
+  const outputDir = options.output ? resolve8(options.output) : join22(dirname6(absoluteInput), `${baseName}_chunks`);
   const sourceFile = relativeSource(outputDir, absoluteInput);
   if (isAbsoluteAnywhere(sourceFile)) {
     io.stderr(`Error: the chunk folder ${outputDir} is on another volume than ${absoluteInput}. Nothing was written. Put the chunk folder on the same volume as the source file.
@@ -16251,7 +16268,7 @@ chunker - Splitting File`);
     const large = lineCount > maxLines ? " ⚠️  [LARGE]" : "";
     log(`  ${String(i2 + 1).padStart(2)}. [${levelIndicator(fileType, section.level).padEnd(4)}] ${section.title.substring(0, 40).padEnd(40)} ${String(lineCount).padStart(4)} lines${large}`);
     if (!dryRun)
-      writeLf(join21(outputDir, filename), section.content);
+      writeLf(join22(outputDir, filename), section.content);
     return {
       index: i2 + 1,
       filename,
@@ -16275,7 +16292,7 @@ chunker - Splitting File`);
     ...lineEnding === "crlf" ? { lineEnding } : {},
     ...lineEnding === "mixed" ? { lineBreaks: lineBreakRuns(content) } : {}
   };
-  const manifestPath = join21(outputDir, MANIFEST_NAME);
+  const manifestPath = join22(outputDir, MANIFEST_NAME);
   if (!dryRun) {
     writeManifest(manifestPath, manifest);
     log(`
@@ -16304,7 +16321,7 @@ To edit: Modify individual chunk files in the directory`);
 function merge(manifestFile, options, io) {
   const log = lineWriter(io);
   const dryRun = options.dryRun ?? false;
-  const absoluteManifest = resolve7(manifestFile);
+  const absoluteManifest = resolve8(manifestFile);
   if (!existsSync8(absoluteManifest)) {
     io.stderr(`Error: Manifest not found: ${absoluteManifest}
 `);
@@ -16317,17 +16334,17 @@ function merge(manifestFile, options, io) {
     return 1;
   }
   const manifest = readManifest(absoluteManifest);
-  const chunksDir = dirname7(absoluteManifest);
+  const chunksDir = dirname6(absoluteManifest);
   const sourcePath = resolveSource(chunksDir, manifest.sourceFile);
   const selfError = chunkFolderError(chunksDir, {
     "source file": sourcePath,
-    ...options.output ? { "output file": resolve7(options.output) } : {}
+    ...options.output ? { "output file": resolve8(options.output) } : {}
   });
   if (selfError) {
     io.stderr(selfError);
     return 1;
   }
-  const outside = isOutside(dirname7(chunksDir), sourcePath);
+  const outside = isOutside(dirname6(chunksDir), sourcePath);
   if (outside && !options.output && !options.yes) {
     io.stderr(outsideError(sourcePath, chunksDir, "Use -o <file> to name the target, or --yes to confirm."));
     return 1;
@@ -16350,7 +16367,7 @@ chunker - Merging Chunks`);
   for (const chunk of manifest.chunks) {
     const content = readChunk(chunksDir, chunk.filename);
     if (content === undefined) {
-      io.stderr(`Error: Missing chunk file: ${join21(chunksDir, chunk.filename)}
+      io.stderr(`Error: Missing chunk file: ${join22(chunksDir, chunk.filename)}
 `);
       return 1;
     }
@@ -16383,7 +16400,7 @@ Modified chunks: ${modifiedCount} of ${manifest.chunks.length}`);
 NOTE: the number of lines changed. All line breaks use the most common original one.`);
     }
   }
-  const outputPath = options.output ? resolve7(options.output) : sourcePath;
+  const outputPath = options.output ? resolve8(options.output) : sourcePath;
   if (readSource && existsSync8(sourcePath)) {
     const currentSourceHash = hash(readFileSync19(sourcePath, "utf8"));
     if (currentSourceHash !== manifest.sourceHash) {
@@ -16424,7 +16441,7 @@ Merged file written: ${outputPath}`);
 }
 function status(manifestFile, options, io) {
   const log = lineWriter(io);
-  const absoluteManifest = resolve7(manifestFile);
+  const absoluteManifest = resolve8(manifestFile);
   if (!existsSync8(absoluteManifest)) {
     io.stderr(`Error: Manifest not found: ${absoluteManifest}
 `);
@@ -16437,14 +16454,14 @@ function status(manifestFile, options, io) {
     return 1;
   }
   const manifest = readManifest(absoluteManifest);
-  const chunksDir = dirname7(absoluteManifest);
+  const chunksDir = dirname6(absoluteManifest);
   const sourcePath = resolveSource(chunksDir, manifest.sourceFile);
   const selfError = chunkFolderError(chunksDir, { "source file": sourcePath });
   if (selfError) {
     io.stderr(selfError);
     return 1;
   }
-  if (isOutside(dirname7(chunksDir), sourcePath) && !options.yes) {
+  if (isOutside(dirname6(chunksDir), sourcePath) && !options.yes) {
     io.stderr(outsideError(sourcePath, chunksDir, "Use --yes to read it."));
     return 1;
   }
@@ -16564,9 +16581,668 @@ ${CHUNK_HELP}`);
   }
 }
 
+// src/clones/index.ts
+import { join as join23, resolve as resolve9 } from "node:path";
+
+// src/clones/detect.ts
+function fnv1a(text) {
+  let h = 2166136261;
+  for (let i2 = 0;i2 < text.length; i2++) {
+    h ^= text.charCodeAt(i2);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function groupsBy(units, key) {
+  const groups = new Map;
+  units.forEach((unit, id) => {
+    const ids = groups.get(key(unit));
+    if (ids)
+      ids.push(id);
+    else
+      groups.set(key(unit), [id]);
+  });
+  return [...groups.values()].filter((ids) => ids.length > 1);
+}
+function shinglesOf(labels, length) {
+  const set = new Set;
+  for (let i2 = 0;i2 + length <= labels.length; i2++) {
+    set.add(fnv1a(labels.slice(i2, i2 + length).join("|")));
+  }
+  return set;
+}
+function nested(a, b) {
+  if (a.file !== b.file)
+    return false;
+  const aInB = b.startIndex <= a.startIndex && a.endIndex <= b.endIndex;
+  const bInA = a.startIndex <= b.startIndex && b.endIndex <= a.endIndex;
+  return aInB || bInA;
+}
+function overlap(small, big) {
+  let shared = 0;
+  for (const item of small)
+    if (big.has(item))
+      shared++;
+  return shared;
+}
+function round3(value) {
+  return Number(value.toFixed(3));
+}
+function detect(units, params) {
+  const exactGroups = groupsBy(units, (u) => u.exactHash);
+  const textGroups = groupsBy(units, (u) => u.textHash);
+  const shingles = units.map((u) => shinglesOf(u.labels, params.shingleLength));
+  const index = new Map;
+  shingles.forEach((set, id) => {
+    for (const shingle of set) {
+      const ids = index.get(shingle);
+      if (ids)
+        ids.push(id);
+      else
+        index.set(shingle, [id]);
+    }
+  });
+  const near = [];
+  units.forEach((unit, id) => {
+    const mine = shingles[id];
+    const shared = new Map;
+    for (const shingle of mine) {
+      const ids = index.get(shingle);
+      if (ids.length > params.rareShingleLimit)
+        continue;
+      for (const other of ids)
+        if (other > id)
+          shared.set(other, (shared.get(other) ?? 0) + 1);
+    }
+    for (const [other, count] of shared) {
+      if (count < params.minSharedShingles)
+        continue;
+      const peer = units[other];
+      if (nested(unit, peer))
+        continue;
+      const theirs = shingles[other];
+      const [small, big] = mine.size <= theirs.size ? [mine, theirs] : [theirs, mine];
+      const inter = overlap(small, big);
+      const jaccard = inter / (mine.size + theirs.size - inter);
+      const contain = inter / small.size;
+      const byContainment = contain >= params.containmentThreshold && small.size >= params.containmentMinShingles;
+      if (jaccard < params.nearThreshold && !byContainment)
+        continue;
+      const common = overlap(unit.names, peer.names);
+      const union = unit.names.size + peer.names.size - common;
+      near.push({
+        a: id,
+        b: other,
+        jStruct: round3(jaccard),
+        contain: round3(contain),
+        jNames: round3(common / (union || 1))
+      });
+    }
+  });
+  near.sort((x, y) => y.jStruct - x.jStruct || x.a - y.a || x.b - y.b);
+  return { exactGroups, textGroups, near };
+}
+
+// src/clones/report.ts
+function inventoryRecord(unit, id) {
+  return {
+    id,
+    file: unit.file,
+    name: unit.name,
+    container: unit.container,
+    kind: unit.kind,
+    exported: unit.exported,
+    startLine: unit.startLine,
+    endLine: unit.endLine,
+    loc: unit.loc,
+    params: unit.params,
+    async: unit.async,
+    nodes: unit.nodes,
+    doc: unit.doc,
+    exactHash: unit.exactHash,
+    textHash: unit.textHash
+  };
+}
+function inventoryJsonl(units) {
+  return units.map((unit, id) => `${JSON.stringify(inventoryRecord(unit, id))}
+`).join("");
+}
+function listJson(items) {
+  if (items.length === 0)
+    return "[]";
+  return `[
+${items.map((item) => `    ${JSON.stringify(item)}`).join(`,
+`)}
+  ]`;
+}
+function clonesJson(config, detection) {
+  const { out: _out, parseErrorList: _list, ...params } = config;
+  return [
+    "{",
+    `  "params": ${JSON.stringify(params)},`,
+    `  "exactGroups": ${listJson(detection.exactGroups)},`,
+    `  "textGroups": ${listJson(detection.textGroups)},`,
+    `  "near": ${listJson(detection.near)}`,
+    "}",
+    ""
+  ].join(`
+`);
+}
+var SUMMARY_BANDS = [
+  ["0.9 or more", 0.9, Number.POSITIVE_INFINITY],
+  ["0.8 to 0.9", 0.8, 0.9],
+  ["0.7 to 0.8", 0.7, 0.8],
+  ["0.6 to 0.7", 0.6, 0.7],
+  ["below 0.6 (containment)", 0, 0.6]
+];
+function folderOf(file) {
+  const parts2 = file.split("/").slice(0, -1);
+  return parts2.length === 0 ? "." : parts2.slice(0, 2).join("/");
+}
+function percentile(sorted, p) {
+  return sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * p))] ?? 0;
+}
+function summaryText(config, stats, units, detection) {
+  const sizes = units.map((u) => u.nodes).sort((a, b) => a - b);
+  const inGroups = detection.exactGroups.reduce((sum, group) => sum + group.length, 0);
+  const bands = SUMMARY_BANDS.map(([label, lo, hi]) => `${label}: ${detection.near.filter((p) => p.jStruct >= lo && p.jStruct < hi).length}`);
+  const byFolder = new Map;
+  for (const unit of units) {
+    const key = folderOf(unit.file);
+    byFolder.set(key, (byFolder.get(key) ?? 0) + 1);
+  }
+  const folders = [...byFolder.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, count]) => `${key}=${count}`).join(" ");
+  const failed = stats.parseErrorFiles.length;
+  const paths = [...stats.parseErrorFiles].sort((a, b) => a < b ? -1 : a > b ? 1 : 0).slice(0, config.parseErrorList);
+  const errorList = failed === 0 ? [] : [
+    `files with a parse error (${paths.length < failed ? "first " : ""}${paths.length} of ${failed}):`,
+    ...paths.map((path) => `  ${path}`)
+  ];
+  const lines = [
+    `files=${stats.files} parseErrors=${failed} units(minNodes=${config.minNodes})=${units.length}`,
+    ...errorList,
+    `nodes p50=${percentile(sizes, 0.5)} p90=${percentile(sizes, 0.9)} p99=${percentile(sizes, 0.99)} max=${sizes[sizes.length - 1] ?? 0}`,
+    `exact groups=${detection.exactGroups.length} (units in them=${inGroups}) text-identical groups=${detection.textGroups.length}`,
+    `near pairs=${detection.near.length} by jStruct: ${bands.join(", ")}`,
+    `units by folder: ${folders}`
+  ];
+  return `${lines.join(`
+`)}
+`;
+}
+
+// src/clones/settings.ts
+var CLONES_DEFAULTS = Object.freeze({
+  src: "auto",
+  out: null,
+  minNodes: 50,
+  shingleLength: 6,
+  nearThreshold: 0.6,
+  containmentThreshold: 0.9,
+  containmentMinShingles: 20,
+  rareShingleLimit: 60,
+  minSharedShingles: 3,
+  parseErrorList: 20
+});
+function mergeClonesConfig(cli, file) {
+  const d = CLONES_DEFAULTS;
+  const src = cli.src ?? file.src ?? d.src;
+  return {
+    src: src === "auto" ? src : [...src],
+    out: cli.out !== undefined ? cli.out : file.out !== undefined ? file.out : d.out,
+    minNodes: cli.minNodes ?? file.minNodes ?? d.minNodes,
+    shingleLength: cli.shingleLength ?? file.shingleLength ?? d.shingleLength,
+    nearThreshold: cli.nearThreshold ?? file.nearThreshold ?? d.nearThreshold,
+    containmentThreshold: cli.containmentThreshold ?? file.containmentThreshold ?? d.containmentThreshold,
+    containmentMinShingles: cli.containmentMinShingles ?? file.containmentMinShingles ?? d.containmentMinShingles,
+    rareShingleLimit: cli.rareShingleLimit ?? file.rareShingleLimit ?? d.rareShingleLimit,
+    minSharedShingles: cli.minSharedShingles ?? file.minSharedShingles ?? d.minSharedShingles,
+    parseErrorList: cli.parseErrorList ?? file.parseErrorList ?? d.parseErrorList
+  };
+}
+
+// src/clones/units.ts
+import { createHash as createHash2 } from "node:crypto";
+
+// src/clones/normalise.ts
+var IDENTIFIERS = new Set([
+  "identifier",
+  "property_identifier",
+  "shorthand_property_identifier",
+  "shorthand_property_identifier_pattern",
+  "private_property_identifier",
+  "statement_identifier",
+  "undefined"
+]);
+var LITERALS = new Set(["string", "number", "regex", "true", "false", "null"]);
+var TYPE_SYNTAX = new Set([
+  "type_annotation",
+  "type_arguments",
+  "type_parameters",
+  "type_alias_declaration",
+  "interface_declaration",
+  "enum_declaration",
+  "ambient_declaration",
+  "asserts_annotation",
+  "opting_type_annotation",
+  "omitting_type_annotation",
+  "type_predicate_annotation",
+  "accessibility_modifier",
+  "override_modifier",
+  "decorator",
+  "comment"
+]);
+var TRANSPARENT = new Set([
+  "parenthesized_expression",
+  "as_expression",
+  "satisfies_expression",
+  "non_null_expression",
+  "type_assertion",
+  "instantiation_expression"
+]);
+var TEMPLATE_TEXT = new Set(["string_fragment", "escape_sequence"]);
+function wrapped(node) {
+  const children = node.namedChildren;
+  return (node.type === "type_assertion" ? children[children.length - 1] : children[0]) ?? null;
+}
+function walk2(node, out2) {
+  if (!node.isNamed)
+    return;
+  const type = node.type;
+  if (TYPE_SYNTAX.has(type))
+    return;
+  if (TRANSPARENT.has(type)) {
+    const inner = wrapped(node);
+    if (inner)
+      walk2(inner, out2);
+    return;
+  }
+  if (IDENTIFIERS.has(type)) {
+    out2.labels.push("ID");
+    out2.names.add(node.text.toLowerCase());
+    return;
+  }
+  if (LITERALS.has(type)) {
+    out2.labels.push("LIT");
+    return;
+  }
+  if (TEMPLATE_TEXT.has(type)) {
+    out2.labels.push("TPL");
+    return;
+  }
+  if (type !== "template_substitution") {
+    const operator = node.childForFieldName("operator");
+    out2.labels.push(operator ? `${type}:${operator.type}` : type);
+  }
+  for (const child of node.children)
+    walk2(child, out2);
+}
+function normalise(body2) {
+  const out2 = { labels: [], names: new Set };
+  walk2(body2, out2);
+  return out2;
+}
+
+// src/clones/units.ts
+var DOC_LIMIT = 160;
+var FUNCTION_VALUES = new Set([
+  "arrow_function",
+  "function_expression",
+  "function",
+  "generator_function"
+]);
+var CLASSES = new Set(["class_declaration", "abstract_class_declaration", "class"]);
+var ANONYMOUS_CLASS = "(class)";
+function sha1(text) {
+  return createHash2("sha1").update(text).digest("hex").slice(0, 16);
+}
+function keyName(key) {
+  if (!key)
+    return null;
+  return key.type === "string" ? key.text.slice(1, -1) : key.text;
+}
+function hasToken(node, token) {
+  return node.children.some((c) => !c.isNamed && c.type === token);
+}
+function anchorOf(node) {
+  let anchor = node;
+  if (node.type === "variable_declarator" && node.parent)
+    anchor = node.parent;
+  if (anchor.parent?.type === "export_statement")
+    anchor = anchor.parent;
+  return anchor;
+}
+function declared(node, container) {
+  switch (node.type) {
+    case "function_declaration":
+    case "generator_function_declaration": {
+      const name2 = keyName(node.childForFieldName("name"));
+      if (!name2)
+        return null;
+      return { fn: node, name: name2, kind: container ? "local" : "function", anchor: anchorOf(node) };
+    }
+    case "method_definition": {
+      const name2 = keyName(node.childForFieldName("name"));
+      if (!name2)
+        return null;
+      const inClass = node.parent?.type === "class_body";
+      let kind = "prop";
+      if (inClass) {
+        if (name2 === "constructor")
+          kind = "ctor";
+        else if (hasToken(node, "get"))
+          kind = "get";
+        else if (hasToken(node, "set"))
+          kind = "set";
+        else
+          kind = "method";
+      }
+      return { fn: node, name: name2, kind, anchor: node };
+    }
+    case "public_field_definition": {
+      const value = node.childForFieldName("value");
+      const name2 = keyName(node.childForFieldName("name"));
+      if (!value || !name2 || !FUNCTION_VALUES.has(value.type))
+        return null;
+      return { fn: value, name: name2, kind: "field", anchor: node };
+    }
+    case "variable_declarator": {
+      const value = node.childForFieldName("value");
+      const id = node.childForFieldName("name");
+      if (!value || !id || id.type !== "identifier" || !FUNCTION_VALUES.has(value.type)) {
+        return null;
+      }
+      return {
+        fn: value,
+        name: id.text,
+        kind: container ? "local" : "function",
+        anchor: anchorOf(node)
+      };
+    }
+    case "pair": {
+      const value = node.childForFieldName("value");
+      const name2 = keyName(node.childForFieldName("key"));
+      if (!value || !name2 || !FUNCTION_VALUES.has(value.type))
+        return null;
+      return { fn: value, name: name2, kind: "prop", anchor: node };
+    }
+    default:
+      return null;
+  }
+}
+function paramCount(fn) {
+  const list = fn.childForFieldName("parameters");
+  if (list)
+    return list.namedChildren.filter((c) => c.type !== "comment").length;
+  return fn.childForFieldName("parameter") ? 1 : 0;
+}
+function docOf(anchor, source) {
+  const comment = anchor.previousSibling;
+  if (comment?.type !== "comment" || !comment.text.startsWith("/**"))
+    return "";
+  if (source.slice(comment.endIndex, anchor.startIndex).trim() !== "")
+    return "";
+  const lines = comment.text.slice(3, -2).split(`
+`).map((line) => line.replace(/^\s*\*\s?/, "").trim());
+  const tag = lines.findIndex((line) => line.startsWith("@"));
+  const text = (tag === -1 ? lines : lines.slice(0, tag)).filter((line) => line !== "");
+  return text.join(" ").slice(0, DOC_LIMIT);
+}
+function buildUnit(d, container, source, file, minNodes) {
+  const body2 = d.fn.childForFieldName("body");
+  if (!body2)
+    return null;
+  const { labels, names } = normalise(body2);
+  if (labels.length < minNodes)
+    return null;
+  const startLine = d.anchor.startPosition.row + 1;
+  const endLine = d.fn.endPosition.row + 1;
+  return {
+    file,
+    name: d.name,
+    container,
+    kind: d.kind,
+    exported: d.anchor.type === "export_statement",
+    startLine,
+    endLine,
+    loc: endLine - startLine + 1,
+    params: paramCount(d.fn),
+    async: hasToken(d.fn, "async"),
+    nodes: labels.length,
+    doc: docOf(d.anchor, source),
+    exactHash: sha1(labels.join(" ")),
+    textHash: sha1(source.slice(body2.startIndex, body2.endIndex).replace(/\s+/g, "")),
+    startIndex: d.fn.startIndex,
+    endIndex: d.fn.endIndex,
+    labels,
+    names
+  };
+}
+function unitsOf(root, source, file, minNodes) {
+  const units = [];
+  const visit = (node, container) => {
+    const found = declared(node, container);
+    if (found) {
+      const unit = buildUnit(found, container, source, file, minNodes);
+      if (unit)
+        units.push(unit);
+    }
+    let inner = container;
+    if (CLASSES.has(node.type)) {
+      inner = keyName(node.childForFieldName("name")) ?? (container || ANONYMOUS_CLASS);
+    }
+    for (const child of node.namedChildren)
+      visit(child, inner);
+  };
+  visit(root, "");
+  return units;
+}
+
+// src/clones/index.ts
+var CLONES_HELP = `Usage: repo-tools clones [root] [--out=<dir>] [--config=<path>] [--src=<path>...]
+                         [--min-nodes=<n>] [--shingle=<n>] [--near=<f>]
+                         [--containment=<f>] [--containment-min=<n>]
+                         [--rare=<n>] [--min-shared=<n>] [--list-errors=<n>]
+
+List the functions of a TypeScript or JavaScript repository and find the functions
+that copy each other. The command only reads the repository. The result is a list
+of candidates: read both bodies of a pair before you change anything.
+
+A function is a unit when it has a name and its body has at least --min-nodes
+labels. A label is one node of the body, with names, literals, types and comments
+erased. Units with the same label sequence are an exact group. Two units whose
+shingles (runs of --shingle labels) overlap enough are a near pair.
+
+  --out=<dir>           Write inventory.jsonl and clones.json to this folder.
+                        Without it the command writes no file.
+  --config=<path>       The config file. The default is repo-tools.config.json at
+                        the root. The settings are in its "clones" section.
+  --src=<path>...       The folders to read. The word "auto" (the default) reads
+                        the files of the src area. The flag takes every argument
+                        up to the next flag.
+  --min-nodes=<n>       The smallest number of labels of a unit. Default 50.
+  --shingle=<n>         The labels in one shingle. Default 6.
+  --near=<f>            The smallest Jaccard score of a near pair. Default 0.6.
+  --containment=<f>     The smallest containment of a near pair. Default 0.9.
+  --containment-min=<n> The smallest shingle count of the smaller unit for the
+                        containment rule. Default 20.
+  --rare=<n>            A shingle in more units than this does not pick candidate
+                        pairs. Default 60.
+  --min-shared=<n>      The rare shingles that a candidate pair must share.
+                        Default 3.
+  --list-errors=<n>     The most paths of files with a parse error that the
+                        summary lists. Default 20.
+  --root=<path>         The root. The default is the current folder.
+  --help, -h            Show this help.
+
+A flag overrides the config file, and the config file overrides the default.
+
+Exit codes: 0 when the run finished. 1 when the root holds no source file to read.
+2 on a usage error, a bad config file or a root that is not a folder.
+`;
+
+class NothingToRead extends Error {
+}
+var VALUE_FLAGS2 = {
+  "--out": "out",
+  "--min-nodes": "minNodes",
+  "--shingle": "shingleLength",
+  "--near": "nearThreshold",
+  "--containment": "containmentThreshold",
+  "--containment-min": "containmentMinShingles",
+  "--rare": "rareShingleLimit",
+  "--min-shared": "minSharedShingles",
+  "--list-errors": "parseErrorList"
+};
+var NUMERIC = new Set([
+  "minNodes",
+  "shingleLength",
+  "nearThreshold",
+  "containmentThreshold",
+  "containmentMinShingles",
+  "rareShingleLimit",
+  "minSharedShingles",
+  "parseErrorList"
+]);
+function parseArgs2(argv) {
+  const options = { root: ".", config: undefined, settings: {} };
+  const seen = new Set;
+  let rootSet = false;
+  const setRoot = (value) => {
+    if (rootSet)
+      throw new Error("the root is set twice (use --root=<path> or one positional path)");
+    rootSet = true;
+    options.root = value;
+  };
+  const once = (flag) => {
+    if (seen.has(flag))
+      throw new Error(`flag ${flag} is set twice`);
+    seen.add(flag);
+  };
+  for (let i2 = 0;i2 < argv.length; i2++) {
+    const arg = argv[i2] ?? "";
+    if (!arg.startsWith("-")) {
+      setRoot(arg);
+      continue;
+    }
+    const eq = arg.indexOf("=");
+    const name2 = eq === -1 ? arg : arg.slice(0, eq);
+    if (name2 === "--src") {
+      once(name2);
+      const paths = [];
+      if (eq !== -1)
+        paths.push(arg.slice(eq + 1));
+      else
+        while (i2 + 1 < argv.length && !(argv[i2 + 1] ?? "").startsWith("-")) {
+          paths.push(argv[++i2] ?? "");
+        }
+      if (paths.length === 0 || paths.some((p) => p === "")) {
+        throw new Error("flag --src needs a value: --src=<path>");
+      }
+      const only = paths.length === 1 ? paths[0] : undefined;
+      options.settings.src = checkClonesFlag(name2, "src", only === "auto" ? "auto" : paths);
+      continue;
+    }
+    if (name2 !== "--root" && name2 !== "--config" && !Object.hasOwn(VALUE_FLAGS2, name2)) {
+      throw new Error(`unknown flag '${name2}' (see repo-tools clones --help)`);
+    }
+    once(name2);
+    let value = eq === -1 ? undefined : arg.slice(eq + 1);
+    if (eq === -1 && i2 + 1 < argv.length && !(argv[i2 + 1] ?? "").startsWith("-")) {
+      value = argv[++i2];
+    }
+    if (value === undefined || value === "") {
+      throw new Error(`flag ${name2} needs a value: ${name2}=<value>`);
+    }
+    if (name2 === "--root")
+      setRoot(value);
+    else if (name2 === "--config")
+      options.config = value;
+    else {
+      const key = VALUE_FLAGS2[name2];
+      const raw = NUMERIC.has(key) ? /^\d+(\.\d+)?$/.test(value) ? Number(value) : NaN : value;
+      Object.assign(options.settings, { [key]: checkClonesFlag(name2, key, raw) });
+    }
+  }
+  return options;
+}
+function folderPrefix(path) {
+  const posix = path.replace(/\\/g, "/").replace(/^(\.\/)+/, "").replace(/\/+$/, "");
+  return posix === "." ? "" : posix;
+}
+function selectFiles(root, src) {
+  const found = discover(root, "typescript").filter((f) => !f.path.endsWith(".d.ts"));
+  if (src === "auto")
+    return found.filter((f) => f.area === "src").map((f) => f.path);
+  const folders = src.map(folderPrefix);
+  return found.filter((f) => folders.some((d) => d === "" || f.path === d || f.path.startsWith(`${d}/`))).map((f) => f.path);
+}
+async function readUnits(root, files, minNodes) {
+  const units = [];
+  const parseErrorFiles = [];
+  for (const file of files) {
+    const source = readSource(join23(root, file)).replace(/^\uFEFF/, "");
+    const grammar = grammarFor(file);
+    await loadGrammar(grammar);
+    const tree = parserFor(grammar).parse(source);
+    if (!tree) {
+      parseErrorFiles.push(file);
+      continue;
+    }
+    try {
+      if (tree.rootNode.hasError)
+        parseErrorFiles.push(file);
+      units.push(...unitsOf(tree.rootNode, source, file, minNodes));
+    } finally {
+      tree.delete();
+    }
+  }
+  return { units, parseErrorFiles };
+}
+async function execute(root, config, io) {
+  const files = selectFiles(root, config.src);
+  if (files.length === 0) {
+    throw new NothingToRead(config.src === "auto" ? "no TypeScript or JavaScript file in the src area (set clones.src or pass --src=<path>)" : "no TypeScript or JavaScript file below the listed folders");
+  }
+  const { units, parseErrorFiles } = await readUnits(root, files, config.minNodes);
+  const detection = detect(units, config);
+  io.stdout(summaryText(config, { files: files.length, parseErrorFiles }, units, detection));
+  if (config.out !== null) {
+    const out2 = resolve9(root, config.out);
+    try {
+      writeLf(join23(out2, "inventory.jsonl"), inventoryJsonl(units));
+      writeLf(join23(out2, "clones.json"), clonesJson(config, detection));
+    } catch {
+      throw new Error(`cannot write the output folder '${config.out}'`);
+    }
+    const shown = config.out.replace(/\\/g, "/").replace(/\/+$/, "");
+    io.stdout(`wrote ${shown}/inventory.jsonl
+wrote ${shown}/clones.json
+`);
+  }
+  return 0;
+}
+async function run4(argv, io) {
+  let root;
+  const stderr = (text) => io.stderr(root ? maskRoot(text, root) : text);
+  try {
+    const options = parseArgs2(argv);
+    root = resolve9(options.root);
+    if (!isDirectory(root))
+      throw new Error("the root <root> is not an existing directory");
+    const file = loadConfigSections(root, options.config).clones;
+    return await execute(root, mergeClonesConfig(options.settings, file), io);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    stderr(`repo-tools clones: ${message}
+`);
+    return error instanceof NothingToRead ? 1 : 2;
+  }
+}
+
 // src/compress/index.ts
 import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync20, statSync as statSync8, writeFileSync as writeFileSync4 } from "node:fs";
-import { basename as basename8, dirname as dirname8, extname as extname4, join as join22 } from "node:path";
+import { basename as basename8, dirname as dirname7, extname as extname4, join as join24 } from "node:path";
 
 // src/compress/formats.ts
 import { extname as extname3 } from "node:path";
@@ -17199,7 +17875,7 @@ a value, a missing input file and two inputs without --batch are errors. No file
 var defaultDeps = {
   readdir: (dir) => readdirSync3(dir, { withFileTypes: true })
 };
-function parseArgs2(args2) {
+function parseArgs3(args2) {
   const o = {
     input: "",
     inputs: [],
@@ -17322,7 +17998,7 @@ function findFiles(dir, pattern, recursive, deps = defaultDeps) {
   const scan = (current) => {
     const entries = [...deps.readdir(current)].sort((a, b) => compareCodeUnits(a.name, b.name));
     for (const entry of entries) {
-      const full = join22(current, entry.name);
+      const full = join24(current, entry.name);
       if (entry.isDirectory()) {
         if (recursive && !entry.name.startsWith(".") && entry.name !== "node_modules")
           scan(full);
@@ -17339,16 +18015,16 @@ function isDirectory2(path) {
 }
 function compactName(file) {
   const ext = extname4(file);
-  return join22(dirname8(file), `${basename8(file, ext)}.compact${ext}`);
+  return join24(dirname7(file), `${basename8(file, ext)}.compact${ext}`);
 }
 function restoredName(file) {
   const base = basename8(file);
   const stripped = base.replace(/\.compact(?=\.[^.]*$|$)/i, "");
-  const output = stripped === base ? file : join22(dirname8(file), stripped);
+  const output = stripped === base ? file : join24(dirname7(file), stripped);
   if (output !== file)
     return output;
   const ext = extname4(file);
-  return join22(dirname8(file), `${basename8(file, ext)}.restored${ext}`);
+  return join24(dirname7(file), `${basename8(file, ext)}.restored${ext}`);
 }
 function assertCanRestore(output, o) {
   if (!o.dryRun && !o.yes && existsSync9(output)) {
@@ -17508,10 +18184,10 @@ Level: ${o.level}
   }
   return 0;
 }
-async function run4(argv, io, deps = defaultDeps) {
+async function run5(argv, io, deps = defaultDeps) {
   let o;
   try {
-    o = parseArgs2(argv);
+    o = parseArgs3(argv);
   } catch (error) {
     if (!(error instanceof UsageError))
       throw error;
@@ -17562,16 +18238,16 @@ async function run4(argv, io, deps = defaultDeps) {
 
 // src/docs/index.ts
 import { lstatSync as lstatSync5, readFileSync as readFileSync23, realpathSync as realpathSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { basename as basename9, isAbsolute as isAbsolute4, join as join26, relative as relative5, resolve as resolve8, sep as sep4 } from "node:path";
+import { basename as basename9, isAbsolute as isAbsolute4, join as join28, relative as relative5, resolve as resolve10, sep as sep4 } from "node:path";
 
 // src/docs/analyse.ts
 import { readFileSync as readFileSync22 } from "node:fs";
-import { join as join24 } from "node:path";
+import { join as join26 } from "node:path";
 
 // src/docs/discovery.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync21, statSync as statSync9 } from "node:fs";
-import { join as join23 } from "node:path";
+import { join as join25 } from "node:path";
 var PYTHON_SUFFIXES2 = new Set([".py"]);
 var TYPESCRIPT_SUFFIXES = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 var SKIP_DIRS2 = new Set([
@@ -17655,8 +18331,8 @@ function walkSource(root) {
       const rel = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         if (!SKIP_DIRS2.has(entry.name))
-          go(join23(dir, entry.name), `${rel}/`);
-      } else if (isSource(rel) && statOk(join23(dir, entry.name))) {
+          go(join25(dir, entry.name), `${rel}/`);
+      } else if (isSource(rel) && statOk(join25(dir, entry.name))) {
         found.push(rel);
       }
     }
@@ -17672,7 +18348,7 @@ function statOk(path) {
   }
 }
 function loadExclusions(root) {
-  const file = join23(root, CONFIG_NAME);
+  const file = join25(root, CONFIG_NAME);
   if (!existsSync10(file) || !statOk(file))
     return [];
   let data;
@@ -18280,13 +18956,13 @@ var DECLARATIONS = {
 var DECLARATION_TYPES = Object.keys(DECLARATIONS);
 var SPACE_CLASS = "[ \\t\\n\\r\\f\\v]";
 var ABSTRACT_PROPERTY = new RegExp(`\\babstract(${SPACE_CLASS}*\\??${SPACE_CLASS}*:)`, "g");
-var EXPORT_TYPE_STAR = new RegExp(`(\\bexport${SPACE_CLASS}+)type(${SPACE_CLASS}*\\*)`, "g");
+var EXPORT_TYPE_STAR2 = new RegExp(`(\\bexport${SPACE_CLASS}+)type(${SPACE_CLASS}*\\*)`, "g");
 function sanitise(source) {
-  return source.replace(ABSTRACT_PROPERTY, "abstrac_$1").replace(EXPORT_TYPE_STAR, "$1    $2");
+  return source.replace(ABSTRACT_PROPERTY, "abstrac_$1").replace(EXPORT_TYPE_STAR2, "$1    $2");
 }
-var IDENTIFIERS = new Set(["identifier", "shorthand_property_identifier_pattern"]);
+var IDENTIFIERS2 = new Set(["identifier", "shorthand_property_identifier_pattern"]);
 function boundIdentifiers(node, text) {
-  if (IDENTIFIERS.has(node.type))
+  if (IDENTIFIERS2.has(node.type))
     return [text(node)];
   const pattern = node.childForFieldName("pattern");
   if (pattern)
@@ -18304,7 +18980,7 @@ function boundIdentifiers(node, text) {
     case "rest_pattern":
       return into(node.namedChildren[0] ?? null);
     default: {
-      const first = node.namedChildren.find((c) => IDENTIFIERS.has(c.type));
+      const first = node.namedChildren.find((c) => IDENTIFIERS2.has(c.type));
       return first ? [text(first)] : [];
     }
   }
@@ -18313,7 +18989,7 @@ function paramsOf2(node, text) {
   const list = node.childForFieldName("parameters");
   return (list?.namedChildren ?? []).flatMap((param) => boundIdentifiers(param, text));
 }
-function anchorOf(node) {
+function anchorOf2(node) {
   let target = node;
   while (target.parent?.type === "export_statement")
     target = target.parent;
@@ -18470,7 +19146,7 @@ async function analyseTypeScript(path, source) {
     const text = (node) => source.slice(node.startIndex, node.endIndex);
     for (const node of tree.rootNode.descendantsOfType(DECLARATION_TYPES)) {
       const kind = DECLARATIONS[node.type];
-      const anchor = anchorOf(node);
+      const anchor = anchorOf2(node);
       const lead = stubAnchor(anchor, source, text);
       const doc = leadingDoc(anchor, node, text);
       const dialect = dialectOf(doc);
@@ -18527,7 +19203,7 @@ async function analyseFile(root, rel) {
   const language = languageOf(rel);
   let source;
   try {
-    source = readSourceText2(join24(root, rel));
+    source = readSourceText2(join26(root, rel));
   } catch (error) {
     const report = newReport(rel, language);
     report.error = `unreadable: ${readFailure(error)}`;
@@ -18544,7 +19220,7 @@ async function analyseRepo(root) {
 }
 
 // src/docs/report.ts
-import { join as join25 } from "node:path";
+import { join as join27 } from "node:path";
 function percent3(part, whole) {
   if (whole === 0)
     return 100;
@@ -18656,8 +19332,8 @@ function symbolJson(s) {
   };
 }
 function writeOutputs(outDir, reports, stats, provenance, rootName) {
-  const markdown = join25(outDir, "COVERAGE.md");
-  const json = join25(outDir, "coverage.json");
+  const markdown = join27(outDir, "COVERAGE.md");
+  const json = join27(outDir, "coverage.json");
   writeReport(markdown, renderMarkdown(reports, stats, provenance, rootName));
   const payload = {
     summary: statsJson(stats),
@@ -18861,7 +19537,7 @@ Exit codes: 0 when the action succeeded and the gate passed. 1 when the gate
 failed, or when the root holds no source file to measure. 2 on a usage error,
 when the root is not a folder, or when ${CONFIG_NAME} is malformed.
 `;
-var VALUE_FLAGS2 = {
+var VALUE_FLAGS3 = {
   "--root": "all",
   "--out": "scan",
   "--path": "stub",
@@ -18914,8 +19590,8 @@ function parseDocsArgs(argv) {
         while (i2 + 1 < argv.length && !(argv[i2 + 1] ?? "").startsWith("-"))
           options.paths.push(argv[++i2] ?? "");
       }
-    } else if (Object.hasOwn(VALUE_FLAGS2, name2)) {
-      forbid(name2, VALUE_FLAGS2[name2]);
+    } else if (Object.hasOwn(VALUE_FLAGS3, name2)) {
+      forbid(name2, VALUE_FLAGS3[name2]);
       let value = eq === -1 ? undefined : arg.slice(eq + 1);
       if (eq === -1 && i2 + 1 < argv.length && !(argv[i2 + 1] ?? "").startsWith("-"))
         value = argv[++i2];
@@ -19009,7 +19685,7 @@ async function runScan(root, options, io) {
   if (reports.length === 0)
     throw new NothingToMeasure(provenance);
   const stats = summarise(reports);
-  const outDir = resolve8(options.out ?? join26(root, "docs", "code-docs"));
+  const outDir = resolve10(options.out ?? join28(root, "docs", "code-docs"));
   const written = writeOutputs(outDir, reports, stats, provenance, basename9(root));
   io.stdout(`scanned ${stats.filesScanned} file(s) via ${provenance}
 `);
@@ -19049,7 +19725,7 @@ async function runStub(root, options, io) {
     const targets = report.symbols.filter((s) => s.issues.some((i2) => i2.rule === "M1"));
     if (targets.length === 0)
       continue;
-    const file = join26(root, report.path);
+    const file = join28(root, report.path);
     if (leavesRoot(root, file)) {
       io.stdout(`  SKIPPED ${report.path}: the path is a link, or it resolves outside the root
 `);
@@ -19175,7 +19851,7 @@ async function runCheck(root, options, io) {
 `);
   return 1;
 }
-async function run5(argv, io) {
+async function run6(argv, io) {
   if (wantsHelp(argv)) {
     io.stdout(DOCS_HELP);
     return 0;
@@ -19184,7 +19860,7 @@ async function run5(argv, io) {
   const stderr = (text) => io.stderr(root ? maskRoot(text, root) : text);
   try {
     const options = parseDocsArgs(argv);
-    root = resolve8(options.root);
+    root = resolve10(options.root);
     if (!isDirectory(root))
       throw new Error("the root <root> is not an existing directory");
     assertReadableLanguage(root);
@@ -19203,14 +19879,14 @@ async function run5(argv, io) {
 
 // src/query/index.ts
 import { existsSync as existsSync12, statSync as statSync10 } from "node:fs";
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve11 } from "node:path";
 
 // src/query/args.ts
 var MODE_FLAGS = {
   "--emit": { name: "emit" },
   "--check-browser-safety": { name: "check-browser-safety" }
 };
-var VALUE_FLAGS3 = new Set(["--root", "--config", "--out", "--node-runtime"]);
+var VALUE_FLAGS4 = new Set(["--root", "--config", "--out", "--node-runtime"]);
 var COMMAND_USAGE = {
   dependents: "<file>",
   "symbol-users": "<symbol>",
@@ -19291,7 +19967,7 @@ function parseQueryArgs(argv, cwd) {
       mode = modeCommand;
       continue;
     }
-    if (!VALUE_FLAGS3.has(name2)) {
+    if (!VALUE_FLAGS4.has(name2)) {
       throw new Error(`unknown flag '${name2}' (see repo-tools query --help)`);
     }
     if (value === undefined || value === "") {
@@ -19780,12 +20456,12 @@ report, a path that is not a file of the graph, a browser-safety command on a
 graph that is not TypeScript/JavaScript, or a browser-safety leak with
 --check-browser-safety.
 `;
-async function run6(argv, io) {
+async function run7(argv, io) {
   let root;
   const stderr = (text) => io.stderr(root ? maskRoot(text, root) : text);
   try {
     const options = parseQueryArgs(argv, process.cwd());
-    root = resolve9(options.root);
+    root = resolve11(options.root);
     if (!(existsSync12(root) && statSync10(root).isDirectory())) {
       throw new Error("the root <root> is not an existing directory");
     }
@@ -19821,7 +20497,7 @@ async function run6(argv, io) {
 
 // src/ste/index.ts
 import { existsSync as existsSync13, lstatSync as lstatSync6, readdirSync as readdirSync5, readFileSync as readFileSync26, statSync as statSync11 } from "node:fs";
-import { basename as basename10, join as join28 } from "node:path";
+import { basename as basename11, join as join30, resolve as resolve13 } from "node:path";
 
 // src/ste/markdown.ts
 function stripNoise(text) {
@@ -19876,7 +20552,12 @@ function wordCount(sentence) {
   const s = sentence.replace(CODE_SPAN, "X").replace(LINK, "$1").replace(EMPHASIS_CHARS, "").replace(LIST_MARKER, "");
   return pySplit(s).filter((w) => Array.from(w).some(isAlnum)).length;
 }
-function join27(parts2, start2) {
+var LIST_JOINS = new Set(["and", "or"]);
+function isIdentifierList(sentence) {
+  const s = sentence.replace(CODE_SPAN, " ").replace(LINK, "$1").replace(LIST_MARKER, "");
+  return pySplit(s).map((w) => Array.from(w).filter(isAlnum).join("").toLowerCase()).filter((w) => w !== "").every((w) => LIST_JOINS.has(w));
+}
+function join29(parts2, start2) {
   const chunks = [];
   const lineMap = [];
   parts2.forEach(([n, body2], i2) => {
@@ -19906,7 +20587,7 @@ function paragraphs(text) {
   for (const [n, line] of stripNoise(text)) {
     const startsItem = LIST_ITEM.test(line);
     if ((n !== prevLine + 1 || startsItem) && para.length > 0) {
-      blocks.push(join27(para, paraStart));
+      blocks.push(join29(para, paraStart));
       para = [];
     }
     if (para.length === 0)
@@ -19915,42 +20596,112 @@ function paragraphs(text) {
     prevLine = n;
   }
   if (para.length > 0)
-    blocks.push(join27(para, paraStart));
+    blocks.push(join29(para, paraStart));
   return blocks;
 }
-function checkMarkdown(name2, text) {
-  const problems = [];
+function checkMarkdownFindings(name2, text) {
+  const found = [];
   const blocks = paragraphs(text);
-  for (const [start2, block] of blocks) {
+  for (const [start2, block, lineMap] of blocks) {
     const procedural = PROCEDURAL_STARTS.some((p) => pyLstrip(block).startsWith(p));
     const limit = procedural ? MAX_WORDS_PROCEDURAL : MAX_WORDS_DESCRIPTIVE;
+    const last = lineMap.length > 0 ? lineMap[lineMap.length - 1] : start2;
     for (const sentence of sentences(block)) {
       const n = wordCount(sentence);
-      if (n > limit) {
+      if (n > limit && !isIdentifierList(sentence)) {
         const tier = procedural ? "procedural" : "descriptive";
-        problems.push(`${name2}:~${start2}: ${n} words (>${limit} ${tier}): ${headCodePoints(pyStrip(sentence), 90)}`);
+        found.push({
+          text: `${name2}:~${start2}: ${n} words (>${limit} ${tier}): ${headCodePoints(pyStrip(sentence), 90)}`,
+          first: start2,
+          last
+        });
       }
     }
   }
   for (const [, block, lineMap] of blocks) {
     const bare = proseOnly(block);
+    const at = (index, rest) => {
+      const line = lineAt2(index, lineMap);
+      return { text: `${name2}:${line}: ${rest}`, first: line, last: line };
+    };
     for (const [phrase, better, re] of WORDY_RULES) {
       for (const m of bare.matchAll(re)) {
-        problems.push(`${name2}:${lineAt2(m.index, lineMap)}: wordy: ${pyRepr(phrase)} - prefer ${pyRepr(better)}`);
+        found.push(at(m.index, `wordy: ${pyRepr(phrase)} - prefer ${pyRepr(better)}`));
       }
     }
     for (const m of bare.matchAll(AMBIGUOUS2)) {
-      problems.push(`${name2}:${lineAt2(m.index, lineMap)}: ambiguous reference: ${pyRepr(pyStrip(m[0]))}`);
+      found.push(at(m.index, `ambiguous reference: ${pyRepr(pyStrip(m[0]))}`));
     }
     for (const m of bare.matchAll(PASSIVE2)) {
-      problems.push(`${name2}:${lineAt2(m.index, lineMap)}: passive voice: ${pyRepr(pyStrip(m[0]))}`);
+      found.push(at(m.index, `passive voice: ${pyRepr(pyStrip(m[0]))}`));
     }
   }
-  return problems;
+  return found;
+}
+
+// src/ste/since.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { basename as basename10, dirname as dirname8, resolve as resolve12 } from "node:path";
+var GIT_TIMEOUT_MS = 60000;
+
+class SinceError extends Error {
+}
+function git(dir, args2) {
+  return spawnSync3("git", ["-C", dir, ...args2], {
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: GIT_TIMEOUT_MS,
+    maxBuffer: 1 << 28
+  });
+}
+var checked = new Set;
+function checkRevision(dir, rev) {
+  const key = `${dir}\x00${rev}`;
+  if (checked.has(key))
+    return;
+  const tree = git(dir, ["rev-parse", "--is-inside-work-tree"]);
+  if (tree.error)
+    throw new SinceError(`--since needs git, and git cannot run: ${tree.error.message}`);
+  if (tree.status !== 0)
+    throw new SinceError(`--since needs a git work tree: ${dir}`);
+  const commit = git(dir, ["rev-parse", "--verify", "--quiet", `${rev}^{commit}`]);
+  if (commit.status !== 0)
+    throw new SinceError(`cannot resolve revision '${rev}' in ${dir}`);
+  checked.add(key);
+}
+var HUNK = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/gmu;
+function addedLinesSince(file, rev) {
+  const full = resolve12(file);
+  const dir = dirname8(full);
+  const name2 = basename10(full);
+  checkRevision(dir, rev);
+  if (git(dir, ["cat-file", "-e", `${rev}:./${name2}`]).status !== 0)
+    return "all";
+  const diff = git(dir, ["diff", "-U0", "--no-color", "--no-ext-diff", rev, "--", name2]);
+  if (diff.status !== 0) {
+    throw new SinceError(`git diff failed for ${name2}: ${diff.stderr.toString().trim()}`);
+  }
+  const ranges = [];
+  const cuts = [];
+  for (const m of diff.stdout.toString().matchAll(HUNK)) {
+    const first = Number(m[1]);
+    const count = m[2] === undefined ? 1 : Number(m[2]);
+    if (count > 0)
+      ranges.push([first, first + count - 1]);
+    else
+      cuts.push(first);
+  }
+  return { ranges, cuts };
+}
+function touchesAdded(added, first, last) {
+  if (added === "all")
+    return true;
+  if (added.ranges.some(([from, to]) => from <= last && first <= to))
+    return true;
+  return added.cuts.some((line) => first <= line && line + 1 <= last);
 }
 
 // src/ste/index.ts
-var STE_HELP = `Usage: repo-tools ste <file-or-directory> [...]
+var STE_HELP = `Usage: repo-tools ste <file-or-directory> [...] [--require=<path>] [--since=<rev>]
        repo-tools ste --prose <file>
 
 Check prose against the mechanically decidable part of ASD-STE100 Simplified
@@ -19960,11 +20711,25 @@ cannot judge the approved dictionary.
 
 Markdown mode (the default) checks each Markdown file, or each .md file below a
 directory, in code-unit order of the path. A descriptive sentence may have 25
-words; a procedural one (a numbered step or a check box) may have 20. Code
-fences, tables, headings, quotes, comments, frontmatter, inline code and
-identifiers are not checked. A file whose first five lines hold
+words; a procedural one (a numbered step or a check box) may have 20. A list of
+identifiers with no prose word is not a sentence, so the word limit does not
+apply to it. Code fences, tables, headings, quotes, comments and frontmatter are
+not checked. Inline code and identifiers are not checked by the wordy, ambiguous
+and passive rules, and each one counts as a word. A file whose first five lines
+hold
 "<!-- ste:historical-record -->" is skipped, and the skip is counted.
 
+  --require=<path>  The file must exist, and the run must examine it. Repeat the
+                  option for more files. A document that someone deletes inside
+                  a folder gives no finding, so this option makes the deletion
+                  an error. A file that the run skips as a historical record
+                  counts as examined.
+  --since=<rev>   Report only the findings on the lines that the working tree
+                  adds or changes since the git revision <rev> (committed,
+                  staged and unstaged edits). A sentence-length finding counts
+                  when any line of its paragraph changed. A file that is not in
+                  <rev> counts in full. The totals line gives the number of
+                  older findings that the option hides.
   --prose <file>  Check the file as one docstring. Tag lines (@param), section
                   headers, doctest lines and code fences are removed first. Each
                   finding prints as "RULE<TAB>detail". The findings are advice:
@@ -19973,7 +20738,9 @@ identifiers are not checked. A file whose first five lines hold
 
 Exit codes: 0 when no finding (Markdown mode) or always (--prose mode). 1 when a
 Markdown finding exists. 2 on a usage error, when a path does not exist, when no
-Markdown file was examined, or when a file is not UTF-8.
+Markdown file was examined, when a required file does not exist or was not
+examined, when --since cannot use the revision or the work tree, or when a file
+is not UTF-8.
 `;
 var HISTORICAL_MARKER = "<!-- ste:historical-record -->";
 function readText(path) {
@@ -20002,7 +20769,7 @@ function targetsFor(path) {
       return;
     }
     for (const entry of entries) {
-      const full = join28(dir, entry.name);
+      const full = join30(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name !== ".pytest_cache")
           walk(full, [...parts2, entry.name]);
@@ -20015,7 +20782,7 @@ function targetsFor(path) {
   };
   if (existsSync13(path) && lstatSync6(path).isDirectory())
     walk(path, []);
-  return found.sort(comparePaths).map((parts2) => join28(path, ...parts2));
+  return found.sort(comparePaths).map((parts2) => join30(path, ...parts2));
 }
 function isHistoricalRecord(path) {
   let text;
@@ -20037,7 +20804,7 @@ function runProse(args2, io) {
   try {
     text = readText(file);
   } catch {
-    io.stderr(`repo-tools ste: cannot read ${basename10(file)} as UTF-8 text
+    io.stderr(`repo-tools ste: cannot read ${basename11(file)} as UTF-8 text
 `);
     return 2;
   }
@@ -20046,10 +20813,41 @@ function runProse(args2, io) {
 `);
   return 0;
 }
-async function run7(argv, io) {
+function parseMarkdownArgs(argv) {
+  const args2 = { paths: [], required: [], since: null };
+  for (const arg of argv) {
+    if (arg === "--require" || arg.startsWith("--require=")) {
+      const value = arg.slice("--require=".length);
+      if (arg === "--require" || value === "")
+        return "--require needs a path (--require=<path>)";
+      args2.required.push(value);
+    } else if (arg === "--since" || arg.startsWith("--since=")) {
+      const value = arg.slice("--since=".length);
+      if (arg === "--since" || value === "" || value.startsWith("-")) {
+        return "--since needs a revision (--since=<rev>)";
+      }
+      args2.since = value;
+    } else {
+      args2.paths.push(arg);
+    }
+  }
+  return args2;
+}
+function pathKey(path) {
+  const full = resolve13(path);
+  return process.platform === "win32" ? full.toLowerCase() : full;
+}
+async function run8(argv, io) {
   if (argv[0] === "--prose")
     return runProse(argv.slice(1), io);
-  if (argv.length === 0) {
+  const parsed = parseMarkdownArgs(argv);
+  if (typeof parsed === "string") {
+    io.stderr(`repo-tools ste: ${parsed}
+`);
+    return 2;
+  }
+  const { paths, required, since } = parsed;
+  if (paths.length === 0) {
     io.stdout(`usage: repo-tools ste <file-or-directory> [...]
 `);
     return 2;
@@ -20057,12 +20855,15 @@ async function run7(argv, io) {
   let total = 0;
   let checked = 0;
   let skipped = 0;
+  let hidden = 0;
   const missing = [];
-  for (const arg of argv) {
+  const examined = new Set;
+  for (const arg of paths) {
     if (!existsSync13(arg))
       missing.push(arg);
     for (const target of targetsFor(arg)) {
-      const name2 = basename10(target);
+      const name2 = basename11(target);
+      examined.add(pathKey(target));
       if (isHistoricalRecord(target)) {
         skipped += 1;
         io.stdout(`
@@ -20078,30 +20879,62 @@ async function run7(argv, io) {
 `);
         return 2;
       }
-      const problems = checkMarkdown(name2, text);
+      let findings = checkMarkdownFindings(name2, text);
+      if (since !== null) {
+        try {
+          const added = addedLinesSince(target, since);
+          const shown = findings.filter((f) => touchesAdded(added, f.first, f.last));
+          hidden += findings.length - shown.length;
+          findings = shown;
+        } catch (error) {
+          if (!(error instanceof SinceError))
+            throw error;
+          io.stderr(`repo-tools ste: ${error.message}
+`);
+          return 2;
+        }
+      }
       checked += 1;
-      total += problems.length;
-      const status = problems.length === 0 ? "OK" : `${problems.length} problem(s)`;
+      total += findings.length;
+      const status = findings.length === 0 ? "OK" : `${findings.length} problem(s)`;
       io.stdout(`
 === ${name2}: ${status} ===
 `);
-      for (const p of problems)
-        io.stdout(`  ${p}
+      for (const f of findings)
+        io.stdout(`  ${f.text}
 `);
     }
   }
-  const tail = skipped > 0 ? `; ${skipped} skipped as historical record(s)` : "";
+  const notes = [];
+  if (skipped > 0)
+    notes.push(`${skipped} skipped as historical record(s)`);
+  if (since !== null && hidden > 0) {
+    notes.push(`${hidden} older finding(s) hidden by --since=${since}`);
+  }
+  const tail = notes.length > 0 ? `; ${notes.join("; ")}` : "";
   io.stdout(`
 TOTAL: ${total} problem(s) in ${checked} file(s)${tail}
 `);
   for (const path of missing)
     io.stderr(`ERROR: path does not exist: ${path}
 `);
+  let requiredFailed = false;
+  for (const path of required) {
+    if (!existsSync13(path) || !statSync11(path).isFile()) {
+      io.stderr(`ERROR: required file does not exist: ${path}
+`);
+      requiredFailed = true;
+    } else if (!examined.has(pathKey(path))) {
+      io.stderr(`ERROR: required file was not examined: ${path}
+`);
+      requiredFailed = true;
+    }
+  }
   if (checked === 0) {
     io.stderr(`ERROR: no Markdown file was examined. This is a failure, not a clean result -- check the path(s) given.
 `);
   }
-  if (missing.length > 0 || checked === 0)
+  if (missing.length > 0 || checked === 0 || requiredFailed)
     return 2;
   return total > 0 ? 1 : 0;
 }
@@ -20128,7 +20961,7 @@ ${MAP_HELP}`,
   docs: {
     summary: "Measure, stub and gate the doc comments of TypeScript, JavaScript and Python source.",
     help: DOCS_HELP,
-    run: run5
+    run: run6
   },
   chunk: {
     summary: "Split a large file into chunks, merge the chunks back, or show changed chunks.",
@@ -20138,17 +20971,22 @@ ${MAP_HELP}`,
   compress: {
     summary: "Write a compact copy of a file for a model context, or restore it.",
     help: HELP,
-    run: run4
+    run: run5
   },
   query: {
     summary: "Answer structural questions from the depgraph reports, or write derived reports.",
     help: QUERY_HELP,
-    run: run6
+    run: run7
   },
   ste: {
     summary: "Check Markdown or docstring prose against Simplified Technical English.",
     help: STE_HELP,
-    run: run7
+    run: run8
+  },
+  clones: {
+    summary: "List the functions of a repository and find the functions that copy each other.",
+    help: CLONES_HELP,
+    run: run4
   }
 };
 var SUBCOMMANDS = Object.keys(REGISTRY);