@hawkeyexl/manni 4.3.0 → 4.4.0

package/dist/chunk-5YXBLLAC.js

@@ -0,0 +1,2165 @@
+#!/usr/bin/env node
+import {
+  CITATIONS_KEY,
+  GIT_UNAVAILABLE_COMMIT,
+  SHALLOW_RECOMMIT,
+  assertNoOrphanJoins,
+  assertNoOrphans,
+  buildSourceIndex,
+  checkCitations,
+  claimWords,
+  encryptSourcePath,
+  gitClient,
+  historyOf,
+  joinHits,
+  prepareRun,
+  readSource,
+  readTarget,
+  resolveCiteRun,
+  sayNotices,
+  sharesSentence,
+  sidecarsFor,
+  sourceIndexFor,
+  wordShare
+} from "./chunk-LAKAWRV5.js";
+import {
+  applyMarkerMoves,
+  blockMatches,
+  listOf,
+  misplacedMarkers,
+  noUnitAt,
+  normalizeWhitespace,
+  otherClaimSpans,
+  shortSrc,
+  spellAt,
+  spellElsewhere,
+  unitAt
+} from "./chunk-252LNOEG.js";
+import {
+  ANY_FENCE,
+  CiteError,
+  MAX_IDS_PER_MARKER,
+  anchoredLines,
+  bodyLineOf,
+  citationInputs,
+  detectEol,
+  fenceSpanAt,
+  formatSrc,
+  formatStatement,
+  isMarkerLine,
+  lineAt,
+  markerIndent,
+  offsetOfLine,
+  parseSrc,
+  pickExtractor,
+  rangeLines,
+  readPage,
+  resolveSeverity,
+  respellEdit,
+  respellStatement,
+  sliceLines,
+  sourceRange,
+  spellSource,
+  tooWide,
+  unitHolding
+} from "./chunk-G7NJSREW.js";
+import {
+  ensureEncryptionKey
+} from "./chunk-CYWHFSRT.js";
+import {
+  STDIN_REQUIRES_AS
+} from "./chunk-V46OILVC.js";
+import {
+  ENCRYPTION_KEY_ENV,
+  hashLines,
+  heldManifest,
+  isMissing,
+  lineSpec,
+  parseLines,
+  pinOfLines,
+  readManifestValue,
+  rebaseable,
+  removeManifestKey,
+  settle,
+  spellLines,
+  spliceManifestValue,
+  splitLines,
+  toBodyLines,
+  toFileLines
+} from "./chunk-RLR4TKUZ.js";
+import {
+  DocmetaError,
+  STDIN_LABEL,
+  STDIN_TOKEN,
+  extractorByName,
+  locateFrontmatter,
+  writeFileAtomic
+} from "./chunk-JVTNMVYU.js";
+import {
+  isEncryptedValue
+} from "./chunk-Q35YIDBV.js";
+
+// src/cite/commands/add.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { relative, resolve } from "node:path";
+
+// src/cite/core/mint.ts
+var COMMIT_PATTERN = /^[0-9a-f]{7,64}$/;
+async function commitFor(opts) {
+  if (opts.commitSha === false) return void 0;
+  if (typeof opts.commitSha === "string") {
+    if (!COMMIT_PATTERN.test(opts.commitSha)) {
+      throw new CiteError(
+        `Invalid commit-sha "${opts.commitSha}": expected 7 to 64 lowercase hex digits.`
+      );
+    }
+    return opts.commitSha;
+  }
+  const client = opts.gitClient;
+  if (client === void 0 || !await client.available()) return void 0;
+  return await client.head() ?? void 0;
+}
+async function assertCommitHolds(opts, commit, path, range, pin, key) {
+  const client = opts.gitClient;
+  if (client === void 0 || !await client.available()) return;
+  const history = await historyOf(client, commit, path, range, pin, key, void 0);
+  if (history.kind !== "never-true") return;
+  throw new CiteError(
+    `${opts.src} is not committed: ${commit.slice(0, 7)} does not contain those lines. Commit the source, or use --no-commit-sha.`
+  );
+}
+function refusalFor(reason, path, encrypted) {
+  switch (reason) {
+    case "untracked":
+      return new CiteError(
+        encrypted ? `No tracked file matches ${path} (wrong --root?).` : `Source not found: ${path} is not a tracked file under the root.`
+      );
+    case "no-key":
+      return new CiteError(`${path} is encrypted, and no encryption key is available to decrypt it.`);
+    case "undecryptable":
+      return new CiteError(`${path} does not decrypt under the current key.`);
+    case "unreadable":
+      return new CiteError(`Source not readable: ${path} could not be read.`);
+  }
+}
+async function mintCitation(opts) {
+  const range = parseSrc(opts.src);
+  const wide = range.start === void 0 || range.end === void 0 ? void 0 : tooWide({ start: range.start, end: range.end });
+  if (wide !== void 0) throw new CiteError(`Invalid range "${opts.src}": it ${wide}.`);
+  const { key } = opts;
+  const encrypt = opts.encrypt === true || range.encrypted;
+  if (encrypt && !range.encrypted && key === void 0) {
+    throw new CiteError(
+      `${opts.src} must be encrypted, and no encryption key is available. Run \`manni key set\`, or set ${ENCRYPTION_KEY_ENV}.`
+    );
+  }
+  const index = opts.sourceIndex ?? await buildSourceIndex(opts.root, { gitClient: opts.gitClient });
+  const read = await readSource(opts.root, index, range, key);
+  if (read.kind === "missing") throw refusalFor(read.reason, range.path, range.encrypted);
+  const joined = sliceLines(splitLines(read.text), range, range.path);
+  const pinKey = encrypt ? key : void 0;
+  const file = pinKey !== void 0 && !range.encrypted ? encryptSourcePath(read.resolvedPath, pinKey) : range.path;
+  const lines = rangeLines(range);
+  const commitSha = await commitFor(opts);
+  const integrity = hashLines(joined, pinKey);
+  if (commitSha !== void 0) {
+    await assertCommitHolds(opts, commitSha, read.resolvedPath, range, integrity, pinKey);
+  }
+  const source = { file, integrity };
+  const ordered = {
+    file: source.file,
+    ...lines === void 0 ? {} : { lines },
+    integrity: source.integrity,
+    ...commitSha === void 0 ? {} : { "commit-sha": commitSha }
+  };
+  return {
+    ...opts.id === void 0 ? {} : { id: opts.id },
+    ...opts.claim === void 0 ? {} : { claim: opts.claim },
+    source: ordered,
+    ...opts.quote === void 0 ? {} : { quote: opts.quote }
+  };
+}
+
+// src/cite/core/shift.ts
+function shiftedEntries(opts) {
+  const { citations, at, delta, bodyLine, label } = opts;
+  const out = { frontmatter: [], manifest: /* @__PURE__ */ new Map() };
+  if (at.length === 0) return out;
+  for (const { citation, origin } of citations) {
+    const spec = citation.claim?.lines;
+    const recorded = spec === void 0 ? void 0 : parseLines(spec);
+    if (recorded === void 0) continue;
+    const file = toFileLines(recorded, bodyLine);
+    const inside = at.find(
+      (line) => delta === 1 ? line > file.start && line <= file.end : line >= file.start && line <= file.end
+    );
+    if (inside !== void 0) {
+      const whose = citation.id === void 0 ? `the claim at ${spellAt(file)}` : `the claim of ${citation.id} (${spellAt(file)})`;
+      const why = delta === 1 ? "A marker there would change its pin." : "Removing the marker there would change its pin.";
+      throw new CiteError(`${label}:${String(inside)} is inside ${whose}. ${why}`);
+    }
+    const lines = at.filter((line) => delta === 1 ? line <= file.start : line < file.start).length;
+    if (lines === 0) continue;
+    const moved = lineSpec({
+      start: recorded.start + lines * delta,
+      end: recorded.end + lines * delta
+    });
+    if (origin.kind === "manifest") out.manifest.set(origin.index, moved);
+    else out.frontmatter.push({ index: origin.index, lines: moved });
+  }
+  return out;
+}
+function withClaimLines(entry, lines) {
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return entry;
+  const claim = entry.claim;
+  if (typeof claim !== "object" || claim === null || Array.isArray(claim)) return entry;
+  return { ...entry, claim: { ...claim, lines } };
+}
+
+// src/cite/core/manifest.ts
+import { readFile } from "node:fs/promises";
+import { posix } from "node:path";
+import { LineCounter, isMap, isNode, isScalar, isSeq, parseDocument } from "yaml";
+
+// src/cite/core/write.ts
+function extractorFor(format) {
+  const extractor = extractorByName(format);
+  if (!extractor) throw new CiteError(`Unknown format "${format}".`);
+  return extractor;
+}
+function readsFencedFrontmatter(extractor, label) {
+  return extractor.extract("---\nprobe: 1\n---\n", label).fenced === true;
+}
+function appendFrontmatterCitation(content, format, citation, filePath) {
+  const label = filePath ?? "the page";
+  const extractor = extractorFor(format);
+  if (!extractor.apply || !readsFencedFrontmatter(extractor, label)) {
+    throw new CiteError(
+      `${label} has no frontmatter to write to; keep its citations in a manifest instead.`
+    );
+  }
+  const extracted = extractor.extract(content, label);
+  if (locateFrontmatter(content)?.flavor === "toml") {
+    throw new CiteError(
+      `${label} has TOML frontmatter; manni cannot add a citations table without re-emitting the whole block, which would drop its comments. Add the entry by hand.`
+    );
+  }
+  const raw = extracted.data.citations ?? [];
+  if (!Array.isArray(raw)) {
+    throw new CiteError(`${label}: \`citations\` is not a list; edit it by hand.`);
+  }
+  const existing = raw;
+  const entry = entryObject(citation);
+  try {
+    return extractor.apply(content, { citations: [...existing, entry] });
+  } catch (e) {
+    if (e instanceof DocmetaError) throw new CiteError(`${label}: ${e.message}`);
+    throw e;
+  }
+}
+function removeFrontmatterCitations(content, format, drop, filePath) {
+  const label = filePath ?? "the page";
+  const extractor = extractorFor(format);
+  if (!extractor.apply || !readsFencedFrontmatter(extractor, label)) {
+    throw new CiteError(
+      `${label} has no frontmatter to write to; keep its citations in a manifest instead.`
+    );
+  }
+  if (locateFrontmatter(content)?.flavor === "toml") {
+    throw new CiteError(
+      `${label} has TOML frontmatter; manni cannot rewrite a citations table without re-emitting the whole block, which would drop its comments. Remove the entry by hand.`
+    );
+  }
+  const raw = extractor.extract(content, label).data.citations ?? [];
+  if (!Array.isArray(raw)) {
+    throw new CiteError(`${label}: \`citations\` is not a list; edit it by hand.`);
+  }
+  const existing = raw;
+  const kept = existing.filter((_entry, index) => !drop.has(index));
+  try {
+    return kept.length === 0 ? extractor.apply(content, {}, { deletions: ["citations"] }) : extractor.apply(content, { citations: kept });
+  } catch (e) {
+    if (e instanceof DocmetaError) throw new CiteError(`${label}: ${e.message}`);
+    throw e;
+  }
+}
+function applyEdits(content, edits) {
+  const sorted = [...edits].sort((a, b) => a.start - b.start);
+  let out = "";
+  let at = 0;
+  for (const edit of sorted) {
+    if (edit.end < edit.start) {
+      throw new Error(`cite: backwards edit [${String(edit.start)}, ${String(edit.end)})`);
+    }
+    if (edit.start < at) {
+      throw new Error(`cite: overlapping edits at ${String(edit.start)}`);
+    }
+    out += content.slice(at, edit.start) + edit.text;
+    at = edit.end;
+  }
+  return out + content.slice(at);
+}
+function lineRemovals(content, lines) {
+  const sorted = [...new Set(lines)].sort((a, b) => a - b);
+  const out = [];
+  let run;
+  for (const line of sorted) {
+    if (run !== void 0 && line === run.last + 1) run.last = line;
+    else {
+      if (run !== void 0) out.push(runRemoval(content, run.first, run.last));
+      run = { first: line, last: line };
+    }
+  }
+  if (run !== void 0) out.push(runRemoval(content, run.first, run.last));
+  return out;
+}
+function runRemoval(content, first, last) {
+  let start = offsetOfLine(content, first);
+  const end = offsetOfLine(content, last + 1);
+  if (end === content.length && !content.endsWith("\n") && start > 0) {
+    let above = content.lastIndexOf("\n", start - 1);
+    if (above > 0 && content.charAt(above - 1) === "\r") above--;
+    start = above === -1 ? 0 : above;
+  }
+  return { start, end, text: "" };
+}
+function removeLine(content, line) {
+  return applyEdits(content, lineRemovals(content, [line]));
+}
+function entryObject(citation) {
+  const source = { file: citation.source.file };
+  if (citation.source.lines !== void 0) source.lines = citation.source.lines;
+  source.integrity = citation.source.integrity;
+  if (citation.source["commit-sha"] !== void 0) {
+    source["commit-sha"] = citation.source["commit-sha"];
+  }
+  const entry = {};
+  if (citation.id !== void 0) entry.id = citation.id;
+  if (citation.claim !== void 0) {
+    const claim = {};
+    if (citation.claim.lines !== void 0) claim.lines = citation.claim.lines;
+    claim.integrity = citation.claim.integrity;
+    entry.claim = claim;
+  }
+  entry.source = source;
+  if (citation.quote !== void 0) entry.quote = citation.quote;
+  return entry;
+}
+function needsYamlQuotes(value) {
+  return value === "" || /^[\s!&*?|>'"%@`{}[\],#]/.test(value) || /^-(\s|$)/.test(value) || /:\s|\s#|:$|\s$/.test(value) || /^(?:true|false|null|~|yes|no|on|off|[-+]?(?:\d[\d_]*\.?\d*|\.\d+)(?:e[-+]?\d+)?)$/i.test(value);
+}
+var doubleQuote = (value) => JSON.stringify(value);
+var singleQuote = (value) => `'${value.replace(/'/g, "''")}'`;
+function splitScalarLine(line, field) {
+  const keyed = new RegExp(`^(\\s*(?:-\\s+)?"?${field}"?\\s*:\\s*)(.*)$`).exec(line);
+  const lead = keyed?.[1];
+  const rest = keyed?.[2];
+  if (lead === void 0 || rest === void 0) return void 0;
+  const quote = rest.charAt(0);
+  let end;
+  if (quote === '"' || quote === "'") {
+    end = -1;
+    for (let i = 1; i < rest.length; i++) {
+      const ch = rest.charAt(i);
+      if (quote === '"' && ch === "\\") {
+        i++;
+      } else if (ch === quote) {
+        if (quote === "'" && rest.charAt(i + 1) === "'") {
+          i++;
+          continue;
+        }
+        end = i + 1;
+        break;
+      }
+    }
+    if (end < 0) return void 0;
+  } else {
+    const comment = /\s#/.exec(rest);
+    end = comment ? comment.index : rest.length;
+    while (end > 0 && /\s/.test(rest.charAt(end - 1))) end--;
+  }
+  return { lead, scalar: rest.slice(0, end), trail: rest.slice(end) };
+}
+function spliceEntryField(content, format, index, path, value) {
+  const [which, field] = path;
+  const refuse = () => new CiteError(
+    `Cannot rewrite citations[${String(index)}].${which}.${field} in ${format} frontmatter; edit it by hand.`
+  );
+  const extractor = extractorFor(format);
+  const pointer = `/citations/${String(index)}/${which}/${field}`;
+  const line = extractor.extract(content, "page").lineFor(pointer);
+  if (line === void 0) throw refuse();
+  const start = offsetOfLine(content, line);
+  const nl = content.indexOf("\n", start);
+  let end = nl === -1 ? content.length : nl;
+  if (end > start && content.charAt(end - 1) === "\r") end--;
+  const parts = splitScalarLine(content.slice(start, end), field);
+  if (!parts) throw refuse();
+  const quote = parts.scalar.charAt(0);
+  const spelled = typeof value === "number" ? String(value) : quote === '"' ? doubleQuote(value) : quote === "'" ? singleQuote(value) : needsYamlQuotes(value) ? doubleQuote(value) : value;
+  const out = content.slice(0, start) + parts.lead + spelled + parts.trail + content.slice(end);
+  const check = extractor.extract(out, "page").data.citations;
+  const entry = Array.isArray(check) ? check[index] : void 0;
+  const block = isRecord(entry) ? entry[which] : void 0;
+  const readBack = isRecord(block) ? block[field] : void 0;
+  if (readBack !== value) throw refuse();
+  return out;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function insertStatementBefore(content, offset, statement) {
+  const start = offsetOfLine(content, lineAt(content, offset));
+  return content.slice(0, start) + statement + detectEol(content) + content.slice(start);
+}
+function unifiedDiff(label, before, after) {
+  const a = splitLines(before);
+  const b = splitLines(after);
+  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 x = a.slice(head, a.length - tail);
+  const y = b.slice(head, b.length - tail);
+  if (x.length === 0 && y.length === 0) return "";
+  const width = y.length + 1;
+  const lcs = new Uint32Array((x.length + 1) * width);
+  for (let i2 = x.length - 1; i2 >= 0; i2--) {
+    for (let j2 = y.length - 1; j2 >= 0; j2--) {
+      lcs[i2 * width + j2] = x[i2] === y[j2] ? (lcs[(i2 + 1) * width + j2 + 1] ?? 0) + 1 : Math.max(lcs[(i2 + 1) * width + j2] ?? 0, lcs[i2 * width + j2 + 1] ?? 0);
+    }
+  }
+  const edits = a.slice(0, head).map((text) => ({ op: " ", text }));
+  let i = 0;
+  let j = 0;
+  while (i < x.length || j < y.length) {
+    const xi = x[i];
+    const yj = y[j];
+    if (xi !== void 0 && yj !== void 0 && xi === yj) {
+      edits.push({ op: " ", text: xi });
+      i++;
+      j++;
+    } else if (xi !== void 0 && (yj === void 0 || (lcs[(i + 1) * width + j] ?? 0) >= (lcs[i * width + j + 1] ?? 0))) {
+      edits.push({ op: "-", text: xi });
+      i++;
+    } else if (yj !== void 0) {
+      edits.push({ op: "+", text: yj });
+      j++;
+    }
+  }
+  edits.push(...a.slice(a.length - tail).map((text) => ({ op: " ", text })));
+  const CONTEXT = 1;
+  const out = [`--- ${label}`, `+++ ${label}`];
+  let pos = 0;
+  while (pos < edits.length) {
+    if (edits[pos]?.op === " ") {
+      pos++;
+      continue;
+    }
+    const from = Math.max(0, pos - CONTEXT);
+    let to = pos;
+    for (let k = pos; k < edits.length; k++) {
+      if (edits[k]?.op !== " ") to = k;
+      else if (k - to > CONTEXT * 2) break;
+    }
+    to = Math.min(edits.length - 1, to + CONTEXT);
+    let oldStart = 1;
+    let newStart = 1;
+    for (let k = 0; k < from; k++) {
+      const op = edits[k]?.op;
+      if (op !== "+") oldStart++;
+      if (op !== "-") newStart++;
+    }
+    const slice = edits.slice(from, to + 1);
+    const oldCount = slice.filter((e) => e.op !== "+").length;
+    const newCount = slice.filter((e) => e.op !== "-").length;
+    out.push(
+      `@@ -${oldCount === 0 ? oldStart - 1 : oldStart},${oldCount} +${newCount === 0 ? newStart - 1 : newStart},${newCount} @@`,
+      ...slice.map((e) => e.op + e.text)
+    );
+    pos = to + 1;
+  }
+  return out.join("\n") + "\n";
+}
+
+// src/cite/core/manifest.ts
+var codec = { apply, read: readManifestValue };
+var ManifestSet = class {
+  held = /* @__PURE__ */ new Map();
+  /** Read a manifest, or hand back the copy this run has already rewritten. */
+  async hold(manifest) {
+    const already = this.held.get(manifest.path);
+    if (already !== void 0) return already;
+    let before;
+    let absent = false;
+    try {
+      before = await readFile(manifest.path, "utf8");
+    } catch (error) {
+      if (manifest.pattern === void 0 || !isMissing(error)) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new CiteError(`Manifest ${manifest.file} could not be read: ${reason}`);
+      }
+      before = "";
+      absent = true;
+    }
+    const fresh = heldManifest(manifest.path, manifest.file, before, absent);
+    this.held.set(manifest.path, fresh);
+    return fresh;
+  }
+  /**
+   * Write one page's whole `citations` list into its entry, and answer where
+   * the entry at `index` now sits. The manifest is not saved: `changed()`
+   * lists what the run would write.
+   */
+  async write(manifest, entry, citations, index) {
+    const held = await this.hold(manifest);
+    const op = {
+      kind: "splice",
+      entry,
+      key: CITATIONS_KEY,
+      join: manifest.join,
+      file: manifest.file,
+      value: [...citations]
+    };
+    rebaseable(held, op, codec);
+    const spliced = splice(held.text, {
+      entry,
+      key: CITATIONS_KEY,
+      value: op.value,
+      join: manifest.join,
+      file: manifest.file
+    });
+    held.text = spliced.text;
+    held.ops.push(op);
+    return { file: manifest.file, line: itemLine(spliced.text, entry, index, manifest.join) ?? spliced.line };
+  }
+  /**
+   * Where one item of an entry's `citations` sits in the manifest as this run
+   * will write it. `add` names a line in its report, and `commit` may have
+   * replayed the entry onto bytes that moved it, so the line is read back from
+   * the settled text rather than kept from the splice.
+   */
+  lineOf(manifest, entry, index) {
+    const held = this.held.get(manifest.path);
+    if (held === void 0) return void 0;
+    return itemLine(held.text, entry, index, manifest.join);
+  }
+  /**
+   * Take a page's `citations` key out of the manifest, for the removal that
+   * leaves it with no entries. The entry itself goes when that key was all it
+   * had, so a manifest never keeps a document nothing is recorded about.
+   */
+  async remove(manifest, entry) {
+    const held = await this.hold(manifest);
+    const op = {
+      kind: "remove",
+      entry,
+      key: CITATIONS_KEY,
+      join: manifest.join,
+      file: manifest.file
+    };
+    rebaseable(held, op, codec);
+    held.text = apply(held.text, op);
+    held.ops.push(op);
+  }
+  /** The manifests this run rewrote, with the diff of each. */
+  changed() {
+    return [...this.held.values()].filter((m) => m.text !== m.before).map((m) => ({ ...m, diff: unifiedDiff(m.file, m.before, m.text) }));
+  }
+  /**
+   * Write every manifest this run rewrote, and report what landed.
+   *
+   * The write is the last thing a run does, so this is the one place that
+   * knows a manifest is about to be replaced by bytes derived from a read
+   * that may be seconds old.
+   */
+  async commit(io = {}) {
+    const write = io.write ?? ((at, text) => writeFileAtomic(at, text, { createParents: true }));
+    const read = io.read ?? ((at) => readFile(at, "utf8"));
+    const landed = [];
+    for (const held of this.held.values()) {
+      if (held.text === held.before) continue;
+      try {
+        await settle(held, { codec, write, read, toError: (message) => new CiteError(message) });
+      } catch (error) {
+        if (io.onError !== void 0) await io.onError(changeOf(held), error);
+        throw error;
+      }
+      const change = changeOf(held);
+      landed.push(change);
+      io.after?.(change);
+    }
+    return landed;
+  }
+};
+function changeOf(held) {
+  return {
+    path: held.path,
+    file: held.file,
+    before: held.before,
+    text: held.text,
+    diff: unifiedDiff(held.file, held.before, held.text)
+  };
+}
+function apply(text, op) {
+  const where = { entry: op.entry, key: op.key, join: op.join, file: op.file };
+  if (op.kind === "splice") return splice(text, { ...where, value: op.value }).text;
+  try {
+    return removeManifestKey(text, where).text;
+  } catch (error) {
+    if (error instanceof DocmetaError) throw new CiteError(error.message);
+    throw error;
+  }
+}
+function splice(text, options) {
+  try {
+    return spliceManifestValue(text, options);
+  } catch (error) {
+    if (error instanceof DocmetaError) throw new CiteError(error.message);
+    throw error;
+  }
+}
+function itemLine(text, entry, index, join) {
+  const lc = new LineCounter();
+  const doc = parseDocument(text, { lineCounter: lc, uniqueKeys: false });
+  if (doc.errors.length > 0) return void 0;
+  const root = doc.contents;
+  if (!isMap(root)) return void 0;
+  const same = (key) => {
+    const spelled = isScalar(key) ? String(key.value) : String(key);
+    return join === "path" ? posix.normalize(spelled) === posix.normalize(entry) : spelled === entry;
+  };
+  const pair = root.items.find((p) => same(p.key));
+  const value = pair?.value;
+  if (!isMap(value)) return void 0;
+  const kv = value.items.find(
+    (p) => (isScalar(p.key) ? String(p.key.value) : String(p.key)) === CITATIONS_KEY
+  );
+  const list = kv?.value;
+  if (!isSeq(list)) return void 0;
+  const item = list.items[index];
+  const range = isNode(item) ? item.range : void 0;
+  return range ? lc.linePos(range[0]).line : void 0;
+}
+
+// src/cite/commands/add.ts
+var ID = /^[a-z0-9][a-z0-9-]*$/;
+var toPosix = (path) => path.replace(/\\/g, "/");
+function isEnoent(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function readPageFile(path, label) {
+  try {
+    return await readFile2(path, "utf8");
+  } catch (error) {
+    if (isEnoent(error)) throw new CiteError(`File not found: "${label}".`);
+    throw error;
+  }
+}
+async function citedText(root, index, src, key) {
+  const range = parseSrc(src);
+  const source = await readSource(root, index, range, key);
+  if (source.kind === "missing") {
+    throw new CiteError(`Source not readable: ${range.path} could not be read.`);
+  }
+  return sliceLines(splitLines(source.text), range, range.path);
+}
+function entryName(entry) {
+  return entry.citation.id ?? `/citations/${String(entry.origin.index)}`;
+}
+function duplicateOf(page, src, pageLines) {
+  const wanted = formatSrc(parseSrc(src));
+  return page.citations.find((entry) => {
+    const { citation } = entry;
+    if (spellSource(citation.source) !== wanted) return false;
+    if (pageLines === void 0) return citation.claim === void 0;
+    const spec = citation.claim?.lines;
+    if (spec === void 0) return false;
+    const recorded = parseLines(spec);
+    if (recorded === void 0) return false;
+    const file = toFileLines(recorded, page.bodyLine);
+    return file.start === pageLines.start && file.end === pageLines.end;
+  });
+}
+function holdsNoText(text) {
+  return text.trim() === "" || ANY_FENCE.test(text);
+}
+function emptyClaimRefusal(lines, pageLines, at) {
+  const span = lines.slice(pageLines.start - 1, pageLines.end);
+  if (span.some((text) => !holdsNoText(text))) return void 0;
+  if (pageLines.start !== pageLines.end) return `${at} holds no claim text.`;
+  const only = span[0] ?? "";
+  return only.trim() === "" ? `${at} is blank.` : `${at} is a fence line, not claim text.`;
+}
+async function runAdd(opts) {
+  const cwd = resolve(opts.cwd ?? process.cwd());
+  const run = await resolveCiteRun({
+    cwd,
+    configPath: opts.configPath,
+    noConfig: opts.noConfig,
+    inputs: [],
+    root: opts.root,
+    onConfigLoaded: opts.onConfigLoaded,
+    onNotice: opts.onNotice,
+    env: opts.env
+  });
+  const { root } = run;
+  const usingStdin = opts.page === STDIN_TOKEN;
+  if (usingStdin && opts.as === void 0) {
+    throw new CiteError(STDIN_REQUIRES_AS);
+  }
+  const path = usingStdin ? void 0 : resolve(cwd, opts.page);
+  const label = path === void 0 ? STDIN_LABEL : toPosix(relative(cwd, path));
+  const content = path === void 0 ? opts.stdinContent ?? "" : await readPageFile(path, label);
+  const sidecars = await sidecarsFor(run, {
+    base: cwd,
+    // A `{page}` manifest (0058) is read for the one page being cited.
+    ...path === void 0 ? {} : { pages: [path] }
+  });
+  const firstManifest = sidecars?.manifests[0];
+  if (usingStdin && firstManifest !== void 0) {
+    const keyedBy = firstManifest.join === "path" ? "path" : firstManifest.join;
+    throw new CiteError(
+      `A page read from stdin has no path, and its citations live in ${firstManifest.file}, which is keyed by ${keyedBy}.`
+    );
+  }
+  const sidecar = usingStdin ? void 0 : await sidecars?.forPage(label, content, opts.as);
+  const owner = sidecar?.owner;
+  const page = readPage(label, content, {
+    ...opts.as === void 0 ? {} : { format: opts.as },
+    // The entries already there are the manifest's, so `--id` uniqueness and
+    // the marker checks are measured against them and not against a page
+    // that carries none.
+    ...sidecar?.citations === void 0 ? {} : { citations: sidecar.citations },
+    ...owner === void 0 ? {} : { owned: { file: owner.file, collection: owner.collection } }
+  });
+  const { format } = page;
+  const pageLines = opts.pageLines;
+  const marker = opts.marker === true;
+  const quote = opts.quote === true;
+  const at = pageLines === void 0 ? "" : `${label}:${spellLines(pageLines)}`;
+  if (marker && pageLines === void 0) {
+    throw new CiteError(`--marker needs the page lines to anchor: ${label}:L.`);
+  }
+  if (marker && opts.id === void 0) {
+    throw new CiteError("--marker needs --id: the marker names the entry.");
+  }
+  const wide = pageLines === void 0 ? void 0 : tooWide(pageLines);
+  if (wide !== void 0) throw new CiteError(`Invalid range "${at}": it ${wide}.`);
+  if (quote && pageLines === void 0) {
+    throw new CiteError(`--quote needs the block's lines: ${label}:L1-L2.`);
+  }
+  if (opts.id !== void 0 && !ID.test(opts.id)) {
+    throw new CiteError(
+      `Invalid id "${opts.id}": use lowercase letters, digits and hyphens, starting with a letter or digit.`
+    );
+  }
+  if (opts.id !== void 0 && page.citations.some((c) => c.citation.id === opts.id)) {
+    throw new CiteError(`${label} already has an entry ${opts.id}.`);
+  }
+  if (marker && opts.id !== void 0) {
+    const already = page.statements.find(
+      (s) => s.payload.kind === "ref" && s.payload.ids.includes(opts.id ?? "")
+    );
+    if (already !== void 0) {
+      throw new CiteError(
+        `${label} already has a marker ${opts.id} at line ${String(already.line)}.`
+      );
+    }
+  }
+  const duplicate = marker ? void 0 : duplicateOf(page, opts.src, pageLines);
+  if (duplicate !== void 0) {
+    const src = shortSrc(spellSource(duplicate.citation.source));
+    const what = pageLines === void 0 ? `a bare pin for ${src}` : `an entry for ${spellAt(pageLines)} and ${src}`;
+    throw new CiteError(`${label} already has ${what} (${entryName(duplicate)}).`);
+  }
+  const lines = splitLines(content);
+  if (pageLines !== void 0) {
+    if (pageLines.end > lines.length) {
+      throw new CiteError(`${at} is past the end of the page (${String(lines.length)} lines).`);
+    }
+    if (pageLines.start < page.bodyLine) {
+      throw new CiteError(`${at} is in the frontmatter. A claim is body text.`);
+    }
+    if (quote) {
+      const span = fenceSpanAt(content, pageLines.start, format);
+      if (span === void 0 || span.end !== pageLines.end) {
+        throw new CiteError(`${at} is not a fenced block, so it cannot be a quote.`);
+      }
+    } else if (!marker) {
+      const empty = emptyClaimRefusal(lines, pageLines, at);
+      if (empty !== void 0) throw new CiteError(empty);
+    }
+    const split = misplacedMarkers(page, lines);
+    const held = split.find(
+      (found) => found.line >= pageLines.start && found.line <= pageLines.end
+    );
+    if (held !== void 0) {
+      throw new CiteError(
+        `${at} holds the marker at line ${String(held.line)}, which splits its paragraph. Run manni cite update first.`
+      );
+    }
+    const inside = marker ? split.find(
+      (found) => pageLines.start >= found.unit.start && pageLines.start <= found.unit.end
+    ) : void 0;
+    if (inside !== void 0) {
+      throw new CiteError(
+        `${at} is in the paragraph at ${spellAt(inside.unit)}, which the marker at line ${String(inside.line)} splits. Run manni cite update first.`
+      );
+    }
+  }
+  const client = opts.gitClient ?? gitClient(root);
+  const sourceIndex = await sourceIndexFor(root, client);
+  let body = content;
+  let markerAt;
+  let markerJoined = false;
+  let claimSpan;
+  let claim;
+  let elsewhere = [];
+  let shifted = { frontmatter: [], manifest: /* @__PURE__ */ new Map() };
+  if (marker && pageLines !== void 0) {
+    if (isMarkerLine(lines[pageLines.start - 1] ?? "", format)) {
+      throw new CiteError(
+        `${label}:${String(pageLines.start)} is a marker line. A marker there would change its pin.`
+      );
+    }
+    const holding = unitHolding(content, pageLines.start, format, {
+      offset: page.bodyOffset,
+      line: page.bodyLine
+    });
+    if (holding === void 0) {
+      throw new CiteError(`${at} has no paragraph or block for a marker to anchor.`);
+    }
+    if (pageLines.end > holding.end) {
+      throw new CiteError(
+        `${at} runs past the ${holding.kind} at ${spellAt(holding)}. A marker anchors one paragraph.`
+      );
+    }
+    const unitWide = tooWide({ start: holding.start, end: holding.end });
+    if (unitWide !== void 0) {
+      throw new CiteError(
+        `${at} is in a ${holding.kind} at ${spellAt(holding)} that ${unitWide}. A marker anchors the whole ${holding.kind}.`
+      );
+    }
+    const above = page.statements.filter((s) => s.anchorLine === holding.start);
+    const nearest = above[above.length - 1];
+    const held = nearest !== void 0 && nearest.payload.kind === "ref" && nearest.payload.ids.length < MAX_IDS_PER_MARKER && !/[\r\n]/.test(nearest.raw) ? nearest.payload.ids : void 0;
+    let after2;
+    if (nearest !== void 0 && held !== void 0) {
+      body = respellStatement(content, nearest, [...held, opts.id ?? ""]);
+      after2 = nearest.end + (body.length - content.length);
+      markerAt = nearest.line;
+      markerJoined = true;
+    } else {
+      shifted = shiftedEntries({
+        citations: page.citations,
+        at: [holding.start],
+        delta: 1,
+        bodyLine: page.bodyLine,
+        label
+      });
+      const statement = markerIndent(content, holding.start, format, page.bodyLine) + formatStatement(format, { kind: "ref", ids: [opts.id ?? ""] });
+      const insertAt = offsetOfLine(content, holding.start);
+      body = insertStatementBefore(content, insertAt, statement);
+      after2 = insertAt + statement.length;
+      markerAt = holding.start;
+    }
+    const unit = anchoredLines(body, after2, format, quote);
+    const pin = unit === void 0 ? void 0 : pinOfLines(splitLines(body), unit);
+    if (unit === void 0 || pin === void 0) {
+      throw new CiteError(`${at} has no paragraph or block for a marker to anchor.`);
+    }
+    for (const { index: index2, lines: moved } of shifted.frontmatter) {
+      body = spliceEntryField(body, format, index2, ["claim", "lines"], moved);
+    }
+    claimSpan = unit;
+    claim = { integrity: pin };
+  } else if (pageLines !== void 0) {
+    const pin = pinOfLines(lines, pageLines);
+    if (pin === void 0) {
+      throw new CiteError(`${at} is past the end of the page (${String(lines.length)} lines).`);
+    }
+    claimSpan = pageLines;
+    claim = { lines: lineSpec(toBodyLines(pageLines, page.bodyLine)), integrity: pin };
+    elsewhere = otherClaimSpans(lines, pageLines, pin, page.bodyLine);
+  }
+  const mint = (key, encrypt) => mintCitation({
+    root,
+    src: opts.src,
+    ...opts.id === void 0 ? {} : { id: opts.id },
+    ...claim === void 0 ? {} : { claim },
+    ...quote ? { quote: true } : {},
+    ...opts.commitSha === false ? { commitSha: false } : {},
+    encrypt,
+    ...key === void 0 ? {} : { key },
+    gitClient: client,
+    sourceIndex
+  });
+  const needsKey = opts.encrypt === true && run.key === void 0;
+  let citation = await mint(run.key, run.key !== void 0);
+  if (quote && claimSpan !== void 0) {
+    const cited = await citedText(root, sourceIndex, opts.src, run.key);
+    const inside = splitLines(body).slice(claimSpan.start, claimSpan.end - 1).join("\n");
+    if (!blockMatches(inside, cited)) {
+      throw new CiteError(`The block at ${at} does not reproduce ${opts.src}.`);
+    }
+  }
+  if (needsKey) {
+    const { key } = await ensureEncryptionKey({
+      subject: opts.src,
+      cwd,
+      file: run.configFile ?? null,
+      env: opts.env,
+      confirm: opts.confirm,
+      notice: (message) => {
+        opts.onNotice?.(message);
+      },
+      toError: (message) => new CiteError(message)
+    });
+    citation = await mint(key, true);
+  }
+  const srcRange = parseSrc(opts.src);
+  let sourceLine;
+  if (srcRange.start !== void 0 && !isEncryptedValue(citation.source.file)) {
+    const read = await readSource(root, sourceIndex, srcRange, void 0);
+    if (read.kind === "ok") sourceLine = splitLines(read.text)[srcRange.start - 1];
+  }
+  const manifests = new ManifestSet();
+  let placed;
+  let index = 0;
+  if (owner !== void 0) {
+    if (sidecar?.entry === void 0) {
+      throw new CiteError(
+        `${label} carries no ${owner.join}: value, so its citations cannot be keyed in ${owner.file}.`
+      );
+    }
+    const existing = (sidecar.citations ?? []).map((input, index2) => {
+      const moved = shifted.manifest.get(index2);
+      return moved === void 0 ? input.entry : withClaimLines(input.entry, moved);
+    });
+    const list = [...existing, entryObject(citation)];
+    index = list.length - 1;
+    const at2 = await manifests.write(owner, sidecar.entry, list, index);
+    const [changed] = manifests.changed();
+    placed = {
+      file: at2.file,
+      line: at2.line,
+      content: changed?.text ?? "",
+      diff: changed?.diff ?? "",
+      written: false
+    };
+  }
+  const after = owner === void 0 ? appendFrontmatterCitation(body, format, citation, label) : body;
+  const shift = bodyLineOf(after, locateFrontmatter(after)?.closeEnd ?? 0) - page.bodyLine;
+  const result = {
+    file: label,
+    citation,
+    placed: owner === void 0 ? "frontmatter" : "manifest",
+    content: after,
+    diff: unifiedDiff(label, content, after),
+    written: false,
+    ...sourceLine === void 0 ? {} : { sourceLine },
+    ...placed === void 0 ? {} : { manifest: placed }
+  };
+  if (markerAt !== void 0) result.markerLine = markerAt + shift;
+  if (markerJoined) result.markerJoined = true;
+  if (claimSpan !== void 0) {
+    result.claimLines = { start: claimSpan.start + shift, end: claimSpan.end + shift };
+  }
+  result.written = path !== void 0 && opts.dryRun !== true && after !== content;
+  if (result.written && path !== void 0) await writeFileAtomic(path, after);
+  if (result.manifest !== void 0 && opts.dryRun !== true) {
+    const [settled] = await manifests.commit();
+    if (owner !== void 0 && sidecar?.entry !== void 0) {
+      result.manifest.line = manifests.lineOf(owner, sidecar.entry, index) ?? result.manifest.line;
+    }
+    if (settled !== void 0) {
+      result.manifest.content = settled.text;
+      result.manifest.diff = settled.diff;
+    }
+    result.manifest.written = true;
+  }
+  if (elsewhere.length > 0) {
+    const named2 = elsewhere.map((span) => ({ start: span.start + shift, end: span.end + shift }));
+    const who = citation.id === void 0 ? "" : `${citation.id}: `;
+    opts.onNotice?.(
+      `${who}the claim's text also appears at ${spellElsewhere(named2)}, so a move would be ambiguous. Use --marker, or pin more lines.`
+    );
+  }
+  if (opts.commitSha !== false && !await client.available()) {
+    opts.onNotice?.(GIT_UNAVAILABLE_COMMIT);
+  }
+  return result;
+}
+
+// src/cite/commands/remove.ts
+import { resolve as resolve2 } from "node:path";
+var POINTER = /^\/citations\/(0|[1-9][0-9]*)$/;
+function entryCount(n) {
+  return `${String(n)} ${n === 1 ? "entry" : "entries"}`;
+}
+function idOf(entry) {
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return void 0;
+  const id = entry.id;
+  return typeof id === "string" ? id : void 0;
+}
+async function runRemove(opts) {
+  const only = [...new Set(opts.only)];
+  if (only.length === 0) {
+    throw new CiteError("remove needs --only <id>; it never removes every citation on a page.");
+  }
+  const prepared = await prepareRun({ ...opts, checkSources: false }, "removed", "remove", {
+    resolve: false
+  });
+  const { run, files, usingStdin, forced } = prepared;
+  await assertNoOrphans(prepared);
+  const hits = joinHits();
+  const manifests = new ManifestSet();
+  const matched = /* @__PURE__ */ new Set();
+  const pageCount = files.length + (usingStdin ? 1 : 0);
+  const planned = [];
+  const removeOne = async (label, content, path) => {
+    const setup = await prepared.setupFor(label, content);
+    if (setup.sidecar !== void 0) hits.record(setup.sidecar, label);
+    const owner = setup.sidecar?.owner;
+    const page = readPage(label, content, {
+      ...forced === void 0 ? {} : { format: forced.name },
+      ...setup.options.citations === void 0 ? {} : { citations: setup.options.citations },
+      ...owner === void 0 ? {} : { owned: { file: owner.file, collection: owner.collection } }
+    });
+    const { format } = page;
+    const extractor = pickExtractor(label, forced?.name);
+    const inputs = citationInputs(
+      label,
+      extractor.extract(content, label),
+      setup.sidecar?.citations
+    );
+    const lines = splitLines(content);
+    const entriesFor = (value) => {
+      const [, digits] = POINTER.exec(value) ?? [];
+      if (digits === void 0) {
+        return inputs.flatMap((input, index2) => idOf(input.entry) === value ? [index2] : []);
+      }
+      const index = Number(digits);
+      if (index < inputs.length) return [index];
+      if (pageCount === 1) {
+        throw new CiteError(
+          `"${value}" is past the last entry of ${label} (${entryCount(inputs.length)}).`
+        );
+      }
+      return [];
+    };
+    const markersFor = (id) => id === void 0 ? [] : page.statements.filter(
+      (s) => s.payload.kind === "ref" && s.payload.ids.includes(id)
+    );
+    const dropped = /* @__PURE__ */ new Map();
+    const drop = (statement, id) => {
+      const held = dropped.get(statement.line) ?? { statement, ids: /* @__PURE__ */ new Set() };
+      held.ids.add(id);
+      dropped.set(statement.line, held);
+    };
+    const removed = [];
+    const indices = /* @__PURE__ */ new Set();
+    const markerLines = [];
+    for (const value of only) {
+      const found = entriesFor(value);
+      for (const index of found) {
+        const input = inputs[index];
+        const id = idOf(input?.entry);
+        const markers2 = markersFor(id);
+        indices.add(index);
+        markerLines.push(...markers2.map((s) => s.line));
+        if (id !== void 0) for (const statement of markers2) drop(statement, id);
+        removed.push({
+          ...id === void 0 ? {} : { id },
+          index,
+          ...input === void 0 ? {} : { origin: input.origin },
+          markerLines: markers2.map((s) => s.line)
+        });
+        matched.add(value);
+      }
+      if (found.length > 0) continue;
+      const markers = markersFor(value);
+      if (markers.length === 0) continue;
+      markerLines.push(...markers.map((s) => s.line));
+      for (const statement of markers) drop(statement, value);
+      removed.push({ id: value, markerLines: markers.map((s) => s.line) });
+      matched.add(value);
+    }
+    const nothing = { file: label, removed: [], diff: "", written: false };
+    if (removed.length === 0) {
+      if (path === void 0) nothing.content = content;
+      planned.push({ page: nothing, ...path === void 0 ? {} : { path } });
+      return;
+    }
+    const touched = [...new Set(markerLines)].sort((a, b) => a - b);
+    for (const line of touched) {
+      if (!isMarkerLine(lines[line - 1] ?? "", format)) {
+        const id = page.statements.find((s) => s.line === line)?.payload;
+        const named2 = id?.kind === "ref" ? ` ${id.ids.join(" ")}` : "";
+        throw new CiteError(
+          `the marker${named2} at ${label}:${String(line)} shares its line with text; remove it by hand.`
+        );
+      }
+    }
+    const kept = /* @__PURE__ */ new Map();
+    const ordered = [];
+    for (const line of touched) {
+      const held = dropped.get(line);
+      const [head, ...rest] = held === void 0 || held.statement.payload.kind !== "ref" ? [] : held.statement.payload.ids.filter((id) => !held.ids.has(id));
+      if (head === void 0) ordered.push(line);
+      else kept.set(line, [head, ...rest]);
+    }
+    const survivors = page.citations.filter((c) => !indices.has(c.origin.index));
+    const shifted = shiftedEntries({
+      citations: survivors,
+      at: ordered,
+      delta: -1,
+      bodyLine: page.bodyLine,
+      label
+    });
+    const edits = [];
+    for (const [line, ids] of kept) {
+      const held = dropped.get(line);
+      if (held === void 0) continue;
+      const edit = respellEdit(content, held.statement, ids);
+      if (edit === void 0) {
+        throw new CiteError(
+          `manni cannot read the marker at ${label}:${String(line)} to rewrite it; remove it by hand.`
+        );
+      }
+      edits.push(edit);
+    }
+    edits.push(...lineRemovals(content, ordered));
+    let after = applyEdits(content, edits);
+    for (const { index, lines: moved } of shifted.frontmatter) {
+      after = spliceEntryField(after, format, index, ["claim", "lines"], moved);
+    }
+    if (owner === void 0) {
+      after = removeFrontmatterCitations(after, format, indices, label);
+    } else {
+      if (setup.sidecar?.entry === void 0) {
+        throw new CiteError(
+          `${label} carries no ${owner.join}: value, so its citations cannot be keyed in ${owner.file}.`
+        );
+      }
+      const kept2 = inputs.map((input, index) => {
+        const moved = shifted.manifest.get(index);
+        return moved === void 0 ? input.entry : withClaimLines(input.entry, moved);
+      }).filter((_entry, index) => !indices.has(index));
+      if (kept2.length === 0) await manifests.remove(owner, setup.sidecar.entry);
+      else void await manifests.write(owner, setup.sidecar.entry, kept2, 0);
+    }
+    const out = {
+      file: label,
+      removed,
+      diff: after === content ? "" : unifiedDiff(label, content, after),
+      written: false
+    };
+    if (path === void 0) out.content = after;
+    planned.push({ page: out, ...after === content ? {} : { content: after }, ...path === void 0 ? {} : { path } });
+  };
+  if (usingStdin) await removeOne(STDIN_LABEL, opts.stdinContent ?? "");
+  for (const file of files) {
+    await removeOne(file, await readTarget(run, file), resolve2(run.base, file));
+  }
+  assertNoOrphanJoins(prepared, hits);
+  const missing = only.find((value) => !matched.has(value));
+  if (missing !== void 0) {
+    const where = pageCount === 1 ? `${planned[0]?.page.file ?? "the page"} has no` : `none of ${String(pageCount)} pages has an`;
+    const what = POINTER.test(missing) ? `entry ${missing}` : `entry or marker ${missing}`;
+    throw new CiteError(`${where} ${what}.`);
+  }
+  const write = opts.dryRun !== true;
+  for (const item of planned) {
+    if (item.content === void 0 || item.path === void 0) continue;
+    if (write) await writeFileAtomic(item.path, item.content);
+    item.page.written = write;
+  }
+  const rewritten = [];
+  const record = (changed) => {
+    rewritten.push({ file: changed.file, diff: changed.diff, written: write });
+  };
+  if (write) await manifests.commit({ after: record });
+  else for (const changed of manifests.changed()) record(changed);
+  const pages = planned.map((item) => item.page);
+  return {
+    pages,
+    removed: pages.reduce((n, page) => n + page.removed.length, 0),
+    ...rewritten.length > 0 ? { manifests: rewritten } : {}
+  };
+}
+
+// src/cite/commands/update.ts
+import { resolve as resolve3 } from "node:path";
+function sayNoUnit(reason) {
+  switch (reason) {
+    case "outside":
+      return "the line is outside the page body";
+    case "blank":
+      return "the line is blank";
+    case "fence-crossed":
+      return "the claim's lines are not all inside one fenced block";
+    case "marker":
+      return "that line now holds a cite marker, not claim text";
+    case "not-a-paragraph":
+      return "the line does not start a paragraph";
+    case "table-short":
+      return "the table no longer holds every row the claim covers";
+    case "table-rule":
+      return "that line is a table rule, not claim text";
+  }
+}
+function unitNoun(kind) {
+  return kind === "fenced-lines" ? "fenced text" : kind;
+}
+function settles(plan) {
+  switch (plan.kind) {
+    case "claim-moved":
+      return "claim-moved";
+    case "source-moved":
+      return "source-moved";
+    case "claim-accepted":
+      return "claim-changed";
+    case "source-accepted":
+      return plan.result.source.status === "never-true" ? "source-never-true" : "source-changed";
+    case "marker-moved":
+      return "marker-misplaced";
+    case "claim-reanchored":
+      return "claim-moved";
+    case "claim-words-held":
+      return "claim-reanchored";
+    // A refused claim leaves nothing written, but its finding is the row the
+    // refusal prints, so it is not also reported as skipped.
+    case "claim-replaced":
+      return "claim-changed";
+    // A shifted entry was `current`, so it had no finding to settle. A
+    // re-committed one was `current` too: `check` never reported it, which is
+    // why the repair is asked for rather than offered.
+    case "claim-shifted":
+    case "source-recommitted":
+      return "";
+  }
+}
+function apply2(content, format, plan) {
+  const index = plan.result.origin.index;
+  switch (plan.kind) {
+    case "claim-moved":
+    case "claim-shifted":
+      return spliceEntryField(content, format, index, ["claim", "lines"], plan.lines);
+    case "claim-reanchored":
+      return spliceEntryField(content, format, index, ["claim", "integrity"], plan.pin);
+    case "claim-words-held": {
+      let out = spliceEntryField(content, format, index, ["claim", "integrity"], plan.pin);
+      if (plan.lines !== void 0) {
+        out = spliceEntryField(out, format, index, ["claim", "lines"], plan.lines);
+      }
+      return out;
+    }
+    // Nothing is written for a refused claim; the report is the whole of it.
+    case "claim-replaced":
+    // The move is a page rewrite, applied to the whole page before any splice.
+    case "marker-moved":
+      return content;
+    case "source-moved": {
+      let out = content;
+      if (plan.file !== void 0) {
+        out = spliceEntryField(out, format, index, ["source", "file"], plan.file);
+      }
+      if (plan.lines !== void 0) {
+        out = spliceEntryField(out, format, index, ["source", "lines"], plan.lines);
+      }
+      out = spliceEntryField(out, format, index, ["source", "integrity"], plan.pin);
+      if (plan.commitSha !== void 0) {
+        out = spliceEntryField(out, format, index, ["source", "commit-sha"], plan.commitSha);
+      }
+      return out;
+    }
+    case "source-recommitted":
+      return spliceEntryField(content, format, index, ["source", "commit-sha"], plan.commitSha);
+    case "claim-accepted": {
+      let out = spliceEntryField(content, format, index, ["claim", "integrity"], plan.pin);
+      if (plan.lines !== void 0) {
+        out = spliceEntryField(out, format, index, ["claim", "lines"], plan.lines);
+      }
+      return out;
+    }
+    case "source-accepted": {
+      let out = content;
+      if (plan.span !== void 0) {
+        out = spliceEntryField(out, format, index, ["source", "lines"], plan.span.lines);
+      }
+      out = spliceEntryField(
+        out,
+        format,
+        index,
+        ["source", "integrity"],
+        plan.minted.source.integrity
+      );
+      const commit = plan.minted.source["commit-sha"];
+      if (commit !== void 0) {
+        out = spliceEntryField(out, format, index, ["source", "commit-sha"], commit);
+      }
+      return out;
+    }
+  }
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function applyToEntry(entry, plan) {
+  if (!isRecord2(entry)) return false;
+  const end = (name) => isRecord2(entry[name]) ? entry[name] : void 0;
+  switch (plan.kind) {
+    case "claim-moved":
+    case "claim-shifted": {
+      const claim = end("claim");
+      if (claim === void 0) return false;
+      claim.lines = plan.lines;
+      return true;
+    }
+    case "claim-reanchored": {
+      const claim = end("claim");
+      if (claim === void 0) return false;
+      claim.integrity = plan.pin;
+      return true;
+    }
+    case "claim-words-held": {
+      const claim = end("claim");
+      if (claim === void 0) return false;
+      claim.integrity = plan.pin;
+      if (plan.lines !== void 0) claim.lines = plan.lines;
+      return true;
+    }
+    // Nothing is written for a refused claim.
+    case "claim-replaced":
+    // The page holds the marker, so the manifest has nothing to change.
+    case "marker-moved":
+      return true;
+    case "source-moved": {
+      const source = end("source");
+      if (source === void 0) return false;
+      if (plan.file !== void 0) source.file = plan.file;
+      if (plan.lines !== void 0) source.lines = plan.lines;
+      source.integrity = plan.pin;
+      if (plan.commitSha !== void 0) source["commit-sha"] = plan.commitSha;
+      return true;
+    }
+    case "source-recommitted": {
+      const source = end("source");
+      if (source === void 0) return false;
+      source["commit-sha"] = plan.commitSha;
+      return true;
+    }
+    case "claim-accepted": {
+      const claim = end("claim");
+      if (claim === void 0) return false;
+      claim.integrity = plan.pin;
+      if (plan.lines !== void 0) claim.lines = plan.lines;
+      return true;
+    }
+    case "source-accepted": {
+      const source = end("source");
+      if (source === void 0) return false;
+      if (plan.span !== void 0) source.lines = plan.span.lines;
+      source.integrity = plan.minted.source.integrity;
+      const commit = plan.minted.source["commit-sha"];
+      if (commit !== void 0) source["commit-sha"] = commit;
+      return true;
+    }
+  }
+}
+function rewriteOf(plan) {
+  const { citation, origin, source } = plan.result;
+  const base = { index: origin.index };
+  if (citation.id !== void 0) base.id = citation.id;
+  if (origin.line !== void 0) base.line = origin.line;
+  switch (plan.kind) {
+    case "claim-moved":
+      return {
+        ...base,
+        end: "claim",
+        reason: "moved",
+        status: "moved",
+        from: plan.from,
+        to: plan.to,
+        fromLines: plan.from,
+        toLines: plan.to
+      };
+    case "marker-moved": {
+      const from = String(plan.from);
+      const to = String(plan.to);
+      return {
+        ...base,
+        end: "marker",
+        reason: "re-anchored",
+        status: "misplaced",
+        from,
+        to,
+        fromLines: from,
+        toLines: to
+      };
+    }
+    case "claim-reanchored": {
+      const was = citation.claim?.integrity ?? "";
+      return {
+        ...base,
+        end: "claim",
+        reason: "re-anchored",
+        status: "moved",
+        from: was,
+        to: plan.pin,
+        fromPin: was,
+        toPin: plan.pin,
+        lines: plan.held,
+        newLines: plan.now
+      };
+    }
+    case "claim-words-held": {
+      const was = citation.claim?.integrity ?? "";
+      const out = {
+        ...base,
+        end: "claim",
+        reason: "re-anchored",
+        status: "reanchored",
+        from: was,
+        to: plan.pin,
+        fromPin: was,
+        toPin: plan.pin,
+        fromLines: plan.fromLines,
+        toLines: plan.toLines,
+        at: plan.at
+      };
+      if (plan.commitSha !== void 0) out.commitSha = plan.commitSha;
+      return out;
+    }
+    case "claim-replaced":
+      return {
+        ...base,
+        end: "claim",
+        reason: "replaced",
+        status: "changed",
+        from: plan.pin,
+        to: plan.would,
+        fromPin: plan.pin,
+        toPin: plan.would,
+        at: plan.at,
+        commitSha: plan.commitSha,
+        ...plan.wordShare === void 0 ? {} : { wordShare: plan.wordShare }
+      };
+    case "claim-shifted":
+      return {
+        ...base,
+        end: "claim",
+        reason: "shifted",
+        status: "current",
+        from: plan.from,
+        to: plan.to,
+        fromLines: plan.from,
+        toLines: plan.to
+      };
+    case "source-moved":
+      return {
+        ...base,
+        end: "source",
+        reason: "moved",
+        status: "moved",
+        from: source.src,
+        to: plan.to
+      };
+    case "source-recommitted":
+      return {
+        ...base,
+        end: "source",
+        reason: "recommitted",
+        // The source itself held. Only its date was wrong.
+        status: "current",
+        because: plan.because,
+        from: plan.from,
+        to: plan.commitSha,
+        fromCommit: plan.from,
+        toCommit: plan.commitSha,
+        src: source.src
+      };
+    case "claim-accepted": {
+      const was = citation.claim?.integrity ?? "";
+      const out = {
+        ...base,
+        end: "claim",
+        reason: "accepted",
+        // A bypassed guard reads `replaced`, so the log shows that the line
+        // held other text and a named accept took it anyway.
+        status: plan.replaced === true ? "replaced" : "changed",
+        from: was,
+        to: plan.pin,
+        fromPin: was,
+        toPin: plan.pin,
+        at: plan.unit.lines.start,
+        text: quoted(plan.unit.text)
+      };
+      const stored = plan.result.claim?.fileLines;
+      const now = spellLines(plan.unit.lines);
+      if (stored !== void 0 && stored !== now) {
+        out.fromLines = stored;
+        out.toLines = now;
+      }
+      const markerLine = plan.markerLine ?? (plan.result.anchor === "marker" ? plan.result.markerLine : void 0);
+      if (markerLine !== void 0) out.markerLine = markerLine;
+      return out;
+    }
+    case "source-accepted": {
+      const out = {
+        ...base,
+        end: "source",
+        reason: "accepted",
+        status: source.status === "never-true" ? "never-true" : "changed",
+        from: citation.source.integrity,
+        to: plan.minted.source.integrity,
+        fromPin: citation.source.integrity,
+        toPin: plan.minted.source.integrity,
+        src: source.src
+      };
+      if (plan.span !== void 0) {
+        out.fromLines = plan.span.from;
+        out.toLines = plan.span.to;
+      }
+      const commit = plan.minted.source["commit-sha"];
+      if (commit !== void 0) out.commitSha = commit;
+      return out;
+    }
+  }
+}
+var CLAIM_WORD_SHARE = 0.5;
+function replacementAt(claim, text, format) {
+  const was = claim.baselineText;
+  const commit = claim.commitSha;
+  if (was === void 0 || commit === void 0) return void 0;
+  const before = claimWords(was, format);
+  const now = claimWords(text, format);
+  if (!sharesSentence(before, now)) return { commit };
+  const share = wordShare(before, now);
+  if (share < CLAIM_WORD_SHARE) return { commit, share };
+  return void 0;
+}
+var QUOTE_CAP = 200;
+function quoted(text) {
+  const all = normalizeWhitespace(text.join("\n"));
+  return all.length <= QUOTE_CAP ? all : `${all.slice(0, QUOTE_CAP)}\u2026`;
+}
+function named(id, text) {
+  return id === void 0 ? text : `${id}: ${text}`;
+}
+function crossing(page, misplaced) {
+  for (const other of page.citations) {
+    const spec = other.citation.claim?.lines;
+    const recorded = spec === void 0 ? void 0 : parseLines(spec);
+    if (recorded === void 0) continue;
+    const file = toFileLines(recorded, page.bodyLine);
+    const holdsMarker = file.start <= misplaced.line && misplaced.line <= file.end;
+    const holdsPlace = file.start < misplaced.place && misplaced.place <= file.end;
+    if (!holdsMarker && !holdsPlace) continue;
+    return other.citation.id === void 0 ? `the claim at ${spellAt(file)}` : `the claim of ${other.citation.id} (${spellAt(file)})`;
+  }
+  return void 0;
+}
+function decideMarkers(input) {
+  const { page, report, lines, accept, only } = input;
+  const out = { moves: [], stays: [] };
+  for (const misplaced of misplacedMarkers(page, lines)) {
+    const entry = misplaced.entry;
+    const line = misplaced.line;
+    const stay = (rule, message) => {
+      out.stays.push({ line, rule, message });
+    };
+    if (entry === void 0) {
+      if (only !== void 0) continue;
+      const own = report.findings.find(
+        (finding) => finding.line === line && finding.rule.startsWith("marker-") && finding.rule !== "marker-misplaced"
+      );
+      stay(
+        own?.rule ?? "marker-orphan",
+        `the marker at line ${String(line)} stays, because it names no entry update can check.`
+      );
+      continue;
+    }
+    const id = entry.citation.id;
+    if (only !== void 0 && (id === void 0 || !only.has(id))) continue;
+    const result = report.citations.find((r) => r.origin.index === entry.origin.index);
+    if (result === void 0) continue;
+    if (entry.citation.claim?.lines !== void 0) {
+      stay(
+        "anchor-invalid",
+        named(id, `the marker at line ${String(line)} stays, because the entry also has claim lines. Keep one.`)
+      );
+      continue;
+    }
+    const across = crossing(page, misplaced);
+    if (across !== void 0) {
+      stay(
+        "marker-misplaced",
+        named(id, `the marker at line ${String(line)} stays, because moving it would change ${across}.`)
+      );
+      continue;
+    }
+    if (result.claim !== null && result.claim.status === "changed" && !accept) {
+      stay(
+        "marker-misplaced",
+        named(
+          id,
+          `the marker at line ${String(line)} stays, because its claim changed since it was pinned. update --accept moves it and re-pins.`
+        )
+      );
+      continue;
+    }
+    out.moves.push({ result, entry, misplaced });
+  }
+  return out;
+}
+function anchoredNow(content, format, lines, markerLine, quote) {
+  const at = offsetOfLine(content, markerLine) + (lines[markerLine - 1]?.length ?? 0);
+  const span = anchoredLines(content, at, format, quote);
+  if (span === void 0) return void 0;
+  const pin = pinOfLines(lines, span);
+  return pin === void 0 ? void 0 : { span, pin };
+}
+function codeOf(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) return void 0;
+  const code = error.code;
+  return typeof code === "string" ? code : void 0;
+}
+var WrittenFiles = class {
+  before = /* @__PURE__ */ new Map();
+  labels = /* @__PURE__ */ new Map();
+  /** Remember what `path` held before this run wrote it. */
+  record(path, label, content) {
+    if (!this.before.has(path)) {
+      this.before.set(path, content);
+      this.labels.set(path, label);
+    }
+  }
+  /**
+   * Put every file back, and say what happened: `<file> could not be written
+   * (<code>). <pages> was restored.`
+   */
+  async restore(file, error) {
+    const restored = [];
+    const failed = [];
+    for (const [path, content] of this.before) {
+      const label = this.labels.get(path) ?? path;
+      try {
+        await writeFileAtomic(path, content);
+        restored.push(label);
+      } catch {
+        failed.push(label);
+      }
+    }
+    const code = codeOf(error);
+    const why = code === void 0 ? "" : ` (${code})`;
+    const parts = [`${file} could not be written${why}.`];
+    if (restored.length > 0) {
+      parts.push(`${listOf(restored)} ${restored.length === 1 ? "was" : "were"} restored.`);
+    }
+    if (failed.length > 0) {
+      parts.push(
+        `${listOf(failed)} could not be restored, and ${failed.length === 1 ? "holds" : "hold"} an intermediate state.`
+      );
+    }
+    return new CiteError(parts.join(" "));
+  }
+};
+function citationsIn(rows) {
+  const withMarker = new Set(rows.filter((row) => row.end === "marker").map((row) => row.index));
+  return withMarker.size + rows.filter((row) => !withMarker.has(row.index)).length;
+}
+async function runUpdate(opts) {
+  const prepared = await prepareRun(opts, "updated", "update", { require: true });
+  const { run, files, usingStdin, forced, pageOptions, git } = prepared;
+  await assertNoOrphans(prepared);
+  const hits = joinHits();
+  const manifests = new ManifestSet();
+  const writes = new WrittenFiles();
+  const only = opts.only !== void 0 && opts.only.length > 0 ? new Set(opts.only) : void 0;
+  const accept = opts.accept === true;
+  const recommit = opts.recommit === true;
+  if (recommit && !await git.available()) {
+    throw new CiteError(
+      "--recommit needs git to verify recorded commits, and git is not available here."
+    );
+  }
+  const outsideHistory = async (commit, head) => {
+    if (git.shallow === void 0 || git.isAncestor === void 0) return false;
+    if (await git.shallow()) return false;
+    return !await git.isAncestor(commit, head);
+  };
+  const recommitFor = async (result) => {
+    const recorded = result.citation.source["commit-sha"];
+    const path = result.source.resolvedPath;
+    if (recorded === void 0 || path === void 0) return void 0;
+    const head = await git.head();
+    if (head === null || head === recorded) return void 0;
+    const range = sourceRange(result.citation.source);
+    const pin = result.citation.source.integrity;
+    const key = range.encrypted ? run.key : void 0;
+    let because;
+    if (await outsideHistory(recorded, head)) because = "not-in-history";
+    else {
+      const was = await historyOf(git, recorded, path, range, pin, key, void 0);
+      if (was.kind !== "never-true") return void 0;
+      because = "not-contained";
+    }
+    const now = await historyOf(git, head, path, range, pin, key, void 0);
+    return now.kind === "original" ? { commit: head, because } : void 0;
+  };
+  const plansFor = async (result, entry, page, lines, lineNow, declined) => {
+    const out = [];
+    const claim = result.claim;
+    if (result.anchor !== "marker" && claim !== null && claim.status === "moved" && claim.newLines !== void 0) {
+      const at = parseLines(claim.newLines);
+      const shifted = at === void 0 ? void 0 : (() => {
+        const file = toFileLines(at, page.bodyLine);
+        const to = { start: lineNow(file.start), end: lineNow(file.end) };
+        return to.end - to.start === file.end - file.start ? toBodyLines(to, page.bodyLine) : void 0;
+      })();
+      if (at !== void 0 && shifted !== void 0) {
+        out.push({
+          kind: "claim-moved",
+          result,
+          lines: lineSpec(shifted),
+          from: claim.fileLines ?? "",
+          to: spellLines(toFileLines(shifted, page.bodyLine))
+        });
+      }
+    }
+    if (result.anchor !== "marker" && claim !== null && claim.status === "reanchored" && claim.newLines !== void 0) {
+      const at = parseLines(claim.newLines);
+      const file = at === void 0 ? void 0 : toFileLines(at, page.bodyLine);
+      const pin = file === void 0 ? void 0 : pinOfLines(lines, file);
+      const to = file === void 0 ? void 0 : { start: lineNow(file.start), end: lineNow(file.end) };
+      if (file !== void 0 && to !== void 0 && pin !== void 0 && to.end - to.start === file.end - file.start) {
+        const plan = {
+          kind: "claim-words-held",
+          result,
+          pin,
+          at: to.start,
+          fromLines: claim.fileLines ?? "",
+          toLines: spellLines(to),
+          lines: lineSpec(toBodyLines(to, page.bodyLine))
+        };
+        if (claim.commitSha !== void 0) plan.commitSha = claim.commitSha;
+        out.push(plan);
+      }
+    }
+    if (result.source.status === "moved" && result.source.newSrc !== void 0) {
+      const to = result.source.newSrc;
+      const recorded = result.citation.source["commit-sha"];
+      const at = result.source.newLines === void 0 ? void 0 : parseLines(result.source.newLines);
+      const went = parseSrc(to).path;
+      const crossFile = went !== result.citation.source.file;
+      if (at !== void 0 || result.citation.source.lines === void 0) {
+        try {
+          if (crossFile) {
+            out.push({
+              kind: "source-moved",
+              result,
+              to,
+              file: went,
+              pin: result.citation.source.integrity,
+              ...at === void 0 ? {} : { lines: lineSpec(at) }
+            });
+          } else if (at !== void 0) {
+            const minted = await mintCitation({
+              root: run.root,
+              src: to,
+              ...run.key === void 0 ? {} : { key: run.key },
+              ...recorded === void 0 ? { commitSha: false } : {},
+              gitClient: git,
+              ...pageOptions.sourceIndex === void 0 ? {} : { sourceIndex: pageOptions.sourceIndex }
+            });
+            const commit = minted.source["commit-sha"];
+            if (recorded !== void 0 && commit === void 0) {
+              declined.set(result.origin.index, {
+                rule: "source-moved",
+                why: "Not rewritten: git is not available here, so the entry's commit-sha cannot advance with its lines."
+              });
+            } else {
+              out.push({
+                kind: "source-moved",
+                result,
+                lines: lineSpec(at),
+                to,
+                pin: minted.source.integrity,
+                ...commit === void 0 ? {} : { commitSha: commit }
+              });
+            }
+          }
+        } catch (error) {
+          if (!(error instanceof CiteError)) throw error;
+          declined.set(result.origin.index, {
+            rule: "source-moved",
+            why: `Not rewritten: ${error.message}`
+          });
+        }
+      }
+    }
+    if (recommit && result.source.status === "current") {
+      const to = await recommitFor(result);
+      if (to !== void 0) {
+        out.push({
+          kind: "source-recommitted",
+          result,
+          from: result.citation.source["commit-sha"] ?? "",
+          commitSha: to.commit,
+          because: to.because
+        });
+      }
+    }
+    if (!accept) return out;
+    if (claim !== null && claim.status === "changed" && entry !== void 0 && result.anchor !== "marker") {
+      const held = claim.fileLines === void 0 ? void 0 : parseLines(claim.fileLines);
+      const at = held?.start;
+      const named2 = only !== void 0;
+      const unit = at === void 0 ? void 0 : unitAt(page, at, lines, held, named2);
+      const wantsBlock = entry.citation.quote === true;
+      const pin = unit === void 0 ? void 0 : pinOfLines(lines, unit.lines);
+      const wide = unit === void 0 ? void 0 : tooWide(unit.lines);
+      if (unit !== void 0 && wide !== void 0) {
+        declined.set(result.origin.index, {
+          rule: "claim-changed",
+          why: `Not re-pinned: the ${unitNoun(unit.kind)} ${wide}.`
+        });
+      } else if (unit === void 0) {
+        const why = at === void 0 ? void 0 : noUnitAt(page, at, lines, held, named2);
+        if (why !== void 0) {
+          declined.set(result.origin.index, {
+            rule: "claim-changed",
+            why: `Not re-pinned: ${sayNoUnit(why)}.`
+          });
+        }
+      } else if (wantsBlock && unit.kind !== "block") {
+        declined.set(result.origin.index, {
+          rule: "claim-changed",
+          why: "Not re-pinned: quote: true, and the line no longer opens a fenced block."
+        });
+      } else if (pin !== void 0) {
+        const elsewhere = named2 ? [] : otherClaimSpans(lines, unit.lines, pin, page.bodyLine);
+        const replaced = replacementAt(claim, unit.text, page.format);
+        if (replaced !== void 0 && only === void 0) {
+          out.push({
+            kind: "claim-replaced",
+            result,
+            at: unit.lines.start,
+            commitSha: replaced.commit,
+            ...replaced.share === void 0 ? {} : { wordShare: replaced.share },
+            pin: entry.citation.claim?.integrity ?? "",
+            would: pin
+          });
+        } else if (elsewhere.length > 0) {
+          const id = result.citation.id;
+          const anyway = id === void 0 ? "" : ` Re-run with --only ${id} to accept it anyway.`;
+          declined.set(result.origin.index, {
+            rule: "claim-changed",
+            why: `Not re-pinned: the text there also appears at ${spellElsewhere(elsewhere)}, so a pin cannot identify it.${anyway}`
+          });
+        } else {
+          const plan = { kind: "claim-accepted", result, unit, pin };
+          if (replaced !== void 0) plan.replaced = true;
+          if (entry.citation.claim?.lines !== void 0) {
+            const body = toBodyLines(unit.lines, page.bodyLine);
+            const recorded = parseLines(entry.citation.claim.lines);
+            if (recorded === void 0 || recorded.start !== body.start || recorded.end !== body.end) {
+              plan.lines = lineSpec(body);
+            }
+          }
+          out.push(plan);
+        }
+      }
+    }
+    if (result.source.status === "changed" || result.source.status === "never-true") {
+      const stored = parseSrc(result.source.src);
+      const span = result.source.newLines === void 0 ? void 0 : parseLines(result.source.newLines);
+      const at = span === void 0 || span.start === stored.start && span.end === stored.end ? void 0 : { ...stored, start: span.start, end: span.end };
+      try {
+        const minted = await mintCitation({
+          root: run.root,
+          src: at === void 0 ? result.source.src : formatSrc(at),
+          ...run.key === void 0 ? {} : { key: run.key },
+          ...result.citation.source["commit-sha"] === void 0 ? { commitSha: false } : {},
+          gitClient: git,
+          ...pageOptions.sourceIndex === void 0 ? {} : { sourceIndex: pageOptions.sourceIndex }
+        });
+        out.push({
+          kind: "source-accepted",
+          result,
+          minted,
+          ...at === void 0 || span === void 0 ? {} : {
+            span: {
+              lines: lineSpec(span),
+              from: spellLines({ start: stored.start ?? 1, end: stored.end ?? stored.start ?? 1 }),
+              to: spellLines(span)
+            }
+          }
+        });
+      } catch (error) {
+        if (!(error instanceof CiteError)) throw error;
+      }
+    }
+    return out;
+  };
+  const pages = [];
+  const updateOne = async (label, content, path) => {
+    const setup = await prepared.setupFor(label, content);
+    if (setup.sidecar !== void 0) hits.record(setup.sidecar, label);
+    const report = await checkCitations({ file: label, content, format: forced?.name }, setup.options);
+    const { format } = report;
+    const severity = resolveSeverity(setup.options.severity);
+    const page = readPage(label, content, {
+      ...forced === void 0 ? {} : { format: forced.name },
+      ...setup.options.citations === void 0 ? {} : { citations: setup.options.citations },
+      ...setup.options.owned === void 0 ? {} : { owned: setup.options.owned }
+    });
+    const lines = splitLines(content);
+    const rewritten2 = [];
+    const refused = [];
+    const settled = /* @__PURE__ */ new Set();
+    const declined = /* @__PURE__ */ new Map();
+    const markers = decideMarkers({ page, report, lines, accept, only });
+    const movedPage = markers.moves.length === 0 ? void 0 : applyMarkerMoves(
+      content,
+      markers.moves.map(({ misplaced }) => ({
+        from: misplaced.line,
+        place: misplaced.place
+      })),
+      (line) => markerIndent(content, line, format, page.bodyLine)
+    );
+    let after = movedPage?.content ?? content;
+    const afterLines = movedPage === void 0 ? lines : splitLines(after);
+    const movedIndexes = new Set(markers.moves.map(({ entry }) => entry.origin.index));
+    const lineNow = (line) => movedPage?.line(line) ?? line;
+    const owner = setup.sidecar?.owner;
+    const entries = setup.sidecar?.citations === void 0 ? void 0 : JSON.parse(JSON.stringify(setup.sidecar.citations.map((c) => c.entry)));
+    let manifestDirty = false;
+    for (const result of report.citations) {
+      const selected = only === void 0 || result.citation.id !== void 0 && only.has(result.citation.id);
+      const entry = page.citations.find((c) => c.origin.index === result.origin.index);
+      const plans = [];
+      const move = selected ? markers.moves.find((m) => m.entry.origin.index === result.origin.index) : void 0;
+      if (move !== void 0) {
+        plans.push({
+          kind: "marker-moved",
+          result,
+          from: move.misplaced.line,
+          to: lineNow(move.misplaced.line)
+        });
+      }
+      const marker = entry?.marker;
+      const recorded = entry?.citation.claim?.integrity;
+      if (selected && result.anchor === "marker" && marker !== void 0 && recorded !== void 0 && result.claim !== null) {
+        const quote = entry?.citation.quote === true;
+        const now = anchoredNow(after, format, afterLines, lineNow(marker.line), quote);
+        const status = result.claim.status;
+        if (now !== void 0 && now.pin !== recorded) {
+          const unitText = afterLines.slice(now.span.start - 1, now.span.end);
+          if (status === "moved" || status === "current" && move !== void 0) {
+            plans.push({
+              kind: "claim-reanchored",
+              result,
+              pin: now.pin,
+              held: result.claim.fileLines ?? "",
+              now: spellLines(now.span)
+            });
+          } else if (status === "reanchored") {
+            const held = {
+              kind: "claim-words-held",
+              result,
+              pin: now.pin,
+              at: now.span.start,
+              fromLines: result.claim.fileLines ?? "",
+              toLines: spellLines(now.span)
+            };
+            if (result.claim.commitSha !== void 0) held.commitSha = result.claim.commitSha;
+            plans.push(held);
+          } else if (status === "changed" && accept) {
+            const kind = quote ? "block" : "paragraph";
+            const wide = tooWide(now.span);
+            if (wide !== void 0) {
+              declined.set(result.origin.index, {
+                rule: "claim-changed",
+                why: `Not re-pinned: the ${kind} ${wide}.`
+              });
+            } else {
+              const replaced = replacementAt(result.claim, unitText, format);
+              plans.push(
+                replaced === void 0 || only !== void 0 ? {
+                  kind: "claim-accepted",
+                  result,
+                  pin: now.pin,
+                  markerLine: lineNow(marker.line),
+                  unit: { lines: now.span, kind, text: unitText },
+                  ...replaced === void 0 ? {} : { replaced: true }
+                } : {
+                  kind: "claim-replaced",
+                  result,
+                  at: now.span.start,
+                  commitSha: replaced.commit,
+                  ...replaced.share === void 0 ? {} : { wordShare: replaced.share },
+                  pin: recorded,
+                  would: now.pin
+                }
+              );
+            }
+          }
+        }
+      }
+      if (selected) {
+        plans.push(...await plansFor(result, entry, page, lines, lineNow, declined));
+      }
+      const spec = entry?.citation.claim?.lines;
+      const wentElsewhere = result.claim?.status === "moved";
+      if (movedPage !== void 0 && spec !== void 0 && !wentElsewhere && !plans.some((p) => p.kind === "claim-moved")) {
+        const at = parseLines(spec);
+        const file = at === void 0 ? void 0 : toFileLines(at, page.bodyLine);
+        const to = file === void 0 ? void 0 : { start: lineNow(file.start), end: lineNow(file.end) };
+        if (file !== void 0 && to !== void 0 && to.end - to.start === file.end - file.start && (to.start !== file.start || to.end !== file.end)) {
+          plans.push({
+            kind: "claim-shifted",
+            result,
+            lines: lineSpec(toBodyLines(to, page.bodyLine)),
+            from: spellLines(file),
+            to: spellLines(to)
+          });
+        }
+      }
+      for (const plan of plans) {
+        if (plan.kind === "claim-replaced") {
+          refused.push(rewriteOf(plan));
+          settled.add(`${String(result.origin.index)}\0${settles(plan)}`);
+          continue;
+        }
+        if (plan.kind === "marker-moved") {
+        } else if (result.origin.kind === "manifest") {
+          const held = entries?.[result.origin.index];
+          if (held === void 0) {
+            declined.set(result.origin.index, {
+              rule: settles(plan),
+              why: `Not rewritten: ${owner?.file ?? "the manifest"} has no entry at index ${String(result.origin.index)}.`
+            });
+            continue;
+          }
+          if (!applyToEntry(held, plan)) continue;
+          manifestDirty = true;
+        } else {
+          after = apply2(after, format, plan);
+        }
+        rewritten2.push(rewriteOf(plan));
+        settled.add(`${String(result.origin.index)}\0${settles(plan)}`);
+      }
+    }
+    for (const index of movedIndexes) settled.add(`${String(index)}\0marker-misplaced`);
+    if (manifestDirty && owner !== void 0 && entries !== void 0) {
+      if (setup.sidecar?.entry === void 0) {
+        throw new CiteError(
+          `${label} carries no ${owner.join}: value, so its citations cannot be keyed in ${owner.file}.`
+        );
+      }
+      await manifests.write(owner, setup.sidecar.entry, entries, 0);
+    }
+    const stayAt = new Map(markers.stays.map((stay) => [stay.line, stay]));
+    const skipped2 = report.findings.filter(
+      (finding) => (only === void 0 || finding.id !== void 0 && only.has(finding.id)) && !settled.has(`${String(finding.index ?? -1)}\0${finding.rule}`)
+    ).map((finding) => {
+      if (finding.rule === "marker-misplaced") {
+        const stay = stayAt.get(finding.line ?? -1);
+        if (stay === void 0) return finding;
+        const level = severity[stay.rule];
+        return {
+          ...finding,
+          message: stay.message,
+          ...level === "off" ? {} : { severity: level }
+        };
+      }
+      const turned = finding.index === void 0 ? void 0 : declined.get(finding.index);
+      const why = turned?.rule === finding.rule ? turned.why : void 0;
+      return why === void 0 ? finding : { ...finding, message: `${finding.message} ${why}` };
+    });
+    const diff = after === content ? "" : unifiedDiff(label, content, after);
+    const written = after !== content && path !== void 0 && opts.dryRun !== true;
+    if (written) {
+      try {
+        await writeFileAtomic(path, after);
+      } catch (error) {
+        throw await writes.restore(label, error);
+      }
+      writes.record(path, label, content);
+    }
+    const out = { file: label, rewritten: rewritten2, refused, skipped: skipped2, diff, written };
+    if (path === void 0) out.content = after;
+    pages.push(out);
+    return report;
+  };
+  const reports = [];
+  if (usingStdin) reports.push(await updateOne(STDIN_LABEL, opts.stdinContent ?? ""));
+  for (const file of files) {
+    reports.push(await updateOne(file, await readTarget(run, file), resolve3(run.base, file)));
+  }
+  assertNoOrphanJoins(prepared, hits);
+  const write = opts.dryRun !== true;
+  const rewrittenManifests = [];
+  const record = (changed) => {
+    rewrittenManifests.push({ file: changed.file, diff: changed.diff, written: write });
+  };
+  if (write) {
+    await manifests.commit({
+      // A manifest joins the run's written files the moment it lands, so a
+      // later manifest's failure puts this one back with the pages. Without
+      // it the tree would keep pins no page content matches.
+      after: (changed) => {
+        writes.record(changed.path, changed.file, changed.before);
+        record(changed);
+      },
+      onError: async (changed, error) => {
+        throw await writes.restore(changed.file, error);
+      }
+    });
+  } else for (const changed of manifests.changed()) record(changed);
+  const reminted = pages.some(
+    (page) => page.rewritten.some((r) => r.reason === "accepted" && r.end === "source")
+  );
+  const also = [];
+  if (reminted && !await git.available()) also.push(GIT_UNAVAILABLE_COMMIT);
+  if (recommit && git.shallow !== void 0 && git.isAncestor !== void 0 && await git.shallow()) {
+    also.push(SHALLOW_RECOMMIT);
+  }
+  sayNotices(reports, opts.onNotice, also);
+  const rewritten = pages.reduce((n, page) => n + citationsIn(page.rewritten), 0);
+  const skipped = pages.reduce((n, page) => n + page.skipped.length + page.refused.length, 0);
+  const undone = pages.some(
+    (page) => page.refused.length > 0 || page.skipped.some((finding) => finding.severity === "error")
+  );
+  return {
+    pages,
+    rewritten,
+    skipped,
+    ...rewrittenManifests.length > 0 ? { manifests: rewrittenManifests } : {},
+    exitCode: undone ? 1 : 0
+  };
+}
+
+export {
+  mintCitation,
+  shiftedEntries,
+  withClaimLines,
+  appendFrontmatterCitation,
+  removeFrontmatterCitations,
+  removeLine,
+  entryObject,
+  spliceEntryField,
+  insertStatementBefore,
+  unifiedDiff,
+  ManifestSet,
+  splice,
+  itemLine,
+  runAdd,
+  runRemove,
+  runUpdate
+};
+//# sourceMappingURL=chunk-5YXBLLAC.js.map