@hawkeyexl/manni 2.8.1 → 2.8.3

package/dist/{chunk-RLHN765L.js → chunk-KGI7B6DD.js}

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 // package.json
 var package_default = {
   name: "@hawkeyexl/manni",
-  version: "2.8.1",
+  version: "2.8.3",
   description: "One command line for documentation that is meant to be checked. `manni meta` validates the presence and format of document metadata (Markdown frontmatter and more) against JSON Schema, built for CI. Formerly docmeta.",
   type: "module",
   bin: {
@@ -393,8 +393,8 @@ function isMember(collection, relPath) {
   return !collection.exclude.some((glob) => matchesFileGlob(relPath, glob));
 }
 function normalizeEntry(entry) {
-  const posix4 = entry.replace(/\\/g, "/").replace(/^\.\//, "");
-  return posix4.endsWith("/") ? posix4.slice(0, -1) : posix4;
+  const posix5 = entry.replace(/\\/g, "/").replace(/^\.\//, "");
+  return posix5.endsWith("/") ? posix5.slice(0, -1) : posix5;
 }
 function isGlob(entry) {
   return picomatch2.scan(entry).isGlob;
@@ -5569,11 +5569,11 @@ function collectSchemaPins(config) {
 }
 function rebaseConfigSchemaRefs(config, configDir, cwd) {
   if (resolve(configDir) === resolve(cwd)) return config;
-  const rebase = (ref) => classifyRef(ref).kind === "file" && !isAbsolute(ref) ? resolve(configDir, ref) : ref;
-  const rebaseEntry = (entry) => typeof entry === "string" ? rebase(entry) : {
+  const rebase2 = (ref) => classifyRef(ref).kind === "file" && !isAbsolute(ref) ? resolve(configDir, ref) : ref;
+  const rebaseEntry = (entry) => typeof entry === "string" ? rebase2(entry) : {
     ...entry,
-    ref: rebase(entry.ref),
-    ...entry.source !== void 0 ? { source: rebase(entry.source) } : {}
+    ref: rebase2(entry.ref),
+    ...entry.source !== void 0 ? { source: rebase2(entry.source) } : {}
   };
   return {
     ...config,
@@ -5581,7 +5581,7 @@ function rebaseConfigSchemaRefs(config, configDir, cwd) {
     ...config.overrides ? {
       overrides: config.overrides.map((o) => ({
         ...o,
-        schemas: o.schemas.map(rebase)
+        schemas: o.schemas.map(rebase2)
       }))
     } : {}
   };
@@ -7012,12 +7012,12 @@ async function gitIgnored(paths, cwd) {
   return answered > 0 ? { ignored, available: true } : unavailable();
 }
 function checkIgnore(paths, cwd) {
-  return new Promise((settle) => {
+  return new Promise((settle2) => {
     let done = false;
     const finish2 = (answer) => {
       if (done) return;
       done = true;
-      settle(answer);
+      settle2(answer);
     };
     let child;
     try {
@@ -9323,12 +9323,12 @@ var MAX_OUTPUT_BYTES = 8 * 1024 * 1024;
 var BinMissing = class extends Error {
 };
 function run(bin, args, opts) {
-  return new Promise((settle, reject) => {
+  return new Promise((settle2, reject) => {
     let done = false;
     const finish2 = (r) => {
       if (done) return;
       done = true;
-      settle(r);
+      settle2(r);
     };
     const fail2 = (err) => {
       if (done) return;
@@ -11226,12 +11226,12 @@ function text(out) {
   }
 }
 function runGit(args, cwd, stdin, maxBytes) {
-  return new Promise((settle, reject) => {
+  return new Promise((settle2, reject) => {
     let done = false;
     const finish2 = (out) => {
       if (done) return;
       done = true;
-      settle(out);
+      settle2(out);
     };
     const fail2 = (err) => {
       if (done) return;
@@ -11769,6 +11769,20 @@ function spliceManifestValue(text2, options) {
   );
   return { text: out, line };
 }
+function readManifestValue(text2, options) {
+  const join11 = options.join ?? PATH_JOIN;
+  const doc = parseDocument5(text2, { uniqueKeys: false });
+  if (doc.errors.length > 0) return void 0;
+  const root = doc.contents;
+  if (!isMap5(root)) return void 0;
+  const same = join11 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
+  const pair = root.items.find((p) => same(keyString(p.key), options.entry));
+  const held = pair?.value;
+  if (!isMap5(held)) return void 0;
+  const kv = held.items.find((p) => keyString(p.key) === options.key);
+  const node = kv?.value;
+  return isNode2(node) ? node.toJSON() : void 0;
+}
 function removeManifestKey(text2, options) {
   const { entry, key, file } = options;
   const join11 = options.join ?? PATH_JOIN;
@@ -12349,17 +12363,17 @@ function bare(path) {
 }
 async function collectionPath(target, cwd, configDir) {
   if (target === STDIN_TOKEN) return void 0;
-  const posix4 = target.replace(/\\/g, "/");
-  const scanned = picomatch6.scan(posix4);
+  const posix5 = target.replace(/\\/g, "/");
+  const scanned = picomatch6.scan(posix5);
   if (scanned.isGlob) {
     const rel2 = toPosix3(relative11(configDir, resolve13(cwd, scanned.base === "" ? "." : scanned.base)));
     if (isAbsolute7(rel2) || rel2 === ".." || rel2.startsWith("../")) return void 0;
     return rel2 === "" ? scanned.glob : `${rel2}/${scanned.glob}`;
   }
-  const abs = resolve13(cwd, posix4);
+  const abs = resolve13(cwd, posix5);
   const rel = toPosix3(relative11(configDir, abs));
   if (isAbsolute7(rel) || rel.startsWith("..")) return void 0;
-  let directory = posix4.endsWith("/");
+  let directory = posix5.endsWith("/");
   if (!directory) {
     try {
       directory = (await stat5(abs)).isDirectory();
@@ -17116,7 +17130,7 @@ function skipExpression(sql, from) {
 }
 
 // src/meta/commands/fill.ts
-import { readFile as readFile13 } from "node:fs/promises";
+import { readFile as readFile14 } from "node:fs/promises";
 import { resolve as resolve19, extname as extname8, join as join10 } from "node:path";
 import {
   completeValidatedJSON,
@@ -17131,6 +17145,107 @@ import {
   InferenceError
 } from "@hawkeyexl/inference";
 
+// src/meta/core/manifest-writes.ts
+import { readFile as readFile13 } from "node:fs/promises";
+
+// src/shared/manifest-cas.ts
+import { posix as posix4 } from "node:path";
+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 heldManifest(path, file, before) {
+  return { path, file, before, text: before, ops: [], bases: /* @__PURE__ */ new Map() };
+}
+function encodeValue(value) {
+  return value === void 0 ? "absent" : JSON.stringify(value);
+}
+function baseKey(at2) {
+  const entry = at2.join === "path" ? posix4.normalize(at2.entry) : at2.entry;
+  return `${entry}\0${at2.key}`;
+}
+function rebaseable(held, op, codec) {
+  const at2 = baseKey(op);
+  if (held.bases.has(at2)) return;
+  held.bases.set(at2, {
+    entry: op.entry,
+    key: op.key,
+    join: op.join,
+    value: encodeValue(codec.read(held.before, op))
+  });
+}
+function rebase(held, current, codec) {
+  for (const base of held.bases.values()) {
+    if (encodeValue(codec.read(current, base)) !== base.value) return void 0;
+  }
+  let text2 = current;
+  for (const op of held.ops) text2 = codec.apply(text2, op);
+  return text2;
+}
+function rebaseline(held) {
+  held.before = held.text;
+  held.ops = [];
+  held.bases.clear();
+}
+async function settle(held, io) {
+  for (let attempt = 1; attempt <= COMMIT_ATTEMPTS; attempt++) {
+    let current;
+    try {
+      current = await io.read(held.path);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw io.toError(`Manifest ${held.file} could not be read: ${reason}`);
+    }
+    if (current === held.before) {
+      await io.write(held.path, held.text);
+      return;
+    }
+    const replayed = rebase(held, current, io.codec);
+    if (replayed === void 0) throw io.toError(conflictRefusal(held.file));
+    held.before = current;
+    held.text = replayed;
+  }
+  throw io.toError(conflictRefusal(held.file));
+}
+
+// src/meta/core/manifest-writes.ts
+var manifestCodec = {
+  apply(text2, op) {
+    const where = { entry: op.entry, key: op.key, join: op.join, file: op.file };
+    return op.kind === "remove" ? removeManifestKey(text2, where).text : spliceManifestValue(text2, { ...where, value: op.value }).text;
+  },
+  read(text2, at2) {
+    return readManifestValue(text2, at2);
+  }
+};
+function applyManifestOp(text2, op) {
+  return manifestCodec.apply(text2, op);
+}
+async function holdManifestFile(path, file) {
+  let before;
+  try {
+    before = await readFile13(path, "utf8");
+  } catch (err) {
+    throw new DocmetaError(`Manifest ${file} could not be read: ${errorMessage(err)}`);
+  }
+  return heldManifest(path, file, before);
+}
+function recordManifestOp(held, op) {
+  rebaseable(held, op, manifestCodec);
+  held.ops.push(op);
+}
+async function settleManifest(held, io = {}) {
+  if (held.text === held.before) return false;
+  await settle(held, {
+    codec: manifestCodec,
+    write: io.write ?? writeFileAtomic,
+    read: io.read ?? ((at2) => readFile13(at2, "utf8")),
+    toError: (message) => new DocmetaError(message)
+  });
+  rebaseline(held);
+  return true;
+}
+
 // src/meta/commands/fill-prompt.ts
 var FILL_PROMPT_VERSION = 4;
 var DEFAULT_CHUNK_CHARS = 12e3;
@@ -17430,28 +17545,34 @@ async function runFill(opts) {
   });
   const heldManifests = /* @__PURE__ */ new Map();
   const holding = /* @__PURE__ */ new Map();
-  const saveManifest = (held) => {
-    held.saving = held.saving.then(async () => {
-      const text2 = held.text;
-      if (text2 === held.written) return;
-      await writeFileAtomic(held.path, text2);
-      held.written = text2;
+  const saveManifest = (h, ops) => {
+    h.saving = h.saving.then(async () => {
+      for (const op of ops) {
+        const after = applyManifestOp(h.held.text, op);
+        if (after === h.held.text) continue;
+        recordManifestOp(h.held, op);
+        h.held.text = after;
+      }
+      if (!dryRun) await settleManifest(h.held);
     });
-    return held.saving;
+    return h.saving;
+  };
+  const restorePage = async (label, before) => {
+    try {
+      await writeFileAtomic(resolve19(base, label), before);
+      return `${label} was restored.`;
+    } catch (err) {
+      return `${label} could not be restored: ${errorMessage(err)}. Restore it from version control.`;
+    }
   };
   const holdManifest = (home) => {
     let held = holding.get(home.absPath);
     if (held === void 0) {
-      held = readFile13(home.absPath, "utf8").then(
-        (before) => {
-          const h = { path: home.absPath, text: before, written: before, saving: Promise.resolve() };
-          heldManifests.set(home.absPath, h);
-          return h;
-        },
-        (err) => {
-          throw new DocmetaError(`Manifest ${home.file} could not be read: ${errorMessage(err)}`);
-        }
-      );
+      held = holdManifestFile(home.absPath, home.file).then((m) => {
+        const h = { held: m, saving: Promise.resolve() };
+        heldManifests.set(home.absPath, h);
+        return h;
+      });
       holding.set(home.absPath, held);
     }
     return held;
@@ -17953,52 +18074,54 @@ async function runFill(opts) {
       metaProvenance = { written: false, skipReason: "unwritable" };
     }
     const helds = await Promise.all(entryWrites.map((w) => holdManifest(w.home)));
-    const splice = () => {
-      const texts = /* @__PURE__ */ new Map();
-      for (const [i, w] of entryWrites.entries()) {
-        const held = helds[i];
-        if (held === void 0) continue;
-        const text2 = texts.get(held.path) ?? held.text;
-        texts.set(
-          held.path,
-          spliceManifestValue(text2, {
-            entry: w.home.entry,
-            key: w.key,
-            value: w.value,
-            join: w.home.join,
-            file: w.home.file
-          }).text
-        );
-      }
-      return texts;
-    };
+    const ops = [];
+    for (const [i, w] of entryWrites.entries()) {
+      const at2 = helds[i];
+      if (at2 === void 0) continue;
+      ops.push({
+        at: at2,
+        op: {
+          kind: "splice",
+          entry: w.home.entry,
+          key: w.key,
+          value: w.value,
+          join: w.home.join,
+          file: w.home.file
+        }
+      });
+    }
     let manifestChanged = false;
     try {
-      manifestChanged = [...splice()].some(([path, text2]) => heldManifests.get(path)?.text !== text2);
+      const texts = /* @__PURE__ */ new Map();
+      for (const { at: at2, op } of ops) {
+        texts.set(at2.held.path, applyManifestOp(texts.get(at2.held.path) ?? at2.held.text, op));
+      }
+      manifestChanged = [...texts].some(([path, text2]) => heldManifests.get(path)?.held.text !== text2);
     } catch (err) {
       if (!(err instanceof DocmetaError)) throw err;
       return errorResult(label, extractor.name, err.message, schemaSet, fields);
     }
     const changed = next !== content || manifestChanged;
-    if (next !== content && !dryRun && label !== "<stdin>") {
+    const pageWritten = next !== content && !dryRun && label !== "<stdin>";
+    if (pageWritten) {
       await writeFileAtomic(resolve19(base, label), next);
     }
     if (manifestChanged) {
-      let texts;
+      const perManifest = /* @__PURE__ */ new Map();
+      for (const { at: at2, op } of ops) {
+        const list2 = perManifest.get(at2);
+        if (list2 === void 0) perManifest.set(at2, [op]);
+        else list2.push(op);
+      }
+      const saves = [...perManifest].map(([at2, list2]) => saveManifest(at2, list2));
       try {
-        texts = splice();
+        await Promise.all(saves);
       } catch (err) {
-        if (!(err instanceof DocmetaError)) throw err;
-        return errorResult(label, extractor.name, err.message, schemaSet, fields);
-      }
-      const saves = [];
-      for (const [path, text2] of texts) {
-        const held = heldManifests.get(path);
-        if (held === void 0 || held.text === text2) continue;
-        held.text = text2;
-        if (!dryRun) saves.push(saveManifest(held));
+        if (!pageWritten) throw err;
+        const note = await restorePage(label, content);
+        if (err instanceof DocmetaError) throw new DocmetaError(`${err.message} ${note}`);
+        throw err;
       }
-      await Promise.all(saves);
     }
     return {
       file: label,
@@ -18013,7 +18136,7 @@ async function runFill(opts) {
   const prepareAll = async () => ({
     stdin: usingStdin ? await prepareOne("<stdin>", opts.stdinContent ?? "", forcedExtractor?.extensions[0] ?? "") : void 0,
     files: await mapConcurrent(files, concurrency, async (file) => {
-      const content = await readFile13(resolve19(base, file), "utf8");
+      const content = await readFile14(resolve19(base, file), "utf8");
       return prepareOne(file, content, extname8(file));
     })
   });
@@ -18037,7 +18160,7 @@ async function runFill(opts) {
   const results = [];
   if (prepared.stdin !== void 0) results.push(await finish2(prepared.stdin));
   results.push(...await mapConcurrent(prepared.files, concurrency, finish2));
-  await Promise.all([...heldManifests.values()].map((held) => held.saving));
+  await Promise.all([...heldManifests.values()].map((h) => h.saving));
   if (flagged.length > 0) {
     const landed = flagged.filter((w) => {
       const r = results.find((x) => x.file === w.label);
@@ -18442,7 +18565,7 @@ async function mapConcurrent(items2, limit, fn) {
 }
 
 // src/meta/commands/derive.ts
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 import { extname as extname9, relative as relative14, resolve as resolve20, sep as sep10 } from "node:path";
 var GENERATED_BY_ENV = "MANNI_GENERATED_BY";
 var SOURCE_HINT = "narrow --sources or --fields";
@@ -18588,7 +18711,7 @@ async function runDerive(opts) {
         });
         continue;
       }
-      const content = await readFile14(absPath, "utf8");
+      const content = await readFile15(absPath, "utf8");
       const elements = resolveElements(label, config, membersFor(label));
       try {
         loaded2.set(label, {
@@ -18809,24 +18932,13 @@ async function runDerive(opts) {
   const holdManifest = async (manifest) => {
     const already = heldManifests.get(manifest.absPath);
     if (already !== void 0) return already;
-    let before;
-    try {
-      before = await readFile14(manifest.absPath, "utf8");
-    } catch (err) {
-      throw new DocmetaError(`Manifest ${manifest.file} could not be read: ${errorMessage(err)}`);
-    }
-    const held = { path: manifest.absPath, written: before, text: before };
+    const held = await holdManifestFile(manifest.absPath, manifest.file);
     heldManifests.set(manifest.absPath, held);
     return held;
   };
   const results = [];
   const saveManifests = async () => {
-    for (const held of heldManifests.values()) {
-      if (held.text !== held.written) {
-        await writeFileAtomic(held.path, held.text);
-        held.written = held.text;
-      }
-    }
+    for (const held of heldManifests.values()) await settleManifest(held);
   };
   let settled = false;
   try {
@@ -18903,12 +19015,15 @@ async function runDerive(opts) {
       }
       let changed = false;
       const staged = /* @__PURE__ */ new Map();
-      const stage = async (manifest, edit) => {
+      const stagedOps = [];
+      const stage = async (manifest, op) => {
         const held = await holdManifest(manifest);
         const before = staged.get(held.path) ?? held.text;
-        const after = edit(before);
+        const after = applyManifestOp(before, op);
         staged.set(held.path, after);
-        return after !== before;
+        if (after === before) return false;
+        stagedOps.push({ held, op });
+        return true;
       };
       const manifestWritten = [];
       const entryWritten = [];
@@ -18917,7 +19032,7 @@ async function runDerive(opts) {
         const plan = toManifest.judged.plan;
         const edited = await stage(
           place.manifest,
-          (text2) => plan.length === 0 ? removeManifestKey(text2, where).text : spliceManifestValue(text2, { ...where, value: plan }).text
+          plan.length === 0 ? { ...where, kind: "remove" } : { ...where, kind: "splice", value: plan }
         );
         if (edited) {
           changed = true;
@@ -18927,16 +19042,14 @@ async function runDerive(opts) {
       try {
         for (const { f, home, entry } of toEntries) {
           const value = isMarked(f.field) ? await sealField(f.field, f.derived, marks.marked) : f.derived;
-          const edited = await stage(
-            home,
-            (text2) => spliceManifestValue(text2, {
-              entry,
-              key: f.field,
-              value,
-              join: home.join,
-              file: home.file
-            }).text
-          );
+          const edited = await stage(home, {
+            kind: "splice",
+            entry,
+            key: f.field,
+            value,
+            join: home.join,
+            file: home.file
+          });
           if (edited) {
             changed = true;
             manifestWritten.push(f);
@@ -18999,6 +19112,7 @@ async function runDerive(opts) {
           }
         }
       }
+      for (const { held, op } of stagedOps) recordManifestOp(held, op);
       for (const [path, text2] of staged) {
         const held = heldManifests.get(path);
         if (held !== void 0) held.text = text2;
@@ -19881,6 +19995,7 @@ export {
   orphanJoins,
   orphanError,
   spliceManifestValue,
+  readManifestValue,
   removeManifestKey,
   LOCATION_KEYWORD,
   LOCATION_EXTERNAL_SCHEMA,
@@ -19929,6 +20044,9 @@ export {
   runVendorSchema,
   runInferSchema,
   runQuery,
+  heldManifest,
+  rebaseable,
+  settle,
   runFill,
   runDerive,
   deriveFailed,
@@ -19947,4 +20065,4 @@ export {
   renderQuery,
   renderQueryCsv
 };
-//# sourceMappingURL=chunk-RLHN765L.js.map
+//# sourceMappingURL=chunk-KGI7B6DD.js.map