@hawkeyexl/manni 2.8.1 → 2.8.3

package/README.md

@@ -98,7 +98,7 @@ actually reads rather than hand-written:
 ```yaml
 repos:
   - repo: https://github.com/hawkeyexl/manni
-    rev: v2.8.1
+    rev: v2.8.3
     hooks:
       - id: manni-meta
 ```

package/dist/{chunk-FWB6LGBB.js → chunk-DGC4CCK3.js}

@@ -35,6 +35,7 @@ import {
   hasFrontmatterFence,
   hashLines,
   hashRange,
+  heldManifest,
   isEncryptedValue,
   isErrorSeverity,
   isIgnoredByGit,
@@ -55,11 +56,14 @@ import {
   pinOfLines,
   readConfigFile,
   readFamilyConfigFile,
+  readManifestValue,
+  rebaseable,
   removeManifestKey,
   resolveBaselineRequest,
   resolveEncryptionKey,
   resolveTargetSet,
   selectCollections,
+  settle,
   settleBaseline,
   sliceLines,
   spellLines,
@@ -71,7 +75,7 @@ import {
   withValueAt,
   writeEncryptionKey,
   writeFileAtomic
-} from "./chunk-RLHN765L.js";
+} from "./chunk-KGI7B6DD.js";
 
 // src/meta/core/reencrypt.ts
 import { extname } from "node:path";
@@ -151,15 +155,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)) {
@@ -2662,6 +2666,7 @@ function unifiedDiff(label, before, after) {
 }
 
 // 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. */
@@ -2675,7 +2680,7 @@ 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 = heldManifest(manifest.path, manifest.file, before);
     this.held.set(manifest.path, fresh);
     return fresh;
   }
@@ -2686,16 +2691,37 @@ var ManifestSet = class {
    */
   async write(manifest, entry, citations, index) {
     const held = await this.hold(manifest);
+    const op = {
+      kind: "splice",
+      entry,
+      key: CITATIONS_KEY2,
+      join: manifest.join,
+      file: manifest.file,
+      value: [...citations]
+    };
+    rebaseable(held, op, codec);
     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
@@ -2703,23 +2729,66 @@ 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,
+      key: CITATIONS_KEY2,
+      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 ?? 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, { 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);
@@ -3846,8 +3915,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 };
@@ -3903,18 +3972,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,
@@ -3943,7 +4014,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) {
@@ -4114,10 +4192,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,
@@ -4171,7 +4250,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":
@@ -4825,7 +4904,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)}`);
@@ -4879,20 +4958,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")
   );
@@ -5973,4 +6057,4 @@ export {
   runKeyRotate,
   runKeySet
 };
-//# sourceMappingURL=chunk-FWB6LGBB.js.map
+//# sourceMappingURL=chunk-DGC4CCK3.js.map