@hawkeyexl/manni 4.3.1 → 4.4.0

package/dist/chunk-LAKAWRV5.js

@@ -0,0 +1,1651 @@
+#!/usr/bin/env node
+import {
+  blockMatches,
+  claimEnd,
+  claimLineNow,
+  claimLinesNow,
+  findingsFor,
+  misplacedMarkerAt,
+  misplacedMarkers,
+  misplacedMessageFor,
+  movedUnit,
+  shortCommit,
+  toValidationResult,
+  unitText
+} from "./chunk-252LNOEG.js";
+import {
+  SEVERITIES
+} from "./chunk-77AINBYM.js";
+import {
+  ANY_FENCE,
+  CITE_RULES,
+  CiteError,
+  SRC_PATTERN,
+  anchoredLines,
+  fenceSpanAt,
+  formatSrc,
+  isCiteRule,
+  isMarkerLine,
+  parseSrc,
+  pickExtractor,
+  readPage,
+  resolveSeverity,
+  ruleId,
+  sliceLines,
+  sourceRange,
+  spellSource
+} from "./chunk-G7NJSREW.js";
+import {
+  STDIN_REQUIRES_AS
+} from "./chunk-V46OILVC.js";
+import {
+  MAX_RANGE_LINES,
+  MOVE_BUDGET_BYTES,
+  PATH_JOIN,
+  configMarks,
+  externalMetadataJoin,
+  findWindows,
+  hashLines,
+  lineSpec,
+  loadExternalMetadata,
+  memberOf,
+  mergeWithMarks,
+  orphanEntries,
+  orphanError,
+  orphanJoins,
+  parseLines,
+  resolveEncryptionKey,
+  spellLines,
+  splitLines,
+  toBodyLines
+} from "./chunk-RLR4TKUZ.js";
+import {
+  STDIN_LABEL,
+  STDIN_TOKEN,
+  assertNonEmpty,
+  classifyRef,
+  extractorByName,
+  gitIgnored,
+  gitignoreOptions,
+  isErrorSeverity,
+  resolveBaselineRequest,
+  resolveTargetSet,
+  settleBaseline,
+  supportedExtensions
+} from "./chunk-JVTNMVYU.js";
+import {
+  decryptValue,
+  encryptValue,
+  findConfigFile,
+  findGitRoot,
+  hasPagePlaceholder,
+  ownsKey,
+  pageManifestPath,
+  readConfigFile,
+  selectCollections,
+  warn
+} from "./chunk-Q35YIDBV.js";
+
+// src/cite/commands/check.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
+
+// src/cite/core/sources.ts
+import fg from "fast-glob";
+import { lstat, readFile, realpath } from "node:fs/promises";
+import { join, sep } from "node:path";
+var CONTEXT = "cite-src";
+function encryptSourcePath(path, key) {
+  return encryptValue(path, key, CONTEXT);
+}
+function decryptSourcePath(token, key) {
+  const opened = decryptValue(token, key, CONTEXT);
+  if (!opened.ok || typeof opened.value !== "string") return void 0;
+  const path = opened.value;
+  if (path.includes(":") || path.startsWith("~") || !SRC_PATTERN.test(path)) return void 0;
+  return path;
+}
+function isUnder(real, realRoot) {
+  return real === realRoot || real.startsWith(realRoot.endsWith(sep) ? realRoot : realRoot + sep);
+}
+async function admit(root, realRoot, rel) {
+  const abs = join(root, rel);
+  try {
+    const info = await lstat(abs);
+    if (!info.isFile()) return void 0;
+    const real = await realpath(abs);
+    return isUnder(real, realRoot) ? rel : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function candidates(root, opts) {
+  const client = opts?.gitClient;
+  if (client !== void 0 && await client.available()) {
+    return client.lsFiles();
+  }
+  return fg("**/*", {
+    cwd: root,
+    onlyFiles: true,
+    dot: true,
+    followSymbolicLinks: false,
+    ignore: ["**/.git/**", "**/node_modules/**"]
+  });
+}
+async function buildSourceIndex(root, opts) {
+  const realRoot = await realpath(root);
+  const admitted = await Promise.all(
+    (await candidates(root, opts)).map((rel) => admit(root, realRoot, rel))
+  );
+  const files = Object.freeze(
+    [...new Set(admitted.filter((rel) => rel !== void 0))].sort()
+  );
+  const byPath = new Set(files);
+  return {
+    files: () => files,
+    has: (path) => byPath.has(path)
+  };
+}
+function isEnoent(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function sourceIndexFor(root, client) {
+  try {
+    return await buildSourceIndex(root, { gitClient: client });
+  } catch (error) {
+    if (isEnoent(error)) throw new CiteError(`Root directory not found: ${root}.`);
+    throw error;
+  }
+}
+function resolveSourcePath(range, key) {
+  if (!range.encrypted) return { path: range.path };
+  if (key === void 0) return { reason: "no-key" };
+  const path = decryptSourcePath(range.path, key);
+  return path === void 0 ? { reason: "undecryptable" } : { path };
+}
+function createSourceCache() {
+  return /* @__PURE__ */ new Map();
+}
+async function readSource(root, index, range, key, cache) {
+  const resolved = resolveSourcePath(range, key);
+  if ("reason" in resolved) return { kind: "missing", reason: resolved.reason };
+  const resolvedPath = resolved.path;
+  if (!index.has(resolvedPath)) return { kind: "missing", reason: "untracked" };
+  if (cache === void 0) {
+    const text = await readTracked(root, resolvedPath);
+    return text === void 0 ? { kind: "missing", reason: "unreadable" } : { kind: "ok", resolvedPath, text };
+  }
+  const slot = JSON.stringify([root, resolvedPath]);
+  let read = cache.get(slot);
+  if (read === void 0) {
+    read = readTracked(root, resolvedPath).then(
+      (text) => text === void 0 ? void 0 : { text, lines: splitLines(text) }
+    );
+    cache.set(slot, read);
+  }
+  const file = await read;
+  return file === void 0 ? { kind: "missing", reason: "unreadable" } : { kind: "ok", resolvedPath, text: file.text, lines: file.lines };
+}
+async function readTracked(root, path) {
+  try {
+    return await readFile(join(root, path), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+
+// src/cite/core/classify.ts
+async function historyOf(git, commit, path, range, pin, key, budget, counter) {
+  const shown = await git.showFile(commit, path);
+  if ("missing" in shown) {
+    return shown.missing === "commit" ? { kind: "unavailable" } : { kind: "never-true" };
+  }
+  const then = splitLines(shown.text);
+  let joined;
+  try {
+    joined = sliceLines(then, range);
+  } catch {
+    joined = void 0;
+  }
+  if (joined !== void 0 && hashLines(joined, key) === pin) {
+    return { kind: "original", lines: joined.split("\n") };
+  }
+  if (range.start === void 0) return { kind: "never-true" };
+  const length = (range.end ?? range.start) - range.start + 1;
+  const search = { around: range.start };
+  if (budget !== void 0) search.budget = budget;
+  if (counter !== void 0) search.counter = counter;
+  const found = findWindows(then, length, pin, key, search);
+  const [first] = found.starts;
+  if (first !== void 0) {
+    return { kind: "original", lines: then.slice(first - 1, first - 1 + length) };
+  }
+  return found.truncated ? { kind: "unknown" } : { kind: "never-true" };
+}
+async function followAcross(ask, counter) {
+  const hits = [];
+  const length = ask.original.length;
+  if (length < 1 || ask.git.changedSince === void 0) return { hits, truncated: false };
+  const candidates2 = (await ask.git.changedSince(ask.commit)).filter(
+    (path) => path !== ask.own && ask.index.has(path)
+  );
+  for (const path of candidates2) {
+    const text = await readTracked(ask.root, path);
+    if (text === void 0) continue;
+    const bytes = Buffer.byteLength(text, "utf8");
+    if (bytes > counter.left) return { hits, truncated: true };
+    counter.left -= bytes;
+    const found = findWindows(splitLines(text), length, ask.pin, ask.key, {
+      original: ask.original
+    });
+    for (const start of found.starts) hits.push({ path, start });
+  }
+  return { hits, truncated: false };
+}
+function spanOf(lines, original) {
+  const first = original[0];
+  const last = original[original.length - 1];
+  if (first === void 0 || last === void 0) return void 0;
+  const at = onlyLine(lines, first);
+  if (at === void 0) return void 0;
+  const to = original.length === 1 ? at : onlyLine(lines, last);
+  if (to === void 0 || to < at || to - at + 1 > MAX_RANGE_LINES) return void 0;
+  return { start: at, end: to };
+}
+function onlyLine(lines, text) {
+  let at;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i] !== text) continue;
+    if (at !== void 0) return void 0;
+    at = i + 1;
+  }
+  return at;
+}
+async function classifyCitation(entry, opts) {
+  const { citation } = entry;
+  const range = sourceRange(citation.source);
+  const commit = citation.source["commit-sha"];
+  const result = { src: spellSource(citation.source), status: "missing" };
+  if (commit !== void 0) result.commitSha = commit;
+  const resolved = resolveSourcePath(range, opts.key);
+  if ("reason" in resolved) {
+    result.missingReason = resolved.reason;
+    return result;
+  }
+  const path = resolved.path;
+  const key = range.encrypted ? opts.key : void 0;
+  const pin = citation.source.integrity;
+  const source = await readSource(opts.root, opts.index, range, opts.key, opts.cache);
+  const lines = source.kind === "ok" ? source.lines ?? splitLines(source.text) : void 0;
+  if (source.kind === "missing") result.missingReason = source.reason;
+  else result.resolvedPath = source.resolvedPath;
+  if (lines !== void 0) {
+    let here;
+    try {
+      here = hashLines(sliceLines(lines, range), key);
+    } catch {
+      here = void 0;
+    }
+    if (here === pin) {
+      result.status = "current";
+      return result;
+    }
+  }
+  const counter = { left: opts.budget ?? MOVE_BUDGET_BYTES };
+  let history = { kind: "none" };
+  if (commit !== void 0 && await opts.git.available()) {
+    history = await historyOf(opts.git, commit, path, range, pin, key, opts.budget, counter);
+  }
+  const original = history.kind === "original" ? history.lines : void 0;
+  const spellAt = (at, start, end) => {
+    const written = range.encrypted && opts.key !== void 0 ? encryptSourcePath(at, opts.key) : at;
+    return formatSrc({ path: written, encrypted: range.encrypted, ...start === void 0 ? {} : { start, end } });
+  };
+  if (lines !== void 0 && range.start !== void 0) {
+    const start = range.start;
+    const end = range.end ?? start;
+    const search = { around: start, counter };
+    if (original !== void 0) search.original = original;
+    const found = findWindows(lines, end - start + 1, pin, key, search);
+    if (found.truncated) result.truncatedSearch = true;
+    const spell = (at) => formatSrc({ ...range, start: at, end: at + (end - start) });
+    const [only] = found.starts;
+    if (found.starts.length === 1 && only !== void 0) {
+      result.status = "moved";
+      result.newSrc = spell(only);
+      result.newLines = String(lineSpec({ start: only, end: only + (end - start) }));
+      if (range.encrypted) result.resolvedNewPath = path;
+      return result;
+    }
+    if (found.starts.length > 1) {
+      result.status = "moved-ambiguous";
+      result.candidates = found.starts.map(spell);
+      return result;
+    }
+  }
+  if (commit !== void 0 && original !== void 0) {
+    const across = await followAcross(
+      { git: opts.git, root: opts.root, index: opts.index, commit, own: path, pin, key, original },
+      counter
+    );
+    if (across.truncated) {
+      result.truncatedSearch = true;
+      result.truncatedAcross = true;
+    }
+    const width = range.start === void 0 ? void 0 : original.length - 1;
+    const spell = (hit) => width === void 0 ? spellAt(hit.path) : spellAt(hit.path, hit.start, hit.start + width);
+    if (across.hits.length > 0) delete result.missingReason;
+    const [only] = across.hits;
+    if (across.hits.length === 1 && only !== void 0) {
+      result.status = "moved";
+      result.newSrc = spell(only);
+      if (width !== void 0) {
+        result.newLines = String(lineSpec({ start: only.start, end: only.start + width }));
+      }
+      if (range.encrypted) result.resolvedNewPath = only.path;
+      return result;
+    }
+    if (across.hits.length > 1) {
+      result.status = "moved-ambiguous";
+      result.candidates = across.hits.map(spell);
+      return result;
+    }
+  }
+  if (lines === void 0) return result;
+  if (history.kind === "never-true") {
+    result.status = "never-true";
+    return result;
+  }
+  result.status = "changed";
+  if (history.kind === "unavailable") result.historyAvailable = false;
+  if (history.kind === "unknown") result.truncatedSearch = true;
+  if (original !== void 0 && commit !== void 0) {
+    result.historyAvailable = true;
+    result.commitsSince = await opts.git.subjectsSince(commit, path);
+    result.diff = await opts.git.diffSince(commit, path);
+    const span = range.start === void 0 ? void 0 : spanOf(lines, original);
+    if (span !== void 0) result.newLines = String(lineSpec(span));
+  }
+  return result;
+}
+
+// src/cite/core/git.ts
+import { execFile } from "node:child_process";
+var MAX_BUFFER = 32 * 1024 * 1024;
+var NO_COMMIT = /invalid object name|bad revision|unknown revision|bad object/i;
+var NO_PATH = /does not exist in|exists on disk, but not in|path .* does not exist/i;
+function run(root, args) {
+  return new Promise((resolve4) => {
+    execFile(
+      "git",
+      ["-c", "core.quotepath=false", ...args],
+      { cwd: root, windowsHide: true, maxBuffer: MAX_BUFFER, encoding: "utf8" },
+      (error, stdout, stderr) => {
+        if (error) {
+          const failure = { ok: false, stderr, message: error.message };
+          if (typeof error.code === "number") failure.code = error.code;
+          resolve4(failure);
+        } else resolve4({ ok: true, stdout });
+      }
+    );
+  });
+}
+function gitClient(root) {
+  const memo = /* @__PURE__ */ new Map();
+  const once = (key, compute) => {
+    const held = memo.get(key);
+    if (held !== void 0) return held;
+    const made = compute();
+    memo.set(key, made);
+    return made;
+  };
+  const available = () => once("available", async () => (await run(root, ["rev-parse", "--show-toplevel"])).ok);
+  const failed = (verb, outcome) => new CiteError(`git ${verb} failed: ${outcome.stderr.trim() || outcome.message}`);
+  const shallow = () => once("shallow", async () => {
+    const out = await run(root, ["rev-parse", "--is-shallow-repository"]);
+    return out.ok && out.stdout.trim() === "true";
+  });
+  const hasCommit = (commit) => once(`has\0${commit}`, async () => {
+    const out = await run(root, ["rev-parse", "--verify", "--quiet", "--end-of-options", `${commit}^{commit}`]);
+    if (out.ok) return true;
+    if (out.code === 1) return false;
+    throw failed("rev-parse", out);
+  });
+  return {
+    available,
+    shallow,
+    // `merge-base --is-ancestor` exits 0 for yes and 1 for no. For a commit
+    // it does not have it exits 128, `Not a valid commit name`, which reads
+    // as git failing. So `hasCommit` answers first, and is required rather
+    // than an optimization: a commit git lacks is in no history it holds,
+    // which is a no, and exactly the pin a deleted branch leaves behind.
+    isAncestor: (commit, of) => once(`ancestor\0${commit}\0${of}`, async () => {
+      if (!await hasCommit(commit)) return false;
+      const out = await run(root, ["merge-base", "--is-ancestor", "--end-of-options", commit, of]);
+      if (out.ok) return true;
+      if (out.code === 1) return false;
+      throw failed("merge-base", out);
+    }),
+    head: () => once("head", async () => {
+      if (!await available()) return null;
+      const out = await run(root, ["rev-parse", "HEAD"]);
+      return out.ok ? out.stdout.trim() : null;
+    }),
+    lsFiles: () => once("ls-files", async () => {
+      if (!await available()) return [];
+      const out = await run(root, ["ls-files", "-z"]);
+      if (!out.ok) throw failed("ls-files", out);
+      return out.stdout.split("\0").filter((entry) => entry !== "");
+    }),
+    showFile: (commit, path) => once(`show\0${commit}\0${path}`, async () => {
+      const out = await run(root, ["show", "--end-of-options", `${commit}:./${path}`]);
+      if (out.ok) return { text: out.stdout };
+      if (NO_COMMIT.test(out.stderr)) return { missing: "commit" };
+      if (NO_PATH.test(out.stderr)) {
+        return await hasCommit(commit) ? { missing: "path" } : { missing: "commit" };
+      }
+      throw failed("show", out);
+    }),
+    subjectsSince: (commit, path) => once(`log\0${commit}\0${path}`, async () => {
+      const out = await run(root, ["log", "--format=%s", "--end-of-options", `${commit}..HEAD`, "--", path]);
+      if (!out.ok) throw failed("log", out);
+      return out.stdout.split(/\r?\n/).filter((line) => line !== "");
+    }),
+    // `HEAD` is written out: with no second revision git compares the commit
+    // to the working tree, and this list is committed changes only, so a move
+    // that is merely saved is never followed into a page (0055 stress test 8).
+    changedSince: (commit) => once(`changed\0${commit}`, async () => {
+      if (!await available()) return [];
+      const out = await run(root, ["diff", "--name-only", "--end-of-options", commit, "HEAD"]);
+      if (!out.ok) throw failed("diff", out);
+      return out.stdout.split(/\r?\n/).filter((line) => line !== "");
+    }),
+    diffSince: (commit, path) => once(`diff\0${commit}\0${path}`, async () => {
+      const out = await run(root, ["diff", "--end-of-options", commit, "--", path]);
+      if (!out.ok) throw failed("diff", out);
+      return out.stdout;
+    }),
+    pageCommits: (path, cap) => once(`commits\0${String(cap)}\0${path}`, async () => {
+      if (!await available()) return { commits: [], shallow: false, truncated: false };
+      const out = await run(root, [
+        "log",
+        `--format=%H${UNIT}%s`,
+        "--topo-order",
+        `-n${String(cap + 1)}`,
+        "HEAD",
+        "--",
+        path
+      ]);
+      if (!out.ok) throw failed("log", out);
+      const commits = [];
+      for (const line of out.stdout.split(/\r?\n/)) {
+        if (line === "") continue;
+        const at = line.indexOf(UNIT);
+        if (at === -1) continue;
+        commits.push({ sha: line.slice(0, at), subject: line.slice(at + 1) });
+      }
+      const truncated = commits.length > cap;
+      return { commits: commits.slice(0, cap), shallow: await shallow(), truncated };
+    })
+  };
+}
+var UNIT = "";
+var GIT_UNAVAILABLE_HISTORY = "git is not available here, so citations are checked without history: no never-true, no reanchored claims, no diffs, no commit subjects.";
+var PAGE_HISTORY_UNAVAILABLE = "the page history ends before the pin held; use fetch-depth: 0 to tell reanchored claims from changed ones";
+var SHALLOW_RECOMMIT = "this clone is shallow, so --recommit re-recorded only commits that do not contain their lines. Fetch full history to check the rest.";
+var GIT_UNAVAILABLE_COMMIT = "git is not available here, so the citation records no commit.";
+function noGit() {
+  return {
+    available: () => Promise.resolve(false),
+    head: () => Promise.resolve(null),
+    lsFiles: () => Promise.resolve([]),
+    showFile: () => Promise.resolve({ missing: "commit" }),
+    subjectsSince: () => Promise.resolve([]),
+    diffSince: () => Promise.resolve(""),
+    changedSince: () => Promise.resolve([]),
+    pageCommits: () => Promise.resolve({ commits: [], shallow: false, truncated: false })
+  };
+}
+
+// src/cite/core/history.ts
+var MAX_PAGE_COMMITS = 256;
+function stripMarkers(lines, format) {
+  return lines.filter((line) => !isMarkerLine(line, format));
+}
+function claimWords(lines, format) {
+  return stripMarkers(lines, format).join(" ").replace(/\s+/g, " ").trim();
+}
+function sentencesOf(text) {
+  return text.split(/(?<=[.!?])\s+/).map((sentence) => sentence.replace(/\s+/g, " ").trim().toLowerCase()).filter((sentence) => sentence !== "");
+}
+function sharesSentence(a, b) {
+  const left = new Set(sentencesOf(a));
+  return sentencesOf(b).some((sentence) => left.has(sentence));
+}
+function wordSet(text) {
+  return new Set(
+    text.toLowerCase().split(/\s+/).filter((word) => word !== "")
+  );
+}
+function wordShare(was, now) {
+  const left = wordSet(was);
+  if (left.size === 0) return 1;
+  const right = wordSet(now);
+  let held = 0;
+  for (const word of left) if (right.has(word)) held++;
+  return held / left.size;
+}
+function holdsWords(outer, inner) {
+  if (inner === "") return true;
+  if (outer === inner) return true;
+  if (outer.startsWith(`${inner} `)) return true;
+  if (outer.endsWith(` ${inner}`)) return true;
+  return outer.includes(` ${inner} `);
+}
+function runsHolding(lines, format, bodyLine, inner) {
+  if (inner === "") return [];
+  let text = "";
+  const at = [];
+  for (let n = Math.max(bodyLine, 1); n <= lines.length; n++) {
+    const line = lines[n - 1] ?? "";
+    if (isMarkerLine(line, format)) continue;
+    const words = line.replace(/\s+/g, " ").trim();
+    if (words === "") continue;
+    if (text !== "") {
+      text += " ";
+      at.push(n);
+    }
+    for (let i = 0; i < words.length; i++) at.push(n);
+    text += words;
+  }
+  const out = [];
+  let from = 0;
+  for (; ; ) {
+    const found = text.indexOf(inner, from);
+    if (found === -1) break;
+    from = found + 1;
+    const before = found === 0 ? " " : text[found - 1];
+    const afterAt = found + inner.length;
+    const after = afterAt === text.length ? " " : text[afterAt];
+    if (before !== " " || after !== " ") continue;
+    const start = at[found];
+    const end = at[afterAt - 1];
+    if (start === void 0 || end === void 0) continue;
+    if (!out.some((span) => span.start === start && span.end === end)) out.push({ start, end });
+  }
+  return out.filter(
+    (span) => !out.some(
+      (other) => (other.start !== span.start || other.end !== span.end) && other.start >= span.start && other.end <= span.end
+    )
+  );
+}
+function bounds(line) {
+  return line === void 0 || line.trim() === "" || ANY_FENCE.test(line);
+}
+function pinOf(lines, span) {
+  if (span.start < 1 || span.end > lines.length || span.end < span.start) return void 0;
+  return hashLines(lines.slice(span.start - 1, span.end).join("\n"));
+}
+function readThen(input, text) {
+  const then = readPage(input.page.file, text, { format: input.page.format });
+  const lines = splitLines(then.content);
+  if (input.entry.citation.claim?.lines !== void 0) return { page: then, lines };
+  const id = input.entry.citation.id;
+  if (id === void 0) return void 0;
+  const marker = then.statements.find(
+    (statement) => statement.payload.kind === "ref" && statement.payload.ids.includes(id)
+  );
+  if (marker === void 0) return void 0;
+  return { page: then, lines, marker };
+}
+function anchorHeldAt(input, then) {
+  const pin = input.entry.citation.claim?.integrity;
+  if (pin === void 0) return { kind: "absent" };
+  const was = {
+    citation: input.entry.citation,
+    origin: input.entry.origin,
+    ...then.marker === void 0 ? {} : { marker: then.marker }
+  };
+  const split = then.marker === void 0 ? void 0 : misplacedMarkerAt(then.page, then.lines, then.marker.line, was);
+  const end = claimEnd(then.page, was, then.lines, split);
+  if (end === null || end.status !== "current" && end.status !== "moved") {
+    return { kind: "absent" };
+  }
+  for (const spec of [end.fileLines, end.newFileLines]) {
+    const span = spec === void 0 ? void 0 : parseLines(spec);
+    if (span !== void 0 && pinOf(then.lines, span) === pin) {
+      return { kind: "found", span, lines: then.lines.slice(span.start - 1, span.end) };
+    }
+  }
+  if (split !== void 0) {
+    const text = unitText(then.lines, split);
+    if (hashLines(text.join("\n")) === pin) {
+      return { kind: "found", span: movedUnit(split), lines: text };
+    }
+  }
+  return { kind: "absent" };
+}
+function windowHeldAt(input, then) {
+  const pin = input.entry.citation.claim?.integrity;
+  const marker = then.marker;
+  if (pin === void 0 || marker === void 0) return { kind: "absent" };
+  if (input.entry.citation.quote === true) return { kind: "absent" };
+  const lines = then.lines;
+  let stop = marker.line;
+  for (let n = marker.line + 1; n <= lines.length; n++) {
+    if (bounds(lines[n - 1])) break;
+    stop = n;
+  }
+  const starts = [marker.line];
+  for (let n = marker.line + 1; n <= stop; n++) {
+    const line = lines[n - 1] ?? "";
+    if (line.trim() === "" || isMarkerLine(line, then.page.format)) continue;
+    starts.push(n);
+  }
+  for (const start of starts) {
+    for (let end = start; end <= stop; end++) {
+      if (pinOf(lines, { start, end }) === pin) {
+        return { kind: "found", span: { start, end }, lines: lines.slice(start - 1, end) };
+      }
+    }
+  }
+  return { kind: "absent" };
+}
+async function stillWritten(input, commit, pageText) {
+  const pin = input.entry.citation.claim?.integrity;
+  if (pin === void 0) return { stop: true, born: true };
+  const manifest = input.manifest;
+  if (manifest !== void 0) {
+    const shown = await input.git.showFile(commit, manifest);
+    const held2 = "text" in shown && shown.text.includes(pin);
+    return { stop: !held2, born: !held2 };
+  }
+  const held = pageText.includes(pin);
+  return { stop: false, born: !held };
+}
+async function claimHistory(input) {
+  const { git, path } = input;
+  if (git.pageCommits === void 0) return { kind: "none" };
+  if (!await git.available()) return { kind: "none" };
+  const cap = input.cap ?? MAX_PAGE_COMMITS;
+  const history = await git.pageCommits(path, cap);
+  const { commits } = history;
+  if (commits.length === 0) return { kind: "none" };
+  const format = input.page.format;
+  const baselineAt = (index, then, found) => {
+    if (found.kind !== "found") return { kind: "none" };
+    const commit = commits[index];
+    if (commit === void 0) return { kind: "none" };
+    return {
+      kind: "baseline",
+      commit: commit.sha,
+      commitsSince: commits.slice(0, index).map((c) => c.subject),
+      words: claimWords(found.lines, format),
+      pageWords: claimWords(then.lines.slice(then.page.bodyLine - 1), format),
+      lines: found.lines,
+      at: spellLines(found.span)
+    };
+  };
+  const examined = [];
+  let ended = "cap";
+  let born = false;
+  for (let i = 0; i < commits.length; i++) {
+    const commit = commits[i];
+    if (commit === void 0) continue;
+    const shown = await git.showFile(commit.sha, path);
+    if (!("text" in shown)) {
+      ended = shown.missing === "commit" ? "unavailable" : "birth";
+      break;
+    }
+    const then = readThen(input, shown.text);
+    if (then === void 0) {
+      ended = "birth";
+      break;
+    }
+    examined.push(then);
+    const found = anchorHeldAt(input, then);
+    if (found.kind === "found") return baselineAt(i, then, found);
+    const written = await stillWritten(input, commit.sha, shown.text);
+    if (written.born) born = true;
+    if (written.stop) {
+      ended = "birth";
+      break;
+    }
+  }
+  for (const [i, then] of examined.entries()) {
+    const found = windowHeldAt(input, then);
+    if (found.kind === "found") return baselineAt(i, then, found);
+  }
+  if (ended === "birth" || born) return { kind: "none" };
+  if (ended === "unavailable") return { kind: "unavailable" };
+  return history.truncated || history.shallow ? { kind: "unavailable" } : { kind: "none" };
+}
+function claimDiff(input) {
+  const a = input.was.lines;
+  const b = input.now.lines;
+  let head = 0;
+  while (head < a.length && head < b.length && a[head] === b[head]) head++;
+  let tail = 0;
+  while (tail < a.length - head && tail < b.length - head && a[a.length - 1 - tail] === b[b.length - 1 - tail]) {
+    tail++;
+  }
+  const out = [
+    `--- ${input.file}@${shortCommit(input.commit)}:${input.was.at}`,
+    `+++ ${input.file}:${input.now.at}`
+  ];
+  for (const line of a.slice(0, head)) out.push(` ${line}`);
+  for (const line of a.slice(head, a.length - tail)) out.push(`-${line}`);
+  for (const line of b.slice(head, b.length - tail)) out.push(`+${line}`);
+  for (const line of a.slice(a.length - tail)) out.push(` ${line}`);
+  return out.join("\n");
+}
+function refineClaim(input) {
+  const { claim, history, entry, page, lines } = input;
+  if (history.kind === "unavailable") return { ...claim, historyAvailable: false };
+  if (history.kind === "none") return claim;
+  const format = page.format;
+  const base = {
+    ...claim,
+    commitSha: history.commit,
+    historyAvailable: true,
+    commitsSince: history.commitsSince,
+    baselineText: history.lines
+  };
+  const withDiff = (end, now2) => {
+    const diff = claimDiff({
+      file: page.file,
+      commit: history.commit,
+      was: { at: history.at, lines: history.lines },
+      now: now2
+    });
+    return { ...end, diff };
+  };
+  if (entry.citation.quote === true) {
+    const now2 = claim.text ?? [];
+    const same = stripMarkers(now2, format).join("\n") === stripMarkers(history.lines, format).join("\n");
+    const at = claim.fileLines ?? history.at;
+    return withDiff(same ? { ...base, status: "reanchored" } : base, { at, lines: now2 });
+  }
+  if (entry.citation.claim?.lines === void 0) {
+    const now2 = claim.text ?? [];
+    const w12 = claimWords(now2, format);
+    const at = claim.fileLines ?? history.at;
+    const held = holdsWords(w12, history.words) && holdsWords(history.pageWords, w12);
+    return withDiff(held ? { ...base, status: "reanchored" } : base, { at, lines: now2 });
+  }
+  const runs = runsHolding(lines, format, page.bodyLine, history.words);
+  const [only] = runs;
+  if (runs.length > 1) {
+    return {
+      ...claim,
+      status: "moved-ambiguous",
+      candidates: runs.map((span) => spellLines(toBodyLines(span, page.bodyLine))),
+      candidateFileLines: runs.map(spellLines)
+    };
+  }
+  if (only === void 0) {
+    return withDiff(base, { at: claim.fileLines ?? history.at, lines: claim.text ?? [] });
+  }
+  const now = lines.slice(only.start - 1, only.end);
+  const w1 = claimWords(now, format);
+  if (!holdsWords(history.pageWords, w1)) {
+    return withDiff(base, { at: claim.fileLines ?? history.at, lines: claim.text ?? [] });
+  }
+  return withDiff(
+    {
+      ...base,
+      status: "reanchored",
+      newLines: spellLines(toBodyLines(only, page.bodyLine)),
+      newFileLines: spellLines(only)
+    },
+    { at: spellLines(only), lines: now }
+  );
+}
+
+// src/cite/core/check-page.ts
+function byLine(a, b) {
+  return (a.line ?? Number.MAX_SAFE_INTEGER) - (b.line ?? Number.MAX_SAFE_INTEGER);
+}
+function relevel(finding, severity) {
+  const level = severity[finding.rule];
+  if (level === "off") return void 0;
+  return { ...finding, severity: level };
+}
+async function citedNow(input, source, entry) {
+  const range = sourceRange(entry.citation.source);
+  const read = await readSource(input.root, input.index, range, input.key, input.cache);
+  if (read.kind === "missing") return void 0;
+  const at = source.status === "moved" && source.newSrc !== void 0 ? parseSrc(source.newSrc) : range;
+  try {
+    return sliceLines(read.lines ?? splitLines(read.text), at);
+  } catch {
+    return void 0;
+  }
+}
+function faithful(blockText, pin, key, now) {
+  return hashLines(splitLines(blockText).join("\n"), key) === pin || now !== void 0 && blockMatches(blockText, now);
+}
+function insideOf(lines, block) {
+  return lines.slice(block.start, block.end - 1).join("\n");
+}
+async function quoteFindings(input, entry, result) {
+  const { citation } = entry;
+  if (citation.quote !== true || result.anchor === null) return [];
+  const id = citation.id;
+  const named = (text) => id === void 0 ? text : `${id}: ${text}`;
+  const { page } = input;
+  let block;
+  if (result.anchor === "marker" && entry.marker !== void 0) {
+    block = anchoredLines(page.content, entry.marker.end, page.format, true);
+    if (block === void 0) {
+      return [
+        {
+          rule: "quote-drift",
+          message: "quote: true, but no fenced block follows the marker",
+          ...result.markerLine === void 0 ? {} : { line: result.markerLine }
+        }
+      ];
+    }
+  } else {
+    const at = result.claim === null ? void 0 : claimLinesNow(result.claim);
+    if (at === void 0) return [];
+    const span = fenceSpanAt(page.content, at.start, page.format);
+    if (span === void 0 || span.end !== at.end) {
+      return [
+        {
+          rule: "anchor-invalid",
+          message: named(
+            `the quote's claim lines ${at.start === at.end ? String(at.start) : `${String(at.start)}-${String(at.end)}`} are no longer a fenced block.`
+          ),
+          line: at.start
+        }
+      ];
+    }
+    block = span;
+  }
+  if (!input.checkSources || result.source.status === "missing") return [];
+  const key = sourceRange(citation.source).encrypted ? input.key : void 0;
+  const now = await citedNow(input, result.source, entry);
+  const inside = insideOf(input.lines, block);
+  if (faithful(inside, citation.source.integrity, key, now)) return [];
+  return [
+    {
+      rule: "quote-drift",
+      message: "quote: true, but the fenced block does not reproduce the cited lines",
+      line: block.start
+    }
+  ];
+}
+function markerEnd(entry, misplaced) {
+  const { marker } = entry;
+  if (marker === void 0) return {};
+  if (misplaced === void 0) return { marker: { line: marker.line } };
+  return {
+    marker: {
+      line: marker.line,
+      misplaced: { unit: spellLines(misplaced.unit), to: misplaced.to }
+    }
+  };
+}
+function anchorOf(entry, claim, page) {
+  const { citation, marker } = entry;
+  const hasLines = citation.claim?.lines !== void 0;
+  const out = { anchor: null };
+  if (marker !== void 0) out.markerLine = marker.line;
+  if (hasLines && marker !== void 0) return out;
+  if (hasLines) {
+    out.anchor = "claim";
+    const at = claim === null ? void 0 : claimLineNow(claim);
+    if (at !== void 0) out.anchorLine = at;
+    return out;
+  }
+  if (marker !== void 0) {
+    out.anchor = "marker";
+    const unit = anchoredLines(page.content, marker.end, page.format, citation.quote === true);
+    out.anchorLine = unit?.start ?? marker.line;
+  }
+  return out;
+}
+async function checkCitations(page, opts) {
+  const readOptions = {};
+  if (page.format !== void 0) readOptions.format = page.format;
+  if (opts.citations !== void 0) readOptions.citations = opts.citations;
+  if (opts.owned !== void 0) readOptions.owned = opts.owned;
+  const read = readPage(page.file, page.content, readOptions);
+  const severity = resolveSeverity(opts.severity);
+  const client = opts.gitClient ?? gitClient(opts.root);
+  const pageGit = opts.pageGitClient ?? (opts.pageRoot === void 0 || opts.pageRoot === opts.root ? client : gitClient(opts.pageRoot));
+  const checkSources = opts.checkSources !== false;
+  const lines = splitLines(read.content);
+  const results = [];
+  const findings = [];
+  const notices = [];
+  for (const finding of read.findings) {
+    const kept = relevel(finding, severity);
+    if (kept !== void 0) findings.push(kept);
+  }
+  const index = checkSources ? opts.sourceIndex ?? await buildSourceIndex(opts.root, { gitClient: client }) : void 0;
+  const classifyOpts = index === void 0 ? void 0 : {
+    root: opts.root,
+    index,
+    git: client,
+    ...opts.key === void 0 ? {} : { key: opts.key },
+    ...opts.sourceCache === void 0 ? {} : { cache: opts.sourceCache }
+  };
+  const quoteInput = {
+    page: read,
+    lines,
+    root: opts.root,
+    index: index ?? emptyIndex,
+    checkSources,
+    ...opts.key === void 0 ? {} : { key: opts.key },
+    ...opts.sourceCache === void 0 ? {} : { cache: opts.sourceCache }
+  };
+  const misplaced = misplacedMarkers(read, lines);
+  const misplacedAt = new Map(misplaced.map((found) => [found.line, found]));
+  for (const entry of read.citations) {
+    const split = entry.marker === void 0 ? void 0 : misplacedAt.get(entry.marker.line);
+    const claim = await withClaimHistory(
+      { page: read, entry, claim: claimEnd(read, entry, lines, split), lines },
+      { path: read.file, git: pageGit, ...opts.pageCommitCap === void 0 ? {} : { cap: opts.pageCommitCap }, ...opts.owned === void 0 ? {} : { manifest: opts.owned.file } }
+    );
+    const source = classifyOpts === void 0 ? skippedSource(entry) : await classifyCitation(entry, classifyOpts);
+    const result = {
+      citation: entry.citation,
+      origin: entry.origin,
+      ...anchorOf(entry, claim, read),
+      ...markerEnd(entry, split),
+      claim,
+      source
+    };
+    results.push(result);
+    for (const found of await quoteFindings(quoteInput, entry, result)) {
+      const level = severity[found.rule];
+      if (level === "off") continue;
+      const finding = {
+        rule: found.rule,
+        ruleId: ruleId(found.rule),
+        severity: level,
+        message: found.message,
+        src: source.src,
+        index: entry.origin.index
+      };
+      if (found.line !== void 0) finding.line = found.line;
+      if (entry.citation.id !== void 0) finding.id = entry.citation.id;
+      findings.push(finding);
+    }
+  }
+  const misplacedLevel = severity["marker-misplaced"];
+  if (misplacedLevel !== "off") {
+    for (const found of misplaced) {
+      const entry = found.entry;
+      const finding = {
+        rule: "marker-misplaced",
+        ruleId: ruleId("marker-misplaced"),
+        severity: misplacedLevel,
+        message: misplacedMessageFor(entry?.citation.id, {
+          line: found.line,
+          unit: spellLines(found.unit),
+          place: found.place,
+          block: found.block
+        }),
+        line: found.line
+      };
+      if (entry !== void 0) {
+        finding.index = entry.origin.index;
+        finding.src = spellSource(entry.citation.source);
+        if (entry.citation.id !== void 0) finding.id = entry.citation.id;
+      }
+      findings.push(finding);
+    }
+  }
+  findings.push(...findingsFor(results, severity));
+  const wantsSourceHistory = checkSources && read.citations.some(({ citation }) => citation.source["commit-sha"] !== void 0);
+  const wantsClaimHistory = results.some((r) => r.claim?.status === "changed");
+  if (wantsSourceHistory && !await client.available()) notices.push(GIT_UNAVAILABLE_HISTORY);
+  else if (wantsClaimHistory && !await pageGit.available()) {
+    notices.push(GIT_UNAVAILABLE_HISTORY);
+  }
+  if (results.some((r) => r.claim?.historyAvailable === false)) {
+    notices.push(PAGE_HISTORY_UNAVAILABLE);
+  }
+  const unavailable = results.find((r) => r.source.historyAvailable === false);
+  if (unavailable?.source.commitSha !== void 0) {
+    notices.push(
+      `commit ${unavailable.source.commitSha.slice(0, 7)} not found in history; use fetch-depth: 0 to enable never-true and diffs`
+    );
+  }
+  const budget = String(MOVE_BUDGET_BYTES / (1024 * 1024));
+  if (results.some((r) => r.source.truncatedSearch === true && r.source.truncatedAcross !== true)) {
+    notices.push(
+      `a move search hit its ${budget} MiB budget before covering the file; a citation may read changed rather than moved`
+    );
+  }
+  if (results.some((r) => r.source.truncatedAcross === true)) {
+    notices.push(
+      `a move search hit its ${budget} MiB budget before covering the files changed since the pin's commit; a citation may read changed or missing rather than moved`
+    );
+  }
+  return {
+    file: read.file,
+    format: read.format,
+    citations: results,
+    findings: findings.sort(byLine),
+    notices
+  };
+}
+async function withClaimHistory(now, read) {
+  const { claim } = now;
+  if (claim === null || claim.status !== "changed") return claim;
+  if (read.path === STDIN_LABEL) return claim;
+  const input = { page: now.page, entry: now.entry, claim, ...read };
+  const history = await claimHistory(input);
+  return refineClaim({ ...input, lines: now.lines, history });
+}
+function skippedSource(entry) {
+  const { source } = entry.citation;
+  const out = { src: spellSource(source), status: "skipped" };
+  if (source["commit-sha"] !== void 0) out.commitSha = source["commit-sha"];
+  return out;
+}
+var emptyIndex = { files: () => [], has: () => false };
+
+// src/cite/core/config.ts
+import { resolve } from "node:path";
+var CITE_SECTION = "cite";
+var DEFAULT_CITE_BASELINE_PATH = ".manni-cite-baseline.json";
+var CONFIG_KEYS = [
+  "allowEmpty",
+  "respectGitignore",
+  "root",
+  "baseline",
+  "checkSources",
+  "severity"
+];
+var SALT_KEY = "salt";
+var saltRefusal = (source) => `${source}: "salt" is no longer a cite key. Values are encrypted with a family key: a top-level encryptionKey:, or MANNI_ENCRYPTION_KEY. Run \`manni key set\`.`;
+var SEVERITY_LEVELS = [...[...SEVERITIES].reverse(), "off"];
+function isLevel(value) {
+  return typeof value === "string" && SEVERITY_LEVELS.includes(value);
+}
+var CONFIG_REF = "https://hawkeyexl.github.io/manni/meta/reference/configuration/";
+var MOVED_KEYS = ["paths", "exclude"];
+function assertNoMovedKeys(raw, source) {
+  for (const key of MOVED_KEYS) {
+    if (Object.hasOwn(raw, key)) {
+      throw new CiteError(
+        `${source}: "${key}" is no longer a cite key. Document sets are declared once for every tool, under a top-level collections: list. See ${CONFIG_REF}#collections`
+      );
+    }
+  }
+}
+var CONFIG_FILE = {
+  section: CITE_SECTION,
+  // The citation tool never had a file of its own before the family file.
+  legacyNames: [],
+  toError: (message) => new CiteError(message)
+};
+function rejectUnknownKeys(obj, allowed, where, source) {
+  for (const key of Object.keys(obj)) {
+    if (!allowed.includes(key)) {
+      throw new CiteError(
+        `Unknown key "${key}" under ${where}: in ${source}. Supported keys: ${allowed.join(", ")}.`
+      );
+    }
+  }
+}
+function wrongType(key, expected, source) {
+  return new CiteError(`cite.${key} in ${source} must be ${expected}.`);
+}
+function asBoolean(value, key, source) {
+  if (typeof value !== "boolean") throw wrongType(key, "a boolean", source);
+  return value;
+}
+function asString(value, key, source) {
+  if (typeof value !== "string") throw wrongType(key, "a string", source);
+  return value;
+}
+function isMapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseSeverity(value, source) {
+  if (!isMapping(value)) throw wrongType("severity", "a mapping", source);
+  rejectUnknownKeys(value, CITE_RULES, "cite.severity", source);
+  const severity = {};
+  for (const [rule, level] of Object.entries(value)) {
+    if (!isCiteRule(rule)) continue;
+    if (!isLevel(level)) {
+      const got = typeof level === "string" ? `, not "${level}"` : "";
+      throw new CiteError(
+        `cite.severity.${rule} in ${source} must be one of ${SEVERITY_LEVELS.join(", ")}${got}.`
+      );
+    }
+    severity[rule] = level;
+  }
+  return severity;
+}
+function parseCiteConfig(raw, source) {
+  if (raw == null) return {};
+  if (!isMapping(raw)) {
+    throw new CiteError(`cite: in ${source} must be a mapping.`);
+  }
+  assertNoMovedKeys(raw, source);
+  if (Object.hasOwn(raw, SALT_KEY)) throw new CiteError(saltRefusal(source));
+  rejectUnknownKeys(raw, CONFIG_KEYS, "cite", source);
+  const config = {};
+  if (raw.allowEmpty !== void 0)
+    config.allowEmpty = asBoolean(raw.allowEmpty, "allowEmpty", source);
+  if (raw.respectGitignore !== void 0)
+    config.respectGitignore = asBoolean(raw.respectGitignore, "respectGitignore", source);
+  if (raw.root !== void 0) config.root = asString(raw.root, "root", source);
+  if (raw.baseline !== void 0)
+    config.baseline = asString(raw.baseline, "baseline", source);
+  if (raw.checkSources !== void 0)
+    config.checkSources = asBoolean(raw.checkSources, "checkSources", source);
+  if (raw.severity !== void 0) config.severity = parseSeverity(raw.severity, source);
+  return config;
+}
+function readCiteConfigFile(explicitPath, cwd) {
+  return explicitPath ? readConfigFile(explicitPath, cwd, CONFIG_FILE) : findConfigFile(cwd, CONFIG_FILE);
+}
+async function loadCiteConfig(explicitPath, cwd = process.cwd()) {
+  const file = await readCiteConfigFile(explicitPath, cwd);
+  return file === null ? null : toLoaded(file);
+}
+function toLoaded(file) {
+  return {
+    config: parseCiteConfig(file.value, file.source),
+    path: file.path,
+    dir: file.dir,
+    source: file.source,
+    collections: file.collections
+  };
+}
+var STDIN = "-";
+async function resolveCiteRun(opts) {
+  const cwd = resolve(opts.cwd);
+  const env = opts.env ?? process.env;
+  const wanted = opts.collection ?? [];
+  const typedInputs = opts.inputs.filter((input) => input !== STDIN);
+  if (wanted.length > 0 && typedInputs.length > 0) {
+    throw new CiteError(
+      "--collection selects a configured collection; it cannot be combined with paths."
+    );
+  }
+  const file = opts.noConfig ? null : await readCiteConfigFile(opts.configPath, cwd);
+  const loaded = file === null ? null : toLoaded(file);
+  if (wanted.length > 0 && loaded === null) {
+    throw new CiteError("--collection needs a config file to select from.");
+  }
+  if (loaded) opts.onConfigLoaded?.({ path: loaded.path, dir: loaded.dir });
+  const config = loaded ? loaded.config : null;
+  const collections = loaded ? selectCollections(loaded.collections, wanted, loaded.source, (message) => new CiteError(message)) : [];
+  const fromCollections = wanted.length > 0 || opts.inputs.length === 0;
+  const collectionPaths = fromCollections ? collections.flatMap((c) => c.paths) : [];
+  const inputs = fromCollections ? [...opts.inputs, ...collectionPaths] : opts.inputs;
+  const base = collectionPaths.length > 0 && loaded ? loaded.dir : cwd;
+  let root;
+  if (opts.root !== void 0) {
+    root = resolve(cwd, opts.root);
+  } else if (loaded && config?.root !== void 0) {
+    root = resolve(loaded.dir, config.root);
+  } else {
+    const gitRoot = findGitRoot(cwd);
+    if (gitRoot !== null) {
+      root = gitRoot;
+    } else {
+      root = cwd;
+      if (opts.resolvesSources !== false) {
+        opts.onNotice?.(`No git root found; resolving src: paths from ${cwd}`);
+      }
+    }
+  }
+  const { key, source: keySource } = resolveEncryptionKey({
+    env,
+    file,
+    toError: (message) => new CiteError(message)
+  });
+  return {
+    config,
+    inputs,
+    base,
+    collections,
+    fromCollections,
+    ...loaded ? { configDir: loaded.dir, configPath: loaded.path, configSource: loaded.source } : {},
+    root,
+    key,
+    keySource,
+    ...file === null ? {} : { configFile: file }
+  };
+}
+
+// src/cite/core/sidecar.ts
+import { existsSync } from "node:fs";
+import { isAbsolute, relative, resolve as resolve2, sep as sep2 } from "node:path";
+var CITATIONS_KEY = "citations";
+var toPosix = (path) => path.split(sep2).join("/");
+function reportedPath(abs, base) {
+  const rel = relative(base, abs);
+  return rel === "" ? "." : toPosix(rel);
+}
+function urlManifestRefusal(source, collection) {
+  return `${source}: collection ${collection}: ${CITATIONS_KEY} cannot come from a URL manifest, because cite writes them.`;
+}
+function twoManifestsRefusal(label, a, b) {
+  return `${label} is in collections ${a} and ${b}, and both keep citations in a manifest.`;
+}
+function ownsCitations(manifest) {
+  return manifest.keys === void 0 || manifest.keys.includes(CITATIONS_KEY);
+}
+function emptyIndex2() {
+  return { owners: /* @__PURE__ */ new Map(), byPath: /* @__PURE__ */ new Map(), byField: /* @__PURE__ */ new Map(), entries: [] };
+}
+async function loadCitationSidecars(opts) {
+  const toError = opts.toError ?? ((message) => new CiteError(message));
+  const manifests = [];
+  const urls = [];
+  const scoped = [];
+  for (const collection of opts.collections) {
+    const owning = collection.externalMetadata.filter(ownsCitations);
+    if (owning.length === 0) continue;
+    const loaded = [];
+    for (const manifest of owning) {
+      const implied = manifest.keys === void 0 ? { implied: { collection, manifest } } : {};
+      if (classifyRef(manifest.file).kind === "url") {
+        if (manifest.keys !== void 0) {
+          throw toError(urlManifestRefusal(opts.configSource, collection.name));
+        }
+        urls.push({ collection: collection.name, path: manifest.file, file: manifest.file, join: externalMetadataJoin(manifest), ...implied });
+        continue;
+      }
+      loaded.push(manifest);
+      const path = isAbsolute(manifest.file) ? manifest.file : resolve2(opts.configDir, manifest.file);
+      manifests.push({
+        collection: collection.name,
+        path,
+        file: reportedPath(path, opts.base),
+        join: externalMetadataJoin(manifest),
+        ...hasPagePlaceholder(manifest.file) ? { pattern: manifest.file } : {},
+        ...implied
+      });
+    }
+    if (loaded.length > 0) scoped.push({ ...collection, externalMetadata: loaded });
+  }
+  if (manifests.length === 0 && urls.length === 0) return null;
+  const index = await loadExternalMetadata(scoped, {
+    configDir: opts.configDir,
+    base: opts.base,
+    ...opts.pages === void 0 ? {} : { pages: opts.pages }
+  }) ?? (urls.length > 0 ? emptyIndex2() : null);
+  if (index === null) return null;
+  return sidecars(index, manifests, urls, scoped, opts);
+}
+function sidecars(index, manifests, urls, collections, opts) {
+  const toError = opts.toError ?? ((message) => new CiteError(message));
+  const { configDir, base } = opts;
+  let marks;
+  const marksOnce = () => marks ??= opts.marks?.() ?? Promise.resolve(void 0);
+  const pageOwner = (owner, label) => {
+    if (owner.pattern === void 0) return owner;
+    const resolved = pageManifestPath(owner.pattern, configDir, resolve2(base, label));
+    if ("outside" in resolved) return void 0;
+    return { ...owner, path: resolved.abs, file: reportedPath(resolved.abs, base) };
+  };
+  const forPage = async (label, content, format) => {
+    const declaredMembers = memberOf(opts.collections, configDir, base, label);
+    if (declaredMembers.length === 0) return { joins: [] };
+    const members = memberOf(collections, configDir, base, label);
+    const memberOfCollection = (m) => declaredMembers.includes(m.collection);
+    let extracted;
+    const extract = () => extracted ??= pickExtractor(label, format).extract(content, label);
+    const candidates2 = [...manifests, ...urls].filter((m) => m.implied !== void 0 && memberOfCollection(m));
+    let marked;
+    if (candidates2.length > 0) {
+      const read = await marksOnce();
+      const data = extract().data;
+      marked = read === void 0 ? void 0 : await read(label, Object.hasOwn(data, CITATIONS_KEY) ? data : { ...data, [CITATIONS_KEY]: null }, declaredMembers);
+    }
+    const keeps = (m) => m.implied === void 0 || ownsKey(m.implied.collection, m.implied.manifest, CITATIONS_KEY, marked);
+    const url = urls.find((m) => memberOfCollection(m) && keeps(m));
+    if (url !== void 0) throw toError(urlManifestRefusal(opts.configSource, url.collection));
+    const mine = manifests.filter((m) => members.includes(m.collection) && keeps(m));
+    const [declared, second] = mine;
+    if (declared === void 0) return { joins: [] };
+    if (second !== void 0) {
+      throw toError(twoManifestsRefusal(label, declared.collection, second.collection));
+    }
+    const owner = pageOwner(declared, label);
+    if (owner === void 0) return { joins: [] };
+    const readMarks = await marksOnce();
+    const merged = await mergeWithMarks(label, extract(), index, members, base, {
+      encryptionKey: () => opts.key,
+      ...readMarks === void 0 ? {} : { marks: readMarks }
+    });
+    const out = { owner, joins: merged.joins };
+    if (owner.join === PATH_JOIN) {
+      out.entry = toPosix(relative(configDir, resolve2(base, label)));
+    } else {
+      const value = merged.joins.find((j) => j.field === owner.join)?.value;
+      const raw = value ?? extract().data[owner.join];
+      if (typeof raw === "string" && raw !== "") out.entry = raw;
+      else if (typeof raw === "number" || typeof raw === "boolean") out.entry = String(raw);
+    }
+    const where = merged.locate(`/${CITATIONS_KEY}`);
+    if (where !== void 0) {
+      const supplied = merged.extracted.data[CITATIONS_KEY];
+      const list = Array.isArray(supplied) ? supplied : [supplied];
+      out.citations = list.map((entry, i) => {
+        const at = merged.locate(`/${CITATIONS_KEY}/${String(i)}`);
+        const line = (Array.isArray(supplied) ? at?.line : void 0) ?? where.line;
+        return {
+          entry,
+          origin: {
+            kind: "manifest",
+            file: where.file,
+            ...line === void 0 ? {} : { line }
+          }
+        };
+      });
+    }
+    return out;
+  };
+  const ignoredManifests = async (loaded) => {
+    const existing = /* @__PURE__ */ new Set();
+    for (const label of loaded) {
+      const members = memberOf(collections, configDir, base, label);
+      for (const declared of manifests) {
+        if (declared.pattern === void 0 || !members.includes(declared.collection)) continue;
+        const owner = pageOwner(declared, label);
+        if (owner !== void 0 && existsSync(owner.path)) existing.add(owner.file);
+      }
+    }
+    if (existing.size === 0) return [];
+    const { ignored } = await gitIgnored([...existing], base);
+    return [...existing].filter((file) => ignored.has(file));
+  };
+  return {
+    manifests,
+    configDir,
+    base,
+    forPage,
+    orphans: (loaded, covered) => orphanEntries(index, loaded, base, covered),
+    orphanJoins: (matched, covered) => orphanJoins(index, matched, covered),
+    ignoredManifests
+  };
+}
+function ignoredManifestWarning(file) {
+  return `${file} is covered by .gitignore, so CI checks out a page with no citations.`;
+}
+function orphanRefusal(orphans, toError = (m) => new CiteError(m)) {
+  return toError(orphanError(orphans).message);
+}
+function duplicateJoinRefusal(field, value, file, labels) {
+  return `${String(labels.length)} pages carry ${field} "${value}"; ${file} cannot tell them apart (${labels.join(", ")}).`;
+}
+function sidecarsFor(run2, over = {}) {
+  const declared = run2.configFile?.collections ?? [];
+  if (run2.configDir === void 0 || declared.length === 0) return Promise.resolve(null);
+  const { configPath } = run2;
+  return loadCitationSidecars({
+    // Every declared collection, whatever `--collection` or the paths chose.
+    collections: declared,
+    configDir: run2.configDir,
+    base: over.base ?? run2.base,
+    configSource: run2.configSource ?? run2.configPath ?? "the config",
+    ...run2.key === void 0 ? {} : { key: run2.key },
+    ...over.toError === void 0 ? {} : { toError: over.toError },
+    ...over.pages === void 0 ? {} : { pages: over.pages },
+    // A keyless manifest (proposal 0068) keeps what a page's schemas mark,
+    // read from meta's section of the same file.
+    ...configPath === void 0 ? {} : { marks: () => configMarks(configPath, run2.base) }
+  });
+}
+
+// src/cite/commands/check.ts
+function joinHits() {
+  const matched = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Map();
+  return {
+    matched,
+    record(page, label) {
+      for (const join2 of page.joins) {
+        const values = matched.get(join2.field) ?? /* @__PURE__ */ new Set();
+        values.add(join2.value);
+        matched.set(join2.field, values);
+        const id = `${join2.field}\0${join2.value}`;
+        const hit = seen.get(id) ?? { file: join2.file, labels: [] };
+        if (!hit.labels.includes(label)) hit.labels.push(label);
+        seen.set(id, hit);
+        if (hit.labels.length > 1) {
+          throw new CiteError(
+            duplicateJoinRefusal(join2.field, join2.value, join2.file, hit.labels)
+          );
+        }
+      }
+    }
+  };
+}
+async function prepareRun(opts, action, verb, sources = {}) {
+  const requireSources = sources.require === true;
+  const cwd = resolve3(opts.cwd ?? process.cwd());
+  const run2 = await resolveCiteRun({
+    cwd,
+    configPath: opts.configPath,
+    noConfig: opts.noConfig,
+    inputs: opts.inputs,
+    collection: opts.collection,
+    root: opts.root,
+    onConfigLoaded: opts.onConfigLoaded,
+    onNotice: opts.onNotice,
+    env: opts.env,
+    ...sources.resolve === false ? { resolvesSources: false } : {}
+  });
+  const { config, inputs, base } = run2;
+  const checkSources = opts.checkSources ?? config?.checkSources ?? true;
+  if (requireSources && !checkSources) {
+    throw new CiteError(`${verb} needs the sources: drop --no-check-sources (or \`checkSources: false\`).`);
+  }
+  if (inputs.length === 0) {
+    throw new CiteError(
+      `No files to ${verb}. Pass paths/globs, or declare a collection under \`collections:\` in manni.config.yaml.`
+    );
+  }
+  const usingStdin = inputs.includes(STDIN_TOKEN);
+  const forced = opts.as === void 0 ? void 0 : extractorByName(opts.as);
+  if (opts.as !== void 0 && forced === void 0) {
+    throw new CiteError(
+      `Unknown format "${opts.as}". Supported extensions: ${supportedExtensions().join(", ")}.`
+    );
+  }
+  if (usingStdin && forced === void 0) {
+    throw new CiteError(STDIN_REQUIRES_AS);
+  }
+  const exts = opts.exts ?? forced?.extensions;
+  const fileInputs = inputs.filter((input) => input !== STDIN_TOKEN);
+  const allowEmpty = opts.allowEmpty ?? config?.allowEmpty;
+  const exclude = [
+    .../* @__PURE__ */ new Set([
+      ...opts.exclude ?? [],
+      ...run2.fromCollections ? run2.collections.flatMap((c) => c.exclude) : []
+    ])
+  ];
+  const { files, gitignoreSkipped } = await resolveTargetSet({
+    inputs: fileInputs,
+    exts,
+    exclude,
+    cwd: base,
+    allowEmpty,
+    ...gitignoreOptions({
+      flag: opts.respectGitignore,
+      configured: config?.respectGitignore,
+      onNotice: opts.onNotice
+    })
+  });
+  assertNonEmpty({ files, inputs: fileInputs, usingStdin, allowEmpty, exclude, exts, gitignoreSkipped, action });
+  const git = opts.gitClient ?? gitClient(run2.root);
+  const pageGit = opts.pageGitClient ?? (run2.base === run2.root ? git : gitClient(run2.base));
+  const pageOptions = {
+    root: run2.root,
+    checkSources,
+    key: run2.key,
+    severity: config?.severity,
+    gitClient: git,
+    pageRoot: run2.base,
+    pageGitClient: pageGit
+  };
+  if (checkSources) pageOptions.sourceIndex = await sourceIndexFor(run2.root, git);
+  const sidecars2 = await sidecarsFor(run2, { pages: files.map((file) => resolve3(base, file)) });
+  const setupFor = async (label, content) => {
+    const page = await sidecars2?.forPage(label, content, forced?.name);
+    if (page?.owner === void 0) return { options: pageOptions };
+    return {
+      sidecar: page,
+      options: {
+        ...pageOptions,
+        owned: { file: page.owner.file, collection: page.owner.collection },
+        ...page.citations === void 0 ? {} : { citations: page.citations }
+      }
+    };
+  };
+  const scopedByFlags = (
+    // The inputs the operator typed, not the collection globs they resolved
+    // to: a corpus run has none of the first and all of the second.
+    opts.inputs.length > 0 || usingStdin || opts.as !== void 0 || opts.exts !== void 0 || opts.exclude !== void 0 && opts.exclude.length > 0 || opts.respectGitignore !== void 0
+  );
+  const covered = (opts.collection?.length ?? 0) > 0 ? run2.collections.map((c) => c.name) : void 0;
+  return {
+    cwd,
+    run: run2,
+    files,
+    gitignoreSkipped,
+    usingStdin,
+    forced,
+    pageOptions,
+    git,
+    sidecars: sidecars2,
+    setupFor,
+    scopedByFlags,
+    ...covered === void 0 ? {} : { covered }
+  };
+}
+async function assertNoOrphans(prepared) {
+  const { sidecars: sidecars2 } = prepared;
+  if (sidecars2 === null || prepared.scopedByFlags) return;
+  const orphans = sidecars2.orphans(prepared.files, prepared.covered);
+  if (orphans.length > 0) throw orphanRefusal(orphans);
+  if (prepared.covered !== void 0) return;
+  for (const file of await sidecars2.ignoredManifests(prepared.files)) warn(ignoredManifestWarning(file));
+}
+function assertNoOrphanJoins(prepared, hits) {
+  const { sidecars: sidecars2 } = prepared;
+  if (sidecars2 === null || prepared.scopedByFlags) return;
+  const orphans = sidecars2.orphanJoins(hits.matched, prepared.covered);
+  if (orphans.length > 0) throw orphanRefusal(orphans);
+}
+function readTarget(run2, file) {
+  return readFile2(resolve3(run2.base, file), "utf8");
+}
+function sayNotices(pages, onNotice, also = []) {
+  const said = /* @__PURE__ */ new Set();
+  for (const notice of [...pages.flatMap((page) => page.notices), ...also]) {
+    if (said.has(notice)) continue;
+    said.add(notice);
+    onNotice?.(notice);
+  }
+}
+async function runCheck(opts) {
+  const prepared = await prepareRun(opts, "checked", "check");
+  const { cwd, run: run2, files, gitignoreSkipped, usingStdin, forced, pageOptions, git } = prepared;
+  await assertNoOrphans(prepared);
+  const hits = joinHits();
+  pageOptions.sourceCache = createSourceCache();
+  const pages = [];
+  const checkOne = async (label, content) => {
+    const setup = await prepared.setupFor(label, content);
+    if (setup.sidecar !== void 0) hits.record(setup.sidecar, label);
+    pages.push(await checkCitations({ file: label, content, format: forced?.name }, setup.options));
+  };
+  if (usingStdin) await checkOne(STDIN_LABEL, opts.stdinContent ?? "");
+  for (const file of files) await checkOne(file, await readTarget(run2, file));
+  assertNoOrphanJoins(prepared, hits);
+  const wantsDiff = opts.showDiff === true && pageOptions.checkSources !== false && !await git.available();
+  sayNotices(pages, opts.onNotice, wantsDiff ? [GIT_UNAVAILABLE_HISTORY] : []);
+  const results = pages.map(toValidationResult);
+  const frame = { cwd, base: run2.configDir ?? cwd, runBase: run2.base };
+  const request = resolveBaselineRequest(opts, run2.config?.baseline, run2.configDir, cwd, {
+    current: DEFAULT_CITE_BASELINE_PATH
+  });
+  if (request !== null && !request.write && !existsSync2(request.absPath)) {
+    throw new CiteError(
+      `Baseline "${request.label}" not found. Record one with \`manni cite check --write-baseline\`, or drop --baseline.`
+    );
+  }
+  const { results: reported, baseline } = await settleBaseline(results, request, frame);
+  const failed = reported.filter((r) => !r.ok).length;
+  const count = (keep) => reported.reduce((n, r) => n + r.errors.filter(keep).length, 0);
+  const warnings = count((e) => e.severity === "warning");
+  const notices = count((e) => e.severity === "notice");
+  const summary = {
+    files: reported.length,
+    passed: reported.length - failed,
+    failed,
+    errors: count(isErrorSeverity),
+    // Omitted at zero, as meta's summary has them, so the JSON shape of a
+    // clean run is the one every consumer of `meta validate` already reads.
+    ...warnings > 0 ? { warnings } : {},
+    ...notices > 0 ? { notices } : {},
+    ...gitignoreSkipped > 0 ? { gitignoreSkipped } : {},
+    ...baseline ? { baseline } : {}
+  };
+  return { results: reported, summary, frame, pages, warnings, notices };
+}
+
+export {
+  CITE_SECTION,
+  DEFAULT_CITE_BASELINE_PATH,
+  parseCiteConfig,
+  readCiteConfigFile,
+  loadCiteConfig,
+  resolveCiteRun,
+  gitClient,
+  GIT_UNAVAILABLE_HISTORY,
+  PAGE_HISTORY_UNAVAILABLE,
+  SHALLOW_RECOMMIT,
+  GIT_UNAVAILABLE_COMMIT,
+  noGit,
+  encryptSourcePath,
+  decryptSourcePath,
+  buildSourceIndex,
+  sourceIndexFor,
+  readSource,
+  historyOf,
+  classifyCitation,
+  CITATIONS_KEY,
+  urlManifestRefusal,
+  twoManifestsRefusal,
+  loadCitationSidecars,
+  orphanRefusal,
+  duplicateJoinRefusal,
+  sidecarsFor,
+  MAX_PAGE_COMMITS,
+  stripMarkers,
+  claimWords,
+  sentencesOf,
+  sharesSentence,
+  wordShare,
+  holdsWords,
+  runsHolding,
+  claimHistory,
+  claimDiff,
+  refineClaim,
+  checkCitations,
+  joinHits,
+  prepareRun,
+  assertNoOrphans,
+  assertNoOrphanJoins,
+  readTarget,
+  sayNotices,
+  runCheck
+};
+//# sourceMappingURL=chunk-LAKAWRV5.js.map