@hawkeyexl/manni 2.8.0 → 2.8.2

package/dist/{chunk-O6RXG33V.js → chunk-WCNU53MJ.js}

@@ -55,6 +55,7 @@ import {
   pinOfLines,
   readConfigFile,
   readFamilyConfigFile,
+  readManifestValue,
   removeManifestKey,
   resolveBaselineRequest,
   resolveEncryptionKey,
@@ -71,7 +72,7 @@ import {
   withValueAt,
   writeEncryptionKey,
   writeFileAtomic
-} from "./chunk-MB3DIO7S.js";
+} from "./chunk-KEW557TN.js";
 
 // src/meta/core/reencrypt.ts
 import { extname } from "node:path";
@@ -151,15 +152,15 @@ function reencryptWith(extractor, page, opts) {
     }
   };
   const data = read(page.content);
-  const apply2 = extractor.apply;
-  const plan = reencryptData(data, { ...opts, writable: apply2 !== void 0 });
+  const apply3 = extractor.apply;
+  const plan = reencryptData(data, { ...opts, writable: apply3 !== void 0 });
   const { rewritten, skipped } = plan;
-  if (rewritten.length === 0 || apply2 === void 0) {
+  if (rewritten.length === 0 || apply3 === void 0) {
     return { content: page.content, rewritten: [], skipped };
   }
   const patch = {};
   for (const top of plan.keys) patch[top] = plan.data[top];
-  const content = apply2(page.content, patch, { filePath: page.file });
+  const content = apply3(page.content, patch, { filePath: page.file });
   const reread = tokensIn(read(content));
   for (const r of rewritten) {
     if (!reread.some((f) => f.pointer === r.pointer && f.token === r.to)) {
@@ -855,6 +856,10 @@ var TABLE_ROW = /^[ \t]*\|/;
 function isTableRow(line) {
   return TABLE_ROW.test(line);
 }
+var TABLE_RULE = /^(?=[^|]*\|)[ \t]*\|?(?:[ \t]*:?-+:?[ \t]*\|)*[ \t]*:?-+:?[ \t]*\|?[ \t]*$/;
+function isTableSeparator(line) {
+  return TABLE_RULE.test(line);
+}
 function isBoundLine(line, format) {
   if (ADORNMENT.test(line)) return true;
   switch (format) {
@@ -1697,36 +1702,61 @@ function claimEnd(page, entry, lines, misplaced) {
   }
   return { status: "changed" };
 }
-function rowsAt(line, lines, recorded) {
+function otherClaimSpans(lines, pageLines, pin, bodyLine) {
+  const width = pageLines.end - pageLines.start + 1;
+  const found = findWindows(lines.slice(bodyLine - 1), width, pin, void 0, {
+    around: toBodyLines(pageLines, bodyLine).start
+  });
+  return found.starts.map((start) => toFileLines({ start, end: start + width - 1 }, bodyLine)).filter((span) => span.start !== pageLines.start);
+}
+var NAMED_SPANS = 3;
+function spellElsewhere(spans) {
+  const first = spans[0];
+  const noun = spans.length === 1 && first !== void 0 && first.start === first.end ? "line" : "lines";
+  const named4 = spans.slice(0, NAMED_SPANS).map((span) => spellLines(span));
+  const rest = spans.length - named4.length;
+  if (rest > 0) return `${noun} ${named4.join(", ")} and ${String(rest)} more`;
+  const last = named4.pop() ?? "";
+  return named4.length === 0 ? `${noun} ${last}` : `${noun} ${named4.join(", ")} and ${last}`;
+}
+function rowsAt(line, lines, recorded, named4) {
   const width = recorded === void 0 ? 1 : Math.max(1, recorded.end - recorded.start + 1);
   const end = line + width - 1;
   if (end > lines.length) return "table-short";
   for (let n = line; n <= end; n++) {
     if (!isTableRow(lines[n - 1] ?? "")) return "table-short";
   }
-  return { lines: { start: line, end }, kind: "paragraph", text: lines.slice(line - 1, end) };
+  const text = lines.slice(line - 1, end);
+  if (!named4 && text.every((row) => isTableSeparator(row))) return "table-rule";
+  return { lines: { start: line, end }, kind: "paragraph", text };
 }
-function unitOrWhy(page, line, lines, recorded) {
+function unitOrWhy(page, line, lines, recorded, named4 = false) {
   if (line < page.bodyLine || line > lines.length) return "outside";
   const own = lines[line - 1] ?? "";
   if (own.trim() === "") return "blank";
+  const marker = isMarkerLine(own, page.format);
+  if (marker && !named4) return "marker";
   const block = fenceSpanAt(page.content, line, page.format);
   if (block !== void 0) {
     return { lines: block, kind: "block", text: lines.slice(block.start - 1, block.end) };
   }
   if (insideFence(page.content, page.bodyOffset, line, page.format)) return "fenced";
-  if (isTableRow(own)) return rowsAt(line, lines, recorded);
-  const paragraph = paragraphAfter(page.content, offsetOfLine(page.content, line));
+  if (isTableRow(own)) return rowsAt(line, lines, recorded, named4);
+  const paragraph = paragraphAfter(
+    page.content,
+    offsetOfLine(page.content, line),
+    marker ? void 0 : page.format
+  );
   if (paragraph === void 0 || paragraph.line !== line) return "not-a-paragraph";
   const span = { start: line, end: lineAt(page.content, paragraph.end) };
   return { lines: span, kind: "paragraph", text: lines.slice(span.start - 1, span.end) };
 }
-function unitAt(page, line, lines, recorded) {
-  const found = unitOrWhy(page, line, lines, recorded);
+function unitAt(page, line, lines, recorded, named4 = false) {
+  const found = unitOrWhy(page, line, lines, recorded, named4);
   return typeof found === "string" ? void 0 : found;
 }
-function noUnitAt(page, line, lines, recorded) {
-  const found = unitOrWhy(page, line, lines, recorded);
+function noUnitAt(page, line, lines, recorded, named4 = false) {
+  const found = unitOrWhy(page, line, lines, recorded, named4);
   return typeof found === "string" ? found : void 0;
 }
 function markerUnit(page, entry, lines) {
@@ -1870,6 +1900,19 @@ 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;
@@ -2620,6 +2663,13 @@ function unifiedDiff(label, before, after) {
 }
 
 // src/cite/core/manifest.ts
+var COMMIT_ATTEMPTS = 5;
+function conflictRefusal(file) {
+  return `${file} changed under the command while it was being written. Nothing was written to it. Re-run the command.`;
+}
+function encodeValue(value) {
+  return value === void 0 ? "absent" : JSON.stringify(value);
+}
 var ManifestSet = class {
   held = /* @__PURE__ */ new Map();
   /** Read a manifest, or hand back the copy this run has already rewritten. */
@@ -2633,7 +2683,14 @@ var ManifestSet = class {
       const reason = error instanceof Error ? error.message : String(error);
       throw new CiteError(`Manifest ${manifest.file} could not be read: ${reason}`);
     }
-    const fresh = { path: manifest.path, file: manifest.file, before, text: before };
+    const fresh = {
+      path: manifest.path,
+      file: manifest.file,
+      before,
+      text: before,
+      ops: [],
+      bases: /* @__PURE__ */ new Map()
+    };
     this.held.set(manifest.path, fresh);
     return fresh;
   }
@@ -2644,16 +2701,36 @@ var ManifestSet = class {
    */
   async write(manifest, entry, citations, index) {
     const held = await this.hold(manifest);
+    const op = {
+      kind: "splice",
+      entry,
+      join: manifest.join,
+      file: manifest.file,
+      value: [...citations]
+    };
+    rebaseable(held, op);
     const spliced = splice(held.text, {
       entry,
       key: CITATIONS_KEY2,
-      value: [...citations],
+      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
@@ -2661,23 +2738,114 @@ var ManifestSet = class {
    */
   async remove(manifest, entry) {
     const held = await this.hold(manifest);
-    try {
-      held.text = removeManifestKey(held.text, {
-        entry,
-        key: CITATIONS_KEY2,
-        join: manifest.join,
-        file: manifest.file
-      }).text;
-    } catch (error) {
-      if (error instanceof DocmetaError) throw new CiteError(error.message);
-      throw error;
-    }
+    const op = { kind: "remove", entry, join: manifest.join, file: manifest.file };
+    rebaseable(held, op);
+    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 ?? writeFileAtomic;
+    const read = io.read ?? ((at2) => readFile2(at2, "utf8"));
+    const landed = [];
+    for (const held of this.held.values()) {
+      if (held.text === held.before) continue;
+      try {
+        await settle(held, write, read);
+      } 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 rebaseable(held, op) {
+  const at2 = op.join === "path" ? posix.normalize(op.entry) : op.entry;
+  if (held.bases.has(at2)) return;
+  held.bases.set(at2, {
+    entry: op.entry,
+    join: op.join,
+    value: encodeValue(
+      readManifestValue(held.before, { entry: op.entry, key: CITATIONS_KEY2, join: op.join })
+    )
+  });
+}
+function apply(text, op) {
+  if (op.kind === "splice") {
+    return splice(text, {
+      entry: op.entry,
+      key: CITATIONS_KEY2,
+      value: op.value,
+      join: op.join,
+      file: op.file
+    }).text;
+  }
+  try {
+    return removeManifestKey(text, {
+      entry: op.entry,
+      key: CITATIONS_KEY2,
+      join: op.join,
+      file: op.file
+    }).text;
+  } catch (error) {
+    if (error instanceof DocmetaError) throw new CiteError(error.message);
+    throw error;
+  }
+}
+function rebase(held, current) {
+  for (const base of held.bases.values()) {
+    const now = encodeValue(
+      readManifestValue(current, { entry: base.entry, key: CITATIONS_KEY2, join: base.join })
+    );
+    if (now !== base.value) return void 0;
+  }
+  let text = current;
+  for (const op of held.ops) text = apply(text, op);
+  return text;
+}
+async function settle(held, write, read) {
+  for (let attempt = 1; attempt <= COMMIT_ATTEMPTS; attempt++) {
+    let current;
+    try {
+      current = await read(held.path);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new CiteError(`Manifest ${held.file} could not be read: ${reason}`);
+    }
+    if (current === held.before) {
+      await write(held.path, held.text);
+      return;
+    }
+    const replayed = rebase(held, current);
+    if (replayed === void 0) throw new CiteError(conflictRefusal(held.file));
+    held.before = current;
+    held.text = replayed;
+  }
+  throw new CiteError(conflictRefusal(held.file));
+}
 function splice(text, options) {
   try {
     return spliceManifestValue(text, options);
@@ -3648,23 +3816,6 @@ function emptyClaimRefusal(lines, pageLines, at2) {
   const only = span[0] ?? "";
   return only.trim() === "" ? `${at2} is blank.` : `${at2} is a fence line, not claim text.`;
 }
-function otherClaimSpans(lines, pageLines, pin, bodyLine) {
-  const width = pageLines.end - pageLines.start + 1;
-  const found = findWindows(lines.slice(bodyLine - 1), width, pin, void 0, {
-    around: toBodyLines(pageLines, bodyLine).start
-  });
-  return found.starts.map((start) => toFileLines({ start, end: start + width - 1 }, bodyLine)).filter((span) => span.start !== pageLines.start);
-}
-var NAMED_SPANS = 3;
-function spellElsewhere(spans) {
-  const first = spans[0];
-  const noun = spans.length === 1 && first !== void 0 && first.start === first.end ? "line" : "lines";
-  const named4 = spans.slice(0, NAMED_SPANS).map((span) => spellLines(span));
-  const rest = spans.length - named4.length;
-  if (rest > 0) return `${noun} ${named4.join(", ")} and ${String(rest)} more`;
-  const last = named4.pop() ?? "";
-  return named4.length === 0 ? `${noun} ${last}` : `${noun} ${named4.join(", ")} and ${last}`;
-}
 async function runAdd(opts) {
   const cwd = resolve4(opts.cwd ?? process.cwd());
   const run3 = await resolveCiteRun({
@@ -3821,8 +3972,8 @@ async function runAdd(opts) {
     if (unit === void 0 || pin === void 0) {
       throw new CiteError(`${at2} has no paragraph or block for a marker to anchor.`);
     }
-    for (const { index, lines: moved } of shifted.frontmatter) {
-      body = spliceEntryField(body, format, index, ["claim", "lines"], moved);
+    for (const { index: index2, lines: moved } of shifted.frontmatter) {
+      body = spliceEntryField(body, format, index2, ["claim", "lines"], moved);
     }
     claimSpan = unit;
     claim = { integrity: pin };
@@ -3878,18 +4029,20 @@ async function runAdd(opts) {
   }
   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, index) => {
-      const moved = shifted.manifest.get(index);
+    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)];
-    const at3 = await manifests.write(owner, sidecar.entry, list, list.length - 1);
+    index = list.length - 1;
+    const at3 = await manifests.write(owner, sidecar.entry, list, index);
     const [changed] = manifests.changed();
     placed = {
       file: at3.file,
@@ -3918,7 +4071,14 @@ async function runAdd(opts) {
   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) {
-    for (const changed of manifests.changed()) await writeFileAtomic(changed.path, changed.text);
+    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) {
@@ -4089,10 +4249,11 @@ async function runRemove(opts) {
     item.page.written = write;
   }
   const rewritten = [];
-  for (const changed of manifests.changed()) {
-    if (write) await writeFileAtomic(changed.path, changed.text);
+  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,
@@ -4111,10 +4272,14 @@ function sayNoUnit(reason) {
       return "the line is blank";
     case "fenced":
       return "the line sits inside a 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 settles(plan) {
@@ -4142,7 +4307,7 @@ function settles(plan) {
       return "";
   }
 }
-function apply(content, format, plan) {
+function apply2(content, format, plan) {
   const index = plan.result.origin.index;
   switch (plan.kind) {
     case "claim-moved":
@@ -4317,7 +4482,8 @@ function rewriteOf(plan) {
         fromPin: plan.pin,
         toPin: plan.would,
         at: plan.at,
-        commitSha: plan.commitSha
+        commitSha: plan.commitSha,
+        ...plan.wordShare === void 0 ? {} : { wordShare: plan.wordShare }
       };
     case "claim-shifted":
       return {
@@ -4383,12 +4549,17 @@ function rewriteOf(plan) {
     }
   }
 }
+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;
-  if (sharesSentence(claimWords(was, format), claimWords(text, format))) return void 0;
-  return commit;
+  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) {
@@ -4578,7 +4749,8 @@ async function runUpdate(opts) {
     if (claim !== null && claim.status === "changed" && entry !== void 0 && result.anchor !== "marker") {
       const held = claim.fileLines === void 0 ? void 0 : parseLines(claim.fileLines);
       const at2 = held?.start;
-      const unit = at2 === void 0 ? void 0 : unitAt(page, at2, lines, held);
+      const named4 = only !== void 0;
+      const unit = at2 === void 0 ? void 0 : unitAt(page, at2, lines, held, named4);
       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);
@@ -4588,7 +4760,7 @@ async function runUpdate(opts) {
           why: `Not re-pinned: the ${unit.kind} ${wide}.`
         });
       } else if (unit === void 0) {
-        const why = at2 === void 0 ? void 0 : noUnitAt(page, at2, lines, held);
+        const why = at2 === void 0 ? void 0 : noUnitAt(page, at2, lines, held, named4);
         if (why !== void 0) {
           declined.set(result.origin.index, {
             rule: "claim-changed",
@@ -4596,16 +4768,25 @@ async function runUpdate(opts) {
           });
         }
       } else if (pin !== void 0 && (!wantsBlock || unit.kind === "block")) {
+        const elsewhere = named4 ? [] : 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,
+            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;
@@ -4732,7 +4913,8 @@ async function runUpdate(opts) {
                   kind: "claim-replaced",
                   result,
                   at: now.span.start,
-                  commitSha: replaced,
+                  commitSha: replaced.commit,
+                  ...replaced.share === void 0 ? {} : { wordShare: replaced.share },
                   pin: recorded,
                   would: now.pin
                 }
@@ -4779,7 +4961,7 @@ async function runUpdate(opts) {
           if (!applyToEntry(held, plan)) continue;
           manifestDirty = true;
         } else {
-          after = apply(after, format, plan);
+          after = apply2(after, format, plan);
         }
         rewritten2.push(rewriteOf(plan));
         settled.add(`${String(result.origin.index)}\0${settles(plan)}`);
@@ -4833,20 +5015,25 @@ async function runUpdate(opts) {
     reports.push(await updateOne(file, await readTarget(run3, file), resolve6(run3.base, file)));
   }
   assertNoOrphanJoins(prepared, hits);
-  const changedManifests = manifests.changed();
+  const write = opts.dryRun !== true;
   const rewrittenManifests = [];
-  for (const changed of changedManifests) {
-    const write = opts.dryRun !== true;
-    if (write) {
-      try {
-        await writeFileAtomic(changed.path, changed.text);
-      } catch (error) {
+  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);
       }
-      writes.record(changed.path, changed.file, changed.before);
-    }
-    rewrittenManifests.push({ file: changed.file, diff: changed.diff, written: write });
-  }
+    });
+  } else for (const changed of manifests.changed()) record(changed);
   const reminted = pages.some(
     (page) => page.rewritten.some((r) => r.reason === "accepted" && r.end === "source")
   );
@@ -5260,7 +5447,12 @@ function movedSpan(rewrite) {
 }
 function refusalLine(rewrite) {
   const at2 = shortCommit(rewrite.commitSha ?? "");
-  return `claim at ${spellAtSpec(String(rewrite.at ?? 0))} skipped: that line now holds different text than the claim at ${at2}. Re-add it with cite add.`;
+  const where = `claim at ${spellAtSpec(String(rewrite.at ?? 0))} skipped:`;
+  if (rewrite.wordShare !== void 0) {
+    const share = Math.round(rewrite.wordShare * 100);
+    return `${where} that line now holds text sharing ${String(share)}% of the claim's words at ${at2}. Re-add it with cite add.`;
+  }
+  return `${where} that line now holds different text than the claim at ${at2}. Re-add it with cite add.`;
 }
 function rewriteLine(rewrite) {
   const word = rewrite.from.includes("-") ? "lines" : "line";
@@ -5922,4 +6114,4 @@ export {
   runKeyRotate,
   runKeySet
 };
-//# sourceMappingURL=chunk-O6RXG33V.js.map
+//# sourceMappingURL=chunk-WCNU53MJ.js.map