@hawkeyexl/manni 2.8.2 → 2.8.4

package/dist/{chunk-KEW557TN.js → chunk-XHH5OSQQ.js}

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 // package.json
 var package_default = {
   name: "@hawkeyexl/manni",
-  version: "2.8.2",
+  version: "2.8.4",
   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;
@@ -2731,15 +2731,66 @@ function listFormats() {
 }
 
 // src/meta/core/write-file.ts
-import { writeFile, rename, rm, stat, chmod } from "node:fs/promises";
-import { dirname, join, basename } from "node:path";
+import { writeFile, rename, rm, stat as stat2, chmod } from "node:fs/promises";
+import { dirname, join, basename, resolve } from "node:path";
+
+// src/meta/core/manifest-cache.ts
+import { stat } from "node:fs/promises";
+var caches = /* @__PURE__ */ new Set();
+function register(cache) {
+  caches.add(new WeakRef(cache));
+}
+function invalidateManifestCache(path) {
+  for (const ref of caches) {
+    const cache = ref.deref();
+    if (cache === void 0) caches.delete(ref);
+    else cache.drop(path);
+  }
+}
+async function signature(path) {
+  try {
+    const info = await stat(path);
+    return { mtimeMs: info.mtimeMs, size: info.size };
+  } catch {
+    return null;
+  }
+}
+var same = (a, b) => a.mtimeMs === b.mtimeMs && a.size === b.size;
+var ManifestCache = class {
+  slots = /* @__PURE__ */ new Map();
+  constructor() {
+    register(this);
+  }
+  drop(path) {
+    this.slots.delete(path);
+  }
+  /** The cached parse of `path` under `variant`, or `compute()`'s result. */
+  async parse(path, variant, compute) {
+    const before = await signature(path);
+    if (before === null) return compute();
+    const slot = this.slots.get(path);
+    if (slot !== void 0 && same(slot.sig, before)) {
+      const hit = slot.variants.get(variant);
+      if (hit !== void 0) return hit;
+    }
+    const parsed2 = await compute();
+    const after = await signature(path);
+    if (after === null || !same(before, after)) return parsed2;
+    const live = this.slots.get(path);
+    if (live !== void 0 && same(live.sig, after)) live.variants.set(variant, parsed2);
+    else this.slots.set(path, { sig: after, variants: /* @__PURE__ */ new Map([[variant, parsed2]]) });
+    return parsed2;
+  }
+};
+
+// src/meta/core/write-file.ts
 var LOCKED = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
 var RENAME_ATTEMPTS = 3;
 function errorCode(err) {
   return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
 }
-var wait = (ms) => new Promise((resolve21) => {
-  setTimeout(resolve21, ms);
+var wait = (ms) => new Promise((resolve22) => {
+  setTimeout(resolve22, ms);
 });
 async function writeFileAtomic(path, contents) {
   const tmp = join(
@@ -2749,7 +2800,7 @@ async function writeFileAtomic(path, contents) {
   try {
     await writeFile(tmp, contents);
     try {
-      const { mode } = await stat(path);
+      const { mode } = await stat2(path);
       await chmod(tmp, mode);
     } catch {
     }
@@ -2776,12 +2827,13 @@ async function writeFileAtomic(path, contents) {
     }
   } finally {
     await rm(tmp, { force: true });
+    invalidateManifestCache(resolve(path));
   }
 }
 
 // src/meta/core/schema-cache.ts
 import { createHash as createHash2 } from "node:crypto";
-import { mkdir, readFile, stat as stat2 } from "node:fs/promises";
+import { mkdir, readFile, stat as stat3 } from "node:fs/promises";
 import { join as join2 } from "node:path";
 var SCHEMA_CACHE_DIR = ".manni/meta/schema-cache";
 var SCHEMA_CACHE_VERSION = 1;
@@ -2828,7 +2880,7 @@ var SchemaCache = class {
     if (options.ignoreTtl !== true) {
       let mtimeMs;
       try {
-        ({ mtimeMs } = await stat2(file));
+        ({ mtimeMs } = await stat3(file));
       } catch {
         return null;
       }
@@ -5292,8 +5344,8 @@ var SCHEMA_KEYS = [
   "multipleOf"
 ];
 var RETRY_DELAY_MS = 500;
-var wait2 = (ms) => new Promise((resolve21) => {
-  setTimeout(resolve21, ms);
+var wait2 = (ms) => new Promise((resolve22) => {
+  setTimeout(resolve22, ms);
 });
 var RetryableFetchError = class extends DocmetaError {
 };
@@ -5546,7 +5598,7 @@ async function loadSchema(ref, options = {}) {
 }
 
 // src/meta/core/resolve-schema.ts
-import { isAbsolute, relative, resolve } from "node:path";
+import { isAbsolute, relative, resolve as resolve2 } from "node:path";
 var DEFAULT_SCHEMAS = Object.freeze([
   "google:okf:0.1",
   "passo-uno:seven-action:1.0"
@@ -5568,12 +5620,12 @@ function collectSchemaPins(config) {
   return pins;
 }
 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) : {
+  if (resolve2(configDir) === resolve2(cwd)) return config;
+  const rebase2 = (ref) => classifyRef(ref).kind === "file" && !isAbsolute(ref) ? resolve2(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 +5633,7 @@ function rebaseConfigSchemaRefs(config, configDir, cwd) {
     ...config.overrides ? {
       overrides: config.overrides.map((o) => ({
         ...o,
-        schemas: o.schemas.map(rebase)
+        schemas: o.schemas.map(rebase2)
       }))
     } : {}
   };
@@ -5645,7 +5697,7 @@ function assertDocumentRefAllowed(ref, mode, params) {
   }
   const root = params.trustRoot;
   if (!root) return;
-  const abs = resolve(params.fileBase ?? process.cwd(), ref);
+  const abs = resolve2(params.fileBase ?? process.cwd(), ref);
   const within = relative(root.dir, abs);
   if (within !== "" && !within.startsWith("..") && !isAbsolute(within)) return;
   const boundary = root.source === "git" ? `the repository root (${root.dir})` : root.source === "config" ? `${root.dir} \u2014 no git repository was found, so the config file's own directory is the boundary` : `${root.dir} \u2014 no git repository and no config file were found, so the directory the command was run from is the boundary`;
@@ -5797,12 +5849,12 @@ function isPlainObject(v) {
 }
 
 // src/meta/core/config.ts
-import { resolve as resolve5 } from "node:path";
+import { resolve as resolve6 } from "node:path";
 import { parse as parseYaml2 } from "yaml";
 
 // src/shared/config-file.ts
 import { readFile as readFile3 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname3, join as join4, relative as relative2, resolve as resolve4 } from "node:path";
+import { basename as basename2, dirname as dirname3, join as join4, relative as relative2, resolve as resolve5 } from "node:path";
 import { parse as parseYaml } from "yaml";
 
 // src/shared/encryption.ts
@@ -5933,9 +5985,9 @@ function keyedPin(text2, key) {
 
 // src/shared/git-root.ts
 import { existsSync } from "node:fs";
-import { dirname as dirname2, join as join3, resolve as resolve2 } from "node:path";
+import { dirname as dirname2, join as join3, resolve as resolve3 } from "node:path";
 function findGitRoot(cwd) {
-  let dir = resolve2(cwd);
+  let dir = resolve3(cwd);
   for (; ; ) {
     if (existsSync(join3(dir, ".git"))) return dir;
     const parent = dirname2(dir);
@@ -5944,7 +5996,7 @@ function findGitRoot(cwd) {
   }
 }
 function searchPath(cwd) {
-  const start = resolve2(cwd);
+  const start = resolve3(cwd);
   const root = findGitRoot(start);
   if (root === null) return [start];
   const chain = [];
@@ -5959,7 +6011,7 @@ function searchPath(cwd) {
 }
 
 // src/shared/tools.ts
-import { isAbsolute as isAbsolute2, resolve as resolve3 } from "node:path";
+import { isAbsolute as isAbsolute2, resolve as resolve4 } from "node:path";
 var TOOL_KEYS = ["vale"];
 var VALE_KEYS = ["config"];
 function isMapping2(value) {
@@ -6004,7 +6056,7 @@ function parseVale(raw, source, toError) {
 function valeConfigPath(tools, configDir) {
   const config = tools.vale?.config;
   if (config === void 0) return void 0;
-  return isAbsolute2(config) ? config : resolve3(configDir, config);
+  return isAbsolute2(config) ? config : resolve4(configDir, config);
 }
 
 // src/shared/warn.ts
@@ -6119,7 +6171,7 @@ var FAMILY_FILES = [
   { names: MOOSE_CONFIG_NAMES, kind: "moose" }
 ];
 async function findConfigFile(cwd, opts) {
-  const start = resolve4(cwd);
+  const start = resolve5(cwd);
   for (const dir of searchPath(start)) {
     for (const { names, kind } of FAMILY_FILES) {
       for (const name2 of names) {
@@ -6167,7 +6219,7 @@ async function findConfigFile(cwd, opts) {
   return null;
 }
 async function readConfigFile(explicitPath, cwd, opts) {
-  const path = resolve4(cwd, explicitPath);
+  const path = resolve5(cwd, explicitPath);
   const document = await readDocument(path, explicitPath, opts.toError);
   if (document === null) {
     throw opts.toError(`Config file not found: "${explicitPath}".`);
@@ -6191,7 +6243,7 @@ async function readConfigFile(explicitPath, cwd, opts) {
   };
 }
 async function findFamilyConfigFile(cwd, toError) {
-  const start = resolve4(cwd);
+  const start = resolve5(cwd);
   for (const dir of searchPath(start)) {
     for (const { names, kind } of FAMILY_FILES) {
       for (const name2 of names) {
@@ -6218,7 +6270,7 @@ async function findFamilyConfigFile(cwd, toError) {
   return null;
 }
 async function readFamilyConfigFile(explicitPath, cwd, toError) {
-  const path = resolve4(cwd, explicitPath);
+  const path = resolve5(cwd, explicitPath);
   const document = await readDocument(path, explicitPath, toError);
   if (document === null) {
     throw toError(`Config file not found: "${explicitPath}".`);
@@ -6887,8 +6939,8 @@ function parseFill(value, source) {
 function schemaTrustRoot(cwd, configDir) {
   const git2 = findGitRoot(cwd);
   if (git2 !== null) return { dir: git2, source: "git" };
-  if (configDir !== void 0) return { dir: resolve5(configDir), source: "config" };
-  return { dir: resolve5(cwd), source: "cwd" };
+  if (configDir !== void 0) return { dir: resolve6(configDir), source: "config" };
+  return { dir: resolve6(cwd), source: "cwd" };
 }
 async function loadConfig(explicitPath, cwd = process.cwd()) {
   const file = explicitPath ? await readConfigFile(explicitPath, cwd, CONFIG_FILE) : await findConfigFile(cwd, CONFIG_FILE);
@@ -6957,17 +7009,17 @@ import { isAbsolute as isAbsolute3 } from "node:path";
 import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
-import { relative as relative5, resolve as resolve8 } from "node:path";
+import { relative as relative5, resolve as resolve9 } from "node:path";
 
 // src/meta/core/load-files.ts
-import { stat as stat3 } from "node:fs/promises";
-import { extname, relative as relative4, resolve as resolve7 } from "node:path";
+import { stat as stat4 } from "node:fs/promises";
+import { extname, relative as relative4, resolve as resolve8 } from "node:path";
 import fg from "fast-glob";
 import picomatch3 from "picomatch";
 
 // src/meta/core/gitignore.ts
 import { spawn } from "node:child_process";
-import { dirname as dirname4, relative as relative3, resolve as resolve6, sep } from "node:path";
+import { dirname as dirname4, relative as relative3, resolve as resolve7, sep } from "node:path";
 var GITIGNORE_UNAVAILABLE = ".gitignore filtering was requested but git could not answer here (no repository, or no git on PATH); no files were skipped.";
 var unavailable = () => ({
   ignored: /* @__PURE__ */ new Set(),
@@ -6981,7 +7033,7 @@ async function gitIgnored(paths, cwd) {
   const byRoot = /* @__PURE__ */ new Map();
   let inSomeRepo = false;
   for (const spelled of paths) {
-    const abs = resolve6(cwd, spelled);
+    const abs = resolve7(cwd, spelled);
     const dir = dirname4(abs);
     let root = rootOf.get(dir);
     if (root === void 0) {
@@ -7012,12 +7064,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 {
@@ -7063,7 +7115,7 @@ function toPosix(p) {
 }
 async function statOrNull(p) {
   try {
-    return await stat3(p);
+    return await stat4(p);
   } catch {
     return null;
   }
@@ -7093,7 +7145,7 @@ async function resolveTargetSet(opts) {
   for (const input of opts.inputs) {
     if (input === STDIN_TOKEN) continue;
     const posixInput = toPosix(input);
-    const abs = resolve7(cwd, posixInput);
+    const abs = resolve8(cwd, posixInput);
     const st = await statOrNull(abs);
     if (st?.isFile()) {
       named.add(toPosix(relative4(cwd, abs)));
@@ -7178,12 +7230,12 @@ var FINGERPRINT_RE = /^[0-9a-f]{16}$/;
 function canonicalFilePath(file, ctx) {
   if (!ctx) return file;
   const from = ctx.runBase ?? ctx.base;
-  return relative5(ctx.base, resolve8(from, file)).replace(/\\/g, "/");
+  return relative5(ctx.base, resolve9(from, file)).replace(/\\/g, "/");
 }
 function canonicalSchemaRef(ref, ctx) {
   if (!ctx) return ref;
   if (classifyRef(ref).kind !== "file") return ref;
-  const abs = resolve8(ctx.cwd, ref);
+  const abs = resolve9(ctx.cwd, ref);
   return relative5(ctx.base, abs).replace(/\\/g, "/");
 }
 function fingerprint(e, ctx) {
@@ -7341,17 +7393,17 @@ function countFingerprints(baseline) {
 }
 function resolveBaselineRequest(opts, configured, configDir, cwd, defaults) {
   const named = (label) => ({
-    absPath: resolve8(cwd, label),
+    absPath: resolve9(cwd, label),
     label
   });
   const implied = () => {
     const base = configDir ?? cwd;
     if (configured !== void 0) {
-      return { absPath: resolve8(base, configured), label: configured };
+      return { absPath: resolve9(base, configured), label: configured };
     }
-    const current = resolve8(base, defaults.current);
+    const current = resolve9(base, defaults.current);
     if (defaults.legacy !== void 0) {
-      const legacy = resolve8(base, defaults.legacy);
+      const legacy = resolve9(base, defaults.legacy);
       if (!existsSync2(current) && existsSync2(legacy)) {
         warn(
           `"${defaults.legacy}" is the pre-rename baseline file name. Rename it to "${defaults.current}".`
@@ -7858,7 +7910,7 @@ async function readCapped(url, res, maxBytes) {
 
 // src/meta/core/external-metadata.ts
 import { readFile as readFile6 } from "node:fs/promises";
-import { isAbsolute as isAbsolute4, relative as relative7, resolve as resolve10, sep as sep2 } from "node:path";
+import { isAbsolute as isAbsolute4, relative as relative7, resolve as resolve11, sep as sep2 } from "node:path";
 import {
   LineCounter as LineCounter2,
   isMap as isMap4,
@@ -7871,20 +7923,20 @@ import {
 // src/shared/encryption-key.ts
 import { spawnSync } from "node:child_process";
 import { readFile as readFile5 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname6, join as join6, relative as relative6, resolve as resolve9 } from "node:path";
+import { basename as basename4, dirname as dirname6, join as join6, relative as relative6, resolve as resolve10 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { isMap as isMap3, parseDocument as parseDocument3, parse as parseYaml3, stringify } from "yaml";
 
 // src/shared/write-file.ts
-import { chmod as chmod2, rename as rename2, rm as rm2, stat as stat4, writeFile as writeFile2 } from "node:fs/promises";
+import { chmod as chmod2, rename as rename2, rm as rm2, stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
 import { basename as basename3, dirname as dirname5, join as join5 } from "node:path";
 var LOCKED2 = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
 var RENAME_ATTEMPTS2 = 3;
 function errorCode2(err) {
   return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
 }
-var wait3 = (ms) => new Promise((resolve21) => {
-  setTimeout(resolve21, ms);
+var wait3 = (ms) => new Promise((resolve22) => {
+  setTimeout(resolve22, ms);
 });
 async function writeTextAtomic(path, text2) {
   const tmp = join5(
@@ -7894,7 +7946,7 @@ async function writeTextAtomic(path, text2) {
   try {
     await writeFile2(tmp, text2, "utf8");
     try {
-      const { mode } = await stat4(path);
+      const { mode } = await stat5(path);
       await chmod2(tmp, mode);
     } catch {
     }
@@ -7933,7 +7985,7 @@ function resolveEncryptionKey(opts) {
   return { key: void 0, source: "none" };
 }
 function relativeSource2(cwd, path) {
-  return relative6(resolve9(cwd), path).replace(/\\/g, "/");
+  return relative6(resolve10(cwd), path).replace(/\\/g, "/");
 }
 function errorCode3(err) {
   return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
@@ -7956,7 +8008,7 @@ async function fileTarget(file, toError) {
   return { path: file.path, source: file.source, text: text2 ?? file.text };
 }
 async function defaultTarget(cwd) {
-  const root = findGitRoot(cwd) ?? resolve9(cwd);
+  const root = findGitRoot(cwd) ?? resolve10(cwd);
   for (const name2 of [...FAMILY_CONFIG_NAMES, ...MOOSE_CONFIG_NAMES]) {
     const path2 = join6(root, name2);
     const text2 = await readIfPresent(path2);
@@ -8242,11 +8294,15 @@ var EXTERNAL_OWNED_SCHEMA = "external:owned";
 var EXTERNAL_DUPLICATE_SCHEMA = "external:duplicate";
 var EXTERNAL_KEYWORD = "external";
 var PATH_JOIN = "path";
+var parsedManifests = new ManifestCache();
 var posix = (p) => p.split(sep2).join("/");
 function reportedPath(abs, base) {
   const rel = relative7(base, abs);
   return rel === "" ? "." : posix(rel);
 }
+function reported(of, file) {
+  return of.file === file ? of : { ...of, file };
+}
 function externalMetadataJoin(manifest) {
   return manifest.join ?? PATH_JOIN;
 }
@@ -8260,27 +8316,56 @@ async function loadExternalMetadata(collections, opts) {
   const byField = /* @__PURE__ */ new Map();
   const entries = [];
   for (const { collection, manifest } of configured) {
-    let text2;
+    const join11 = externalMetadataJoin(manifest);
+    let parsed2;
     let file;
     if (classifyRef(manifest.file).kind === "url") {
       file = manifest.file;
-      text2 = await fetchExternalMetadata(manifest.file, {
+      const text2 = await fetchExternalMetadata(manifest.file, {
         ...manifest.tokenEnv !== void 0 ? { tokenEnv: manifest.tokenEnv } : {},
         ...opts.offline !== void 0 ? { offline: opts.offline } : {},
         ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
         ...opts.env !== void 0 ? { env: opts.env } : {}
       });
+      parsed2 = parseManifest(manifest, collection, text2, file, opts.configDir, join11);
     } else {
-      const abs = isAbsolute4(manifest.file) ? manifest.file : resolve10(opts.configDir, manifest.file);
-      file = reportedPath(abs, opts.base);
-      text2 = await readManifest(abs, file);
+      const abs = isAbsolute4(manifest.file) ? manifest.file : resolve11(opts.configDir, manifest.file);
+      const label = reportedPath(abs, opts.base);
+      file = label;
+      parsed2 = await parsedManifests.parse(
+        abs,
+        // The keys are sorted because they reach the variant as an array, and
+        // two declarations that own the same keys in a different order parse
+        // to the same thing.
+        //
+        // `label` is deliberately not part of this. It is the manifest as this
+        // run reports it, which is a function of the run's base rather than of
+        // the bytes, so two runs over one corpus from two directories parse
+        // identically and differ only in a string each value carries. Keying
+        // on it would miss the cache for exactly the runs that share a
+        // process, which is what a test suite is. The copy-in below writes
+        // this run's spelling onto every value and entry instead.
+        JSON.stringify([
+          collection,
+          join11,
+          opts.configDir,
+          [...manifest.keys].sort()
+        ]),
+        async () => parseManifest(
+          manifest,
+          collection,
+          await readManifest(abs, label),
+          label,
+          opts.configDir,
+          join11
+        )
+      );
     }
     for (const key of manifest.keys) {
       const list2 = owners.get(key);
       if (list2) list2.push({ collection, file });
       else owners.set(key, [{ collection, file }]);
     }
-    const join11 = externalMetadataJoin(manifest);
     let target;
     if (join11 === PATH_JOIN) {
       target = byPath;
@@ -8292,16 +8377,12 @@ async function loadExternalMetadata(collections, opts) {
         byField.set(join11, target);
       }
     }
-    parseManifest(
-      manifest,
-      collection,
-      text2,
-      file,
-      opts.configDir,
-      join11,
-      target,
-      entries
-    );
+    for (const [indexKey, values] of parsed2.values) {
+      const into = target.get(indexKey) ?? /* @__PURE__ */ new Map();
+      for (const [key, value] of values) into.set(key, reported(value, file));
+      target.set(indexKey, into);
+    }
+    for (const entry of parsed2.entries) entries.push(reported(entry, file));
   }
   return { owners, byPath, byField, entries };
 }
@@ -8315,7 +8396,9 @@ async function readManifest(abs, file) {
     );
   }
 }
-function parseManifest(manifest, collection, text2, file, configDir, join11, target, entries) {
+function parseManifest(manifest, collection, text2, file, configDir, join11) {
+  const target = /* @__PURE__ */ new Map();
+  const entries = [];
   const lc = new LineCounter2();
   const doc = parseDocument4(text2, { lineCounter: lc, uniqueKeys: false });
   const problem = doc.errors[0];
@@ -8325,7 +8408,8 @@ function parseManifest(manifest, collection, text2, file, configDir, join11, tar
     );
   }
   const root = doc.contents;
-  if (root === null || isScalar2(root) && root.value === null) return;
+  if (root === null || isScalar2(root) && root.value === null)
+    return { values: target, entries };
   if (!isMap4(root)) {
     throw new DocmetaError(
       `Manifest ${file}: the manifest must be a mapping from document ${join11 === PATH_JOIN ? "path" : `"${join11}"`} to owned keys.`
@@ -8353,7 +8437,7 @@ function parseManifest(manifest, collection, text2, file, configDir, join11, tar
         `Manifest ${where}: "${spelled}" must be a mapping of owned keys to values.`
       );
     }
-    const indexKey = join11 === PATH_JOIN ? resolve10(configDir, spelled) : spelled;
+    const indexKey = join11 === PATH_JOIN ? resolve11(configDir, spelled) : spelled;
     const values = target.get(indexKey) ?? /* @__PURE__ */ new Map();
     for (const kv of pair.value.items) {
       const key = isScalar2(kv.key) ? String(kv.key.value) : String(kv.key);
@@ -8388,6 +8472,7 @@ function parseManifest(manifest, collection, text2, file, configDir, join11, tar
       ...entryLine === void 0 ? {} : { line: entryLine }
     });
   }
+  return { values: target, entries };
 }
 function nodeLines(node, lineAt, prefix = "", out = /* @__PURE__ */ new Map()) {
   if (isMap4(node)) {
@@ -8431,7 +8516,7 @@ function mergeExternalMetadata(label, extracted, index, memberOf2, base, options
   const sources = [];
   const joins = [];
   if (label !== STDIN_LABEL) {
-    const byPath = index.byPath.get(resolve10(base, label));
+    const byPath = index.byPath.get(resolve11(base, label));
     if (byPath) sources.push(byPath);
   }
   for (const [field, byValue] of index.byField) {
@@ -8526,7 +8611,7 @@ function externalMetadataPointer(key) {
 }
 function orphanEntries(index, loaded, base, collections) {
   if (!index) return [];
-  const have = new Set(loaded.map((l) => resolve10(base, l)));
+  const have = new Set(loaded.map((l) => resolve11(base, l)));
   return index.entries.filter(
     (e) => inCollections(e, collections) && e.join === PATH_JOIN && e.abs !== void 0 && !have.has(e.abs)
   );
@@ -9323,12 +9408,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;
@@ -9821,12 +9906,12 @@ function utcDate(iso) {
 }
 
 // src/meta/core/derive/index.ts
-import { dirname as dirname9, resolve as resolve12 } from "node:path";
+import { dirname as dirname9, resolve as resolve13 } from "node:path";
 
 // src/meta/core/derive/codeowners.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { readFile as readFile7 } from "node:fs/promises";
-import { dirname as dirname7, relative as relative9, resolve as resolve11, sep as sep4 } from "node:path";
+import { dirname as dirname7, relative as relative9, resolve as resolve12, sep as sep4 } from "node:path";
 import picomatch4 from "picomatch";
 var CODEOWNERS_LOCATIONS = [
   ".github/CODEOWNERS",
@@ -9836,11 +9921,11 @@ var CODEOWNERS_LOCATIONS = [
 ];
 function findCodeowners(root, explicit) {
   if (explicit !== void 0) {
-    const path = resolve11(root, explicit);
+    const path = resolve12(root, explicit);
     return existsSync3(path) ? path : null;
   }
   for (const loc of CODEOWNERS_LOCATIONS) {
-    const path = resolve11(root, ...loc.split("/"));
+    const path = resolve12(root, ...loc.split("/"));
     if (existsSync3(path)) return path;
   }
   return null;
@@ -9955,7 +10040,7 @@ function toGlobs(pattern) {
 var NOT_FOUND_REASON = `no CODEOWNERS file found (looked for ${CODEOWNERS_LOCATIONS.join(", ")})`;
 async function deriveFromCodeowners(inputs, opts) {
   const records = /* @__PURE__ */ new Map();
-  const explicitPath = opts.explicit === void 0 ? void 0 : resolve11(opts.configDir ?? process.cwd(), opts.explicit);
+  const explicitPath = opts.explicit === void 0 ? void 0 : resolve12(opts.configDir ?? process.cwd(), opts.explicit);
   if (explicitPath !== void 0 && !existsSync3(explicitPath)) {
     return {
       status: { available: false, reason: `CODEOWNERS not found at ${explicitPath}` },
@@ -10095,14 +10180,14 @@ function findWindows(lines, length, pin, key, opts) {
     const first = original[0];
     for (let start = 1; start <= lastStart; start++) {
       if (lines[start - 1] !== first) continue;
-      let same = true;
+      let same2 = true;
       for (let i = 1; i < length; i++) {
         if (lines[start - 1 + i] !== original[i]) {
-          same = false;
+          same2 = false;
           break;
         }
       }
-      if (same && hashLines(joined(start), key) === pin) starts.push(start);
+      if (same2 && hashLines(joined(start), key) === pin) starts.push(start);
     }
     return { starts, truncated: false };
   }
@@ -10432,10 +10517,10 @@ function planProvenanceWrite(comparisons, derivation) {
     if (r.status === "current") kept.push({ entry: r.entry, start: r.span.start });
     else if (r.status === "moved") kept.push({ entry: { ...r.entry, lines: lineSpec(r.span) }, start: r.span.start });
   }
-  const same = (a, b) => a["generated-by"] === b["generated-by"] && String(a.lines) === String(b.lines) && a.integrity === b.integrity;
+  const same2 = (a, b) => a["generated-by"] === b["generated-by"] && String(a.lines) === String(b.lines) && a.integrity === b.integrity;
   const out = [...kept];
   for (const d of derivation.derived) {
-    if (!kept.some((k) => same(k.entry, d.entry))) out.push({ entry: d.entry, start: d.span.start });
+    if (!kept.some((k) => same2(k.entry, d.entry))) out.push({ entry: d.entry, start: d.span.start });
   }
   return out.sort((a, b) => a.start - b.start).map((k) => k.entry);
 }
@@ -11154,8 +11239,8 @@ function manifestStamp(text2, key, join11) {
   }
   if (!isRecord5(data)) return [];
   for (const [candidate, value] of Object.entries(data)) {
-    const same = join11 === "path" ? posix2.normalize(candidate) === posix2.normalize(key) : candidate === key;
-    if (same && isRecord5(value)) return provenanceEntries(value[PROVENANCE_FIELD]);
+    const same2 = join11 === "path" ? posix2.normalize(candidate) === posix2.normalize(key) : candidate === key;
+    if (same2 && isRecord5(value)) return provenanceEntries(value[PROVENANCE_FIELD]);
   }
   return [];
 }
@@ -11226,12 +11311,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;
@@ -11464,7 +11549,7 @@ async function deriveReviewsByRoot(inputs, git2, rootFor, ctx, requested) {
   if (byRoot.size === 0) {
     return unavailable3(requested, "no git repository contains the documents");
   }
-  const cacheDir = resolve12(ctx.configDir ?? ctx.cwd, REVIEW_CACHE_DIR);
+  const cacheDir = resolve13(ctx.configDir ?? ctx.cwd, REVIEW_CACHE_DIR);
   for (const [root, bucket] of byRoot) {
     const client = ctx.reviews ?? await createReviewClient(root, { cwd: ctx.cwd, cache: ctx.cache, cacheDir, requested });
     const identity = await client.detect();
@@ -11645,8 +11730,8 @@ async function deriveForTable(inputs, ctx, hint, fields) {
 import { readFile as readFile9 } from "node:fs/promises";
 
 // src/meta/core/relocation.ts
-import { access, readFile as readFile8, stat as stat5, unlink } from "node:fs/promises";
-import { basename as basename5, extname as extname3, isAbsolute as isAbsolute7, join as join8, relative as relative11, resolve as resolve13, sep as sep6 } from "node:path";
+import { access, readFile as readFile8, stat as stat6, unlink } from "node:fs/promises";
+import { basename as basename5, extname as extname3, isAbsolute as isAbsolute7, join as join8, relative as relative11, resolve as resolve14, sep as sep6 } from "node:path";
 import picomatch6 from "picomatch";
 import {
   LineCounter as LineCounter4,
@@ -11697,7 +11782,7 @@ function spliceManifestValue(text2, options) {
     const r = rangeOf(node);
     return r ? lc.linePos(r[0]).line : void 0;
   };
-  const same = join11 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
+  const same2 = join11 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
   const root = doc.contents;
   let spelled = entry;
   let edit;
@@ -11709,7 +11794,7 @@ function spliceManifestValue(text2, options) {
     );
   } else {
     const style = detectStyle(text2, root, eol);
-    const matches = root.items.filter((p) => same(keyString(p.key), entry));
+    const matches = root.items.filter((p) => same2(keyString(p.key), entry));
     const [first, second] = matches;
     if (first && second) {
       throw new DocmetaError(
@@ -11775,8 +11860,8 @@ function readManifestValue(text2, options) {
   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 same2 = join11 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
+  const pair = root.items.find((p) => same2(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);
@@ -11809,8 +11894,8 @@ function removeManifestKey(text2, options) {
       `${at2()}: the manifest must be a mapping from document ${join11 === PATH_JOIN ? "path" : `"${join11}"`} to owned keys.`
     );
   }
-  const same = join11 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
-  const matches = root.items.filter((p) => same(keyString(p.key), entry));
+  const same2 = join11 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
+  const matches = root.items.filter((p) => same2(keyString(p.key), entry));
   const [first, second] = matches;
   if (first && second) {
     throw new DocmetaError(
@@ -11897,15 +11982,15 @@ function renameManifestEntry(text2, options) {
       `${at2()}: the manifest must be a mapping from document ${join11 === PATH_JOIN ? "path" : `"${join11}"`} to owned keys.`
     );
   }
-  const same = join11 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
-  const [first, second] = root.items.filter((p) => same(keyString(p.key), entry));
+  const same2 = join11 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
+  const [first, second] = root.items.filter((p) => same2(keyString(p.key), entry));
   if (first && second) {
     throw new DocmetaError(
       `${at2(keyLine(second.key))}: "${keyString(second.key)}" is named twice (first at line ${String(keyLine(first.key) ?? "?")}). Merge the two entries into one.`
     );
   }
   if (first === void 0) return { text: text2 };
-  const taken = root.items.find((p) => same(keyString(p.key), to));
+  const taken = root.items.find((p) => same2(keyString(p.key), to));
   if (taken !== void 0) {
     throw new DocmetaError(
       `${at2(keyLine(taken.key))}: "${keyString(taken.key)}" already has an entry, so "${keyString(first.key)}" cannot be renamed to it. Merge the two entries into one.`
@@ -12171,7 +12256,7 @@ function relocationContext(run2, extras) {
   };
 }
 var toPosix3 = (p) => p.split(sep6).join("/");
-function reported(abs, base) {
+function reported2(abs, base) {
   const rel = relative11(base, abs);
   return rel === "" ? "." : toPosix3(rel);
 }
@@ -12194,14 +12279,14 @@ var Model = class {
     for (const c of this.collections) {
       c.externalMetadata.forEach((m, index) => {
         const url = classifyRef(m.file).kind === "url";
-        const absPath = url ? void 0 : isAbsolute7(m.file) ? m.file : resolve13(configDir, m.file);
+        const absPath = url ? void 0 : isAbsolute7(m.file) ? m.file : resolve14(configDir, m.file);
         this.manifests.push({
           collection: c.name,
           index,
           written: m.file,
           url,
           absPath,
-          file: absPath === void 0 ? m.file : reported(absPath, ctx.base),
+          file: absPath === void 0 ? m.file : reported2(absPath, ctx.base),
           join: externalMetadataJoin(m),
           created: false,
           keysBefore: [...m.keys],
@@ -12299,7 +12384,7 @@ var Model = class {
     if (local !== void 0) return { manifest: local, proposed: proposedOf(local) };
     const fileName = `${name2}.metadata.yaml`;
     const absPath = join8(this.configDir, fileName);
-    const file = reported(absPath, this.ctx.base);
+    const file = reported2(absPath, this.ctx.base);
     if (!commit) return { proposed: proposedOf({ file, created: true }) };
     if (await exists(absPath, file)) {
       throw new DocmetaError(
@@ -12351,7 +12436,7 @@ var Model = class {
   /** A label relative to the config directory, posix; undefined outside it. */
   relative(label) {
     if (label === "<stdin>") return void 0;
-    const rel = toPosix3(relative11(this.configDir, resolve13(this.ctx.base, label)));
+    const rel = toPosix3(relative11(this.configDir, resolve14(this.ctx.base, label)));
     return isAbsolute7(rel) || rel.startsWith("../") ? void 0 : rel;
   }
 };
@@ -12363,20 +12448,20 @@ 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)));
+    const rel2 = toPosix3(relative11(configDir, resolve14(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 = resolve14(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();
+      directory = (await stat6(abs)).isDirectory();
     } catch {
       directory = false;
     }
@@ -12394,7 +12479,7 @@ async function exists(absPath, file) {
   }
 }
 function plannedConfigDir(ctx) {
-  return ctx.configDir ?? findGitRoot(ctx.cwd) ?? resolve13(ctx.cwd);
+  return ctx.configDir ?? findGitRoot(ctx.cwd) ?? resolve14(ctx.cwd);
 }
 async function keyHome(ctx, label, data, key) {
   const model = new Model(ctx, plannedConfigDir(ctx));
@@ -12415,7 +12500,7 @@ async function keyHome(ctx, label, data, key) {
   return { kind: "unowned", home: (await model.home(label, false)).proposed };
 }
 function entryFor(m, label, data, configDir, base, key) {
-  if (m.join === PATH_JOIN) return toPosix3(relative11(configDir, resolve13(base, label)));
+  if (m.join === PATH_JOIN) return toPosix3(relative11(configDir, resolve14(base, label)));
   let raw = data[m.join];
   if (isEncryptedValue(raw)) {
     const k = key();
@@ -12456,7 +12541,7 @@ async function planRelocation(ctx, request) {
       if (beyond) return void 0;
       throw new DocmetaError(`Unsupported file type "${extname3(label)}" for "${label}". Use --as to override.`);
     }
-    const absPath = resolve13(ctx.base, label);
+    const absPath = resolve14(ctx.base, label);
     const elements = resolveElements(label, ctx.config, currentMembers(label));
     let content = "";
     let own2 = {};
@@ -12669,7 +12754,7 @@ async function planRelocation(ctx, request) {
     });
     const labels = dedupe2([
       ...request.files,
-      ...walked.files.map((f) => reported(resolve13(configDir, f), ctx.base))
+      ...walked.files.map((f) => reported2(resolve14(configDir, f), ctx.base))
     ]).filter((label) => model.members(label).includes(name2));
     for (const label of labels) {
       const page = await load(label, !runSet.has(label));
@@ -13113,7 +13198,7 @@ function buildResult(input) {
 async function applyRelocation(ctx, plan, io = {}) {
   const write = io.write ?? ((path, text2) => writeFileAtomic(path, text2));
   const remove = io.remove ?? ((path) => unlink(path));
-  const label = (w) => w.kind === "config" ? configSource(w.path, ctx.cwd) : reported(w.path, ctx.base);
+  const label = (w) => w.kind === "config" ? configSource(w.path, ctx.cwd) : reported2(w.path, ctx.base);
   for (const w of plan.writes) {
     let now;
     try {
@@ -13284,7 +13369,7 @@ function relocationOffers(plan) {
 }
 
 // src/meta/commands/validate.ts
-import { resolve as resolve15, extname as extname4 } from "node:path";
+import { resolve as resolve16, extname as extname4 } from "node:path";
 
 // src/meta/core/checks.ts
 var CHECK_KEYWORD = "check";
@@ -13422,7 +13507,7 @@ async function runChecks(checks, entries, ctx = {}) {
 }
 
 // src/meta/core/derive/provenance-place.ts
-import { isAbsolute as isAbsolute8, relative as relative12, resolve as resolve14, sep as sep7 } from "node:path";
+import { isAbsolute as isAbsolute8, relative as relative12, resolve as resolve15, sep as sep7 } from "node:path";
 var toPosix4 = (p) => p.split(sep7).join("/");
 function provenanceManifests(collections, configDir, base) {
   const out = [];
@@ -13434,7 +13519,7 @@ function provenanceManifests(collections, configDir, base) {
           `collection ${collection.name}: ${PROVENANCE_FIELD} cannot come from a URL manifest, because manni meta derive writes it.`
         );
       }
-      const absPath = isAbsolute8(manifest.file) ? manifest.file : resolve14(configDir, manifest.file);
+      const absPath = isAbsolute8(manifest.file) ? manifest.file : resolve15(configDir, manifest.file);
       const rel = relative12(base, absPath);
       out.push({
         collection: collection.name,
@@ -13458,7 +13543,7 @@ function provenancePlace(label, data, manifests, collections, configDir, base) {
     );
   }
   if (manifest.join === PATH_JOIN) {
-    const entry = toPosix4(relative12(configDir, resolve14(base, label)));
+    const entry = toPosix4(relative12(configDir, resolve15(base, label)));
     return { manifest, absPath: manifest.absPath, entry, join: manifest.join };
   }
   const value = data[manifest.join];
@@ -13722,7 +13807,7 @@ async function runValidate(opts) {
       const place = provenanceManifests2.length === 0 ? void 0 : readerPlace(label, extracted.data, provenanceManifests2, declaredCollections, configDir ?? cwd, base);
       deriveInputs.push({
         label,
-        absPath: resolve15(base, label),
+        absPath: resolve16(base, label),
         content,
         extracted,
         ...place !== void 0 ? { provenanceManifest: place } : {}
@@ -13853,7 +13938,7 @@ async function runValidate(opts) {
     await processOne(STDIN_LABEL, content, forcedExtractor.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile9(resolve15(base, file), "utf8");
+    const content = await readFile9(resolve16(base, file), "utf8");
     await processOne(file, content, extname4(file));
   }
   if (unverified > 0) opts.onNotice?.(unverifiedWarning(unverified));
@@ -13967,7 +14052,7 @@ async function runValidate(opts) {
     }
   }
   const frame = { cwd, base: configDir ?? cwd, runBase: base };
-  const { results: reported2, baseline } = await settleBaseline(
+  const { results: reported3, baseline } = await settleBaseline(
     results,
     resolveBaselineRequest(opts, config?.baseline, configDir, cwd, {
       current: DEFAULT_BASELINE_PATH,
@@ -13975,13 +14060,13 @@ async function runValidate(opts) {
     }),
     frame
   );
-  const failed = reported2.filter((r) => !r.ok).length;
-  const count2 = (keep) => reported2.reduce((n, r) => n + r.errors.filter(keep).length, 0);
+  const failed = reported3.filter((r) => !r.ok).length;
+  const count2 = (keep) => reported3.reduce((n, r) => n + r.errors.filter(keep).length, 0);
   const warnings = count2((e) => e.severity === "warning");
   const notices = count2((e) => e.severity === "notice");
   const summary = {
-    files: reported2.length,
-    passed: reported2.length - failed,
+    files: reported3.length,
+    passed: reported3.length - failed,
     failed,
     errors: count2(isErrorSeverity),
     // Omitted at zero, like `gitignoreSkipped` below: only the location
@@ -13994,12 +14079,12 @@ async function runValidate(opts) {
     ...gitignoreSkipped > 0 ? { gitignoreSkipped } : {},
     ...baseline ? { baseline } : {}
   };
-  return { results: reported2, summary, frame };
+  return { results: reported3, summary, frame };
 }
 
 // src/meta/commands/get.ts
 import { readFile as readFile10 } from "node:fs/promises";
-import { resolve as resolve16, extname as extname5 } from "node:path";
+import { resolve as resolve17, extname as extname5 } from "node:path";
 async function runGet(opts) {
   const cwd = opts.cwd ?? process.cwd();
   if (opts.fields.length === 0) {
@@ -14085,7 +14170,7 @@ async function runGet(opts) {
         const place = provenanceManifests2.length === 0 ? void 0 : readerPlace(label, own2.data, provenanceManifests2, declaredCollections, configDir ?? cwd, base);
         deriveInputs.push({
           label,
-          absPath: resolve16(base, label),
+          absPath: resolve17(base, label),
           content,
           extracted: own2,
           ...place !== void 0 ? { provenanceManifest: place } : {}
@@ -14127,7 +14212,7 @@ async function runGet(opts) {
     readOne(STDIN_LABEL, opts.stdinContent ?? "", forced.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile10(resolve16(base, file), "utf8");
+    const content = await readFile10(resolve17(base, file), "utf8");
     readOne(file, content, extname5(file));
   }
   if (deriving) {
@@ -14254,7 +14339,7 @@ function parseJsonPointer(pointer) {
 // src/meta/commands/schemas.ts
 import { existsSync as existsSync4 } from "node:fs";
 import { mkdir as mkdir2, readFile as readFile11 } from "node:fs/promises";
-import { dirname as dirname10, extname as extname6, isAbsolute as isAbsolute9, join as join9, relative as relative13, resolve as resolve17, sep as sep8 } from "node:path";
+import { dirname as dirname10, extname as extname6, isAbsolute as isAbsolute9, join as join9, relative as relative13, resolve as resolve18, sep as sep8 } from "node:path";
 import { parseDocument as parseDocument7, parse as parseYaml6, stringify as stringify3 } from "yaml";
 function getSchemasInfo() {
   return { builtins: listBuiltins(), formats: listFormats() };
@@ -14348,9 +14433,9 @@ async function runVendorSchema(opts) {
     );
   }
   const loaded = await loadConfig(opts.configPath, cwd);
-  const configPath = loaded?.path ?? resolve17(cwd, DEFAULT_CONFIG_NAME);
+  const configPath = loaded?.path ?? resolve18(cwd, DEFAULT_CONFIG_NAME);
   const configDir = loaded?.dir ?? cwd;
-  const absDir = resolve17(cwd, opts.dir ?? DEFAULT_VENDOR_DIR);
+  const absDir = resolve18(cwd, opts.dir ?? DEFAULT_VENDOR_DIR);
   const absFile = join9(absDir, vendorFileName(url));
   await assertNotIgnored(absFile, absDir, cwd, opts.onNotice);
   const fromConfig = posixRelative(configDir, absFile);
@@ -14531,7 +14616,7 @@ async function runInferSchema(opts) {
   }
   let absOut;
   if (opts.out !== void 0) {
-    absOut = resolve17(cwd, opts.out);
+    absOut = resolve18(cwd, opts.out);
     await assertNotIgnored(
       absOut,
       dirname10(absOut),
@@ -14610,42 +14695,42 @@ async function runInferSchema(opts) {
       return;
     }
     for (const [key, value] of Object.entries(extracted.data)) {
-      const stat6 = stats.get(key) ?? emptyStats();
-      recordValue(stat6, label, value, extracted.lineFor(key));
-      stats.set(key, stat6);
+      const stat7 = stats.get(key) ?? emptyStats();
+      recordValue(stat7, label, value, extracted.lineFor(key));
+      stats.set(key, stat7);
     }
   };
   if (usingStdin && forced) {
     scanOne(STDIN_LABEL, opts.stdinContent ?? "", forced.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile11(resolve17(base, file), "utf8");
+    const content = await readFile11(resolve18(base, file), "utf8");
     scanOne(file, content, extname6(file));
   }
   for (const u of unreadable) {
     opts.onNotice?.(`could not read metadata from "${u.file}": ${u.message}`);
   }
-  const all = [...stats.entries()].map(([key, stat6]) => {
-    const dominantType = dominantTypeOf(stat6);
-    const enumValues = enumFor(stat6, dominantType);
-    const format = formatOf(stat6, dominantType);
-    const outliers = [...stat6.locations.entries()].filter(([type]) => type !== dominantType).flatMap(([, where]) => where);
-    const outlierCount = [...stat6.types.entries()].filter(([type]) => type !== dominantType).reduce((sum, [, count2]) => sum + count2, 0);
-    const sample = [...stat6.values.values()].filter((v) => v.type === dominantType).sort((a, b) => b.count - a.count)[0]?.value;
+  const all = [...stats.entries()].map(([key, stat7]) => {
+    const dominantType = dominantTypeOf(stat7);
+    const enumValues = enumFor(stat7, dominantType);
+    const format = formatOf(stat7, dominantType);
+    const outliers = [...stat7.locations.entries()].filter(([type]) => type !== dominantType).flatMap(([, where]) => where);
+    const outlierCount = [...stat7.types.entries()].filter(([type]) => type !== dominantType).reduce((sum, [, count2]) => sum + count2, 0);
+    const sample = [...stat7.values.values()].filter((v) => v.type === dominantType).sort((a, b) => b.count - a.count)[0]?.value;
     return {
       key,
-      present: stat6.present,
-      coverage: filesScanned === 0 ? 0 : stat6.present / filesScanned * 100,
-      types: [...stat6.types.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([type, count2]) => ({ type, count: count2 })),
+      present: stat7.present,
+      coverage: filesScanned === 0 ? 0 : stat7.present / filesScanned * 100,
+      types: [...stat7.types.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([type, count2]) => ({ type, count: count2 })),
       dominantType,
       outliers,
       outlierCount,
-      distinct: stat6.values.size,
-      distinctCapped: stat6.distinctCapped,
+      distinct: stat7.values.size,
+      distinctCapped: stat7.distinctCapped,
       ...enumValues ? { enumValues } : {},
       ...sample !== void 0 ? { sample } : {},
       ...format !== void 0 ? { format } : {},
-      sawEmptyString: stat6.sawEmptyString
+      sawEmptyString: stat7.sawEmptyString
     };
   });
   const kept = all.filter((k) => k.coverage >= minCoverage).sort((a, b) => b.coverage - a.coverage || a.key.localeCompare(b.key));
@@ -14681,7 +14766,7 @@ async function runInferSchema(opts) {
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
 import { mkdir as mkdir3, open as open2, readFile as readFile12, rename as rename3, rm as rm3 } from "node:fs/promises";
-import { dirname as dirname11, isAbsolute as isAbsolute10, resolve as resolve18, extname as extname7, sep as sep9 } from "node:path";
+import { dirname as dirname11, isAbsolute as isAbsolute10, resolve as resolve19, extname as extname7, sep as sep9 } from "node:path";
 
 // src/shared/prompt.ts
 import { createInterface } from "node:readline";
@@ -15020,10 +15105,10 @@ async function runQuery(opts) {
     readOne(STDIN_LABEL, opts.stdinContent ?? "", ext);
   }
   for (const file of files) {
-    const content = await readFile12(resolve18(base, file), "utf8");
+    const content = await readFile12(resolve19(base, file), "utf8");
     readOne(file, content, extname7(file));
   }
-  const db = opts.db === void 0 ? void 0 : { resolved: resolve18(cwd, opts.db), display: opts.db };
+  const db = opts.db === void 0 ? void 0 : { resolved: resolve19(cwd, opts.db), display: opts.db };
   const run2 = await runSql(sql, entries, {
     target: db,
     params: boundParams,
@@ -15164,7 +15249,7 @@ async function runSql(sql, entries, ctx) {
         const place = manifests.length === 0 ? void 0 : readerPlace(e.label, e.own.data, manifests, ctx.declaredCollections, manifestRoot, ctx.base);
         return {
           label: e.label,
-          absPath: resolve18(ctx.base, e.label),
+          absPath: resolve19(ctx.base, e.label),
           content: e.content,
           extracted: e.own,
           ...place !== void 0 ? { provenanceManifest: place } : {}
@@ -15635,14 +15720,14 @@ function assertSchemaWriteWithin(ctx, abs) {
   );
 }
 function foldPath(p) {
-  const abs = resolve18(p);
+  const abs = resolve19(p);
   return process.platform === "win32" ? abs.toLowerCase() : abs;
 }
 function filePinsByPath(ctx) {
   const byPath = /* @__PURE__ */ new Map();
   for (const [ref, pin] of collectSchemaPins(ctx.config)) {
     if (classifyRef(ref).kind !== "file") continue;
-    byPath.set(foldPath(resolve18(ctx.cwd, ref)), pin);
+    byPath.set(foldPath(resolve19(ctx.cwd, ref)), pin);
   }
   return byPath;
 }
@@ -15670,7 +15755,7 @@ async function loadSetMembers(refs, ctx) {
       });
       continue;
     }
-    const abs = resolve18(ctx.cwd, ref);
+    const abs = resolve19(ctx.cwd, ref);
     const canon = foldPath(abs);
     if (seenFiles.has(canon)) continue;
     seenFiles.add(canon);
@@ -15875,7 +15960,7 @@ async function planSchemaMutation(ops, entries, ctx) {
     const [, name2, ver] = target.builtinId.split(":");
     const safe = (s) => s.replace(/[^A-Za-z0-9._-]/g, "-");
     const forkName = `${safe(name2 ?? "schema")}-${safe(ver ?? "0")}.local.json`;
-    schemaAbs = resolve18(ctx.configDir ?? ctx.cwd, "schemas", forkName);
+    schemaAbs = resolve19(ctx.configDir ?? ctx.cwd, "schemas", forkName);
     assertSchemaWriteWithin(ctx, schemaAbs);
     if (existsSync5(schemaAbs)) {
       throw new DocmetaError(
@@ -16042,7 +16127,7 @@ async function planConfigEdit(ctx, edit, runRefs) {
     }
     return void 0;
   };
-  const rebaseRaw = (raw) => classifyRef(raw).kind === "file" && !isAbsolute10(raw) ? resolve18(configDir, raw) : raw;
+  const rebaseRaw = (raw) => classifyRef(raw).kind === "file" && !isAbsolute10(raw) ? resolve19(configDir, raw) : raw;
   const wantSet = runRefs.map(rebaseRaw).sort().join("\n");
   const seqResolvesToRunSet = (node) => {
     if (!isSeq5(node)) return false;
@@ -16087,7 +16172,7 @@ async function planConfigEdit(ctx, edit, runRefs) {
       if (!isMap8(item)) continue;
       const raw = rawRefOf(item);
       if (raw === void 0 || classifyRef(raw).kind !== "file") continue;
-      const abs = isAbsolute10(raw) ? raw : resolve18(configDir, raw);
+      const abs = isAbsolute10(raw) ? raw : resolve19(configDir, raw);
       if (foldPath(abs) !== wantPath) continue;
       pinFrom = item.get("integrity");
       item.set("integrity", edit.integrity.value);
@@ -16316,7 +16401,7 @@ function buildChanges(diff, entries, sentinel, ctx, renameHints = [], booleanAdd
         `"${file}": no writable format for that extension.`
       );
     }
-    if (existsSync5(resolve18(ctx.base, file))) {
+    if (existsSync5(resolve19(ctx.base, file))) {
       throw new DocmetaError(
         `"${file}" already exists; INSERT creates new files only.`
       );
@@ -16335,7 +16420,7 @@ function buildChanges(diff, entries, sentinel, ctx, renameHints = [], booleanAdd
         `"${from}" -> "${to}": a rename may not change the extension.`
       );
     }
-    if (existsSync5(resolve18(ctx.base, to))) {
+    if (existsSync5(resolve19(ctx.base, to))) {
       throw new DocmetaError(
         `"${to}" already exists; the rename would overwrite it.`
       );
@@ -16368,9 +16453,9 @@ function validateNewPath(p, base) {
   if (p.split(/[\\/]/).some((segment) => segment === "..")) {
     refuse("it traverses upward");
   }
-  const abs = resolve18(base, p);
-  if (abs === resolve18(base)) refuse("it points at the corpus root, not a file");
-  if (!abs.startsWith(resolve18(base) + sep9)) refuse("it escapes the corpus");
+  const abs = resolve19(base, p);
+  if (abs === resolve19(base)) refuse("it points at the corpus root, not a file");
+  if (!abs.startsWith(resolve19(base) + sep9)) refuse("it escapes the corpus");
 }
 function refuseJoinFieldChanges(changes, entries, ctx) {
   const index = ctx.externalMetadata;
@@ -16521,7 +16606,7 @@ async function planManifestEdits(changes, entries, ctx, renameHints) {
     );
     const index = await leftOut;
     if (index === null) return void 0;
-    const abs = resolve18(ctx.base, file);
+    const abs = resolve19(ctx.base, file);
     const named = index.entries.find(
       (e) => e.join === PATH_JOIN && e.abs === abs && excluded.includes(e.collection)
     );
@@ -16568,7 +16653,7 @@ async function planManifestEdits(changes, entries, ctx, renameHints) {
       continue;
     }
     if ("renamed" in c) {
-      const supplied = ctx.externalMetadata?.byPath.get(resolve18(ctx.base, c.file));
+      const supplied = ctx.externalMetadata?.byPath.get(resolve19(ctx.base, c.file));
       const seen = /* @__PURE__ */ new Set();
       for (const [key, sv] of supplied ?? []) {
         if (seen.has(sv.file) || !ctx.memberships(c.file).includes(sv.collection)) continue;
@@ -16870,14 +16955,14 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
   const pendingWrites = [];
   const pendingRenames = [];
   for (const [label, ops] of grouped) {
-    const path = resolve18(ctx.base, label);
+    const path = resolve19(ctx.base, label);
     if (ops.renamedTo !== void 0) {
       if (!existsSync5(path)) {
         throw new DocmetaError(
           `"${label}" is gone from disk since it was read; re-run the query.`
         );
       }
-      const toDisk = resolve18(ctx.base, ops.renamedTo);
+      const toDisk = resolve19(ctx.base, ops.renamedTo);
       if (existsSync5(toDisk)) {
         throw new DocmetaError(
           `"${ops.renamedTo}" appeared on disk since the plan; re-run the query.`
@@ -17130,8 +17215,8 @@ function skipExpression(sql, from) {
 }
 
 // src/meta/commands/fill.ts
-import { readFile as readFile13 } from "node:fs/promises";
-import { resolve as resolve19, extname as extname8, join as join10 } from "node:path";
+import { readFile as readFile14 } from "node:fs/promises";
+import { resolve as resolve20, extname as extname8, join as join10 } from "node:path";
 import {
   completeValidatedJSON,
   makeProvider,
@@ -17145,6 +17230,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;
@@ -17444,28 +17630,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(resolve20(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;
@@ -17967,52 +18159,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>") {
-      await writeFileAtomic(resolve19(base, label), next);
+    const pageWritten = next !== content && !dryRun && label !== "<stdin>";
+    if (pageWritten) {
+      await writeFileAtomic(resolve20(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,
@@ -18027,7 +18221,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(resolve20(base, file), "utf8");
       return prepareOne(file, content, extname8(file));
     })
   });
@@ -18051,7 +18245,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);
@@ -18456,8 +18650,8 @@ async function mapConcurrent(items2, limit, fn) {
 }
 
 // src/meta/commands/derive.ts
-import { readFile as readFile14 } from "node:fs/promises";
-import { extname as extname9, relative as relative14, resolve as resolve20, sep as sep10 } from "node:path";
+import { readFile as readFile15 } from "node:fs/promises";
+import { extname as extname9, relative as relative14, resolve as resolve21, sep as sep10 } from "node:path";
 var GENERATED_BY_ENV = "MANNI_GENERATED_BY";
 var SOURCE_HINT = "narrow --sources or --fields";
 async function runDerive(opts) {
@@ -18568,7 +18762,7 @@ async function runDerive(opts) {
   const files = fromCollections ? retainMembers(walked, membersFor) : walked;
   const rangesByPage = /* @__PURE__ */ new Map();
   for (const t of targets) {
-    const label = relative14(base, resolve20(base, t.page)).split(sep10).join("/");
+    const label = relative14(base, resolve21(base, t.page)).split(sep10).join("/");
     if (!files.includes(label)) {
       throw new DocmetaError(
         `${t.target} does not name one file that derive reads; a range names lines of one file.`
@@ -18593,7 +18787,7 @@ async function runDerive(opts) {
     const loaded2 = /* @__PURE__ */ new Map();
     const errors2 = /* @__PURE__ */ new Map();
     for (const label of files) {
-      const absPath = resolve20(base, label);
+      const absPath = resolve21(base, label);
       const extractor = forcedExtractor ?? extractorForExtension(extname9(label));
       if (!extractor) {
         errors2.set(label, {
@@ -18602,7 +18796,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, {
@@ -18823,24 +19017,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 {
@@ -18870,7 +19053,7 @@ async function runDerive(opts) {
       const shown = () => compared.map(
         (f) => f.field !== PROVENANCE_FIELD && isMarked(f.field) ? redactedDerived(f) : f
       );
-      const findingsOf = (reported3) => reported3.flatMap(
+      const findingsOf = (reported4) => reported4.flatMap(
         (f) => f.field === PROVENANCE_FIELD && provenance?.judged !== void 0 ? provenanceFindings(provenance.judged.comparisons, provenance.judged.derivation.page.bodyLine) : staleFindings([f], doc.extracted.lineFor, marks.locate)
       );
       if (provenance?.judged !== void 0 && flagGeneratedBy !== void 0 && doc.attribution === void 0 && ![...provenance.judged.derivation.evidenceByLine.values()].some((e) => e.rule === 1)) {
@@ -18917,12 +19100,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 = [];
@@ -18931,7 +19117,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;
@@ -18941,16 +19127,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);
@@ -19013,14 +19197,15 @@ 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;
       }
       if (!dryRun) for (const f of manifestWritten) markWritten(f);
-      const reported2 = shown();
+      const reported3 = shown();
       for (const { f, home, entry } of toEntries) {
-        const shownField = reported2.find((r) => r.field === f.field);
+        const shownField = reported3.find((r) => r.field === f.field);
         if (shownField !== void 0 && entryWritten.includes(f)) {
           lineRequests.push({ field: shownField, absPath: home.absPath, entry, join: home.join });
         }
@@ -19028,9 +19213,9 @@ async function runDerive(opts) {
       results.push({
         file: label,
         format: doc.format,
-        fields: reported2,
+        fields: reported3,
         changed,
-        ...check ? { findings: findingsOf(reported2) } : {}
+        ...check ? { findings: findingsOf(reported3) } : {}
       });
     }
     settled = true;
@@ -19944,6 +20129,9 @@ export {
   runVendorSchema,
   runInferSchema,
   runQuery,
+  heldManifest,
+  rebaseable,
+  settle,
   runFill,
   runDerive,
   deriveFailed,
@@ -19962,4 +20150,4 @@ export {
   renderQuery,
   renderQueryCsv
 };
-//# sourceMappingURL=chunk-KEW557TN.js.map
+//# sourceMappingURL=chunk-XHH5OSQQ.js.map