@hawkeyexl/manni 2.10.2 → 2.11.0

package/dist/{chunk-KJLPOY2I.js → chunk-BUXVMARH.js}

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 // package.json
 var package_default = {
   name: "@hawkeyexl/manni",
-  version: "2.10.2",
+  version: "2.11.0",
   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: {
@@ -141,6 +141,99 @@ function matchesFileGlob(relPath, glob) {
   return m(relPath.replace(/\\/g, "/"));
 }
 
+// src/shared/collections.ts
+import { posix as posix2, win32 } from "node:path";
+
+// src/shared/page-manifest.ts
+import { readFileSync, realpathSync } from "node:fs";
+import { isAbsolute, posix, relative, resolve, sep } from "node:path";
+import fg from "fast-glob";
+import { LineCounter, isMap, isNode, isScalar, parseDocument } from "yaml";
+var PAGE_PLACEHOLDER = "{page}";
+function hasPagePlaceholder(file) {
+  return file.includes(PAGE_PLACEHOLDER);
+}
+function slashes(path) {
+  return path.split(sep).join("/").replace(/\\/g, "/");
+}
+function normalizeManifestPattern(file) {
+  const forward = file.replace(/\\/g, "/");
+  return forward.startsWith("./") ? forward.slice(2) : forward;
+}
+function pageManifestPath(file, configDir, pageAbs) {
+  const between = relative(configDir, pageAbs);
+  const pageRel = slashes(between);
+  if (isAbsolute(between) || pageRel === ".." || pageRel.startsWith("../")) {
+    return { outside: true, pageRel };
+  }
+  const ext = posix.extname(pageRel);
+  const page = ext === "" ? pageRel : pageRel.slice(0, -ext.length);
+  const named = normalizeManifestPattern(file).replace(PAGE_PLACEHOLDER, () => page);
+  const abs = resolve(configDir, named);
+  return { abs, rel: slashes(relative(configDir, abs)) };
+}
+function strayManifestGlob(file) {
+  const normalized = normalizeManifestPattern(file);
+  const at2 = normalized.indexOf(PAGE_PLACEHOLDER);
+  if (at2 < 0) return literal(normalized);
+  const prefix = literal(normalized.slice(0, at2));
+  const suffix = literal(normalized.slice(at2 + PAGE_PLACEHOLDER.length));
+  return `${prefix}**/*${suffix}`;
+}
+function literal(text2) {
+  return text2 === "" ? "" : fg.escapePath(text2);
+}
+function findPageManifests(file, configDir, isMember2) {
+  const matched = fg.sync(strayManifestGlob(file), {
+    cwd: configDir,
+    absolute: true,
+    onlyFiles: true,
+    dot: false,
+    ignore: ["**/node_modules/**", "**/.git/**"]
+  }).map((path) => resolve(path)).sort();
+  const found = [];
+  for (const abs of matched) {
+    const entries = ownEntries(abs, file, configDir, isMember2);
+    if (entries.length > 0) found.push({ abs, entries });
+  }
+  return found;
+}
+function ownEntries(abs, file, configDir, isMember2) {
+  let text2;
+  try {
+    text2 = readFileSync(abs, "utf8");
+  } catch {
+    return [];
+  }
+  const lc = new LineCounter();
+  const doc = parseDocument(text2, { lineCounter: lc, uniqueKeys: false });
+  const root = doc.contents;
+  if (doc.errors.length > 0 || !isMap(root)) return [];
+  const entries = [];
+  for (const pair of root.items) {
+    const spelled = isScalar(pair.key) ? String(pair.key.value) : String(pair.key);
+    const pageAbs = resolve(configDir, spelled);
+    if (!isMember2(slashes(relative(configDir, pageAbs)))) continue;
+    const resolved = pageManifestPath(file, configDir, pageAbs);
+    if ("outside" in resolved || !sameFile(resolved.abs, abs)) continue;
+    const range = isNode(pair.key) ? pair.key.range : void 0;
+    entries.push({
+      spelled,
+      pageAbs,
+      ...range ? { line: lc.linePos(range[0]).line } : {}
+    });
+  }
+  return entries;
+}
+function sameFile(a, b) {
+  if (a === b) return true;
+  try {
+    return realpathSync(a) === realpathSync(b);
+  } catch {
+    return false;
+  }
+}
+
 // src/shared/collections.ts
 var COLLECTION_KEYS = [
   "name",
@@ -150,6 +243,7 @@ var COLLECTION_KEYS = [
   "externalMetadata"
 ];
 var EXTERNAL_METADATA_KEYS = ["file", "keys", "tokenEnv", "join"];
+var PATH_JOIN = "path";
 var SCHEMA_KEY = "$schema";
 var STDIN = "<stdin>";
 function isUrlRef(ref) {
@@ -285,6 +379,7 @@ function isHttpUrl(value) {
 }
 function parseExternalMetadata(raw, collectionWhere, source, toError) {
   const owners = /* @__PURE__ */ new Map();
+  const patterns = /* @__PURE__ */ new Map();
   return raw.map((entry, i) => {
     const where = `${collectionWhere}.externalMetadata[${i}]`;
     if (!isMapping(entry)) {
@@ -296,6 +391,16 @@ function parseExternalMetadata(raw, collectionWhere, source, toError) {
         `${source}: ${where}.file must be a non-empty string naming the manifest, relative to the config file.`
       );
     }
+    const placeholderProblem = pagePlaceholderProblem(entry.file);
+    if (placeholderProblem !== null) {
+      throw toError(`${source}: ${where}.file ${placeholderProblem}`);
+    }
+    const perPage = hasPagePlaceholder(entry.file);
+    if (perPage && (posix2.isAbsolute(entry.file) || win32.isAbsolute(entry.file))) {
+      throw toError(
+        `${source}: ${where}.file uses ${PAGE_PLACEHOLDER} in an absolute path, so every manifest would sit outside the repository. Make it relative to the config file.`
+      );
+    }
     if (!Array.isArray(entry.keys) || entry.keys.length === 0 || entry.keys.some((k) => !isNonEmptyString(k))) {
       throw toError(
         `${source}: ${where}.keys must be a non-empty list of key names.`
@@ -307,6 +412,11 @@ function parseExternalMetadata(raw, collectionWhere, source, toError) {
       if (problem !== null) {
         throw toError(`${source}: ${where}.file ${problem}.`);
       }
+      if (perPage) {
+        throw toError(
+          `${source}: ${where}.file uses ${PAGE_PLACEHOLDER} in a URL. A placeholder names a file this run can write, and a URL is not one.`
+        );
+      }
     }
     if (entry.tokenEnv !== void 0) {
       if (!isNonEmptyString(entry.tokenEnv)) {
@@ -336,6 +446,11 @@ function parseExternalMetadata(raw, collectionWhere, source, toError) {
         );
       }
     }
+    if (perPage && typeof entry.join === "string" && entry.join !== PATH_JOIN) {
+      throw toError(
+        `${source}: ${where}.file uses ${PAGE_PLACEHOLDER}, and join is "${entry.join}". A per-page manifest is found by path, so it cannot be keyed by a field. Remove ${PAGE_PLACEHOLDER}, or remove join.`
+      );
+    }
     const seen = /* @__PURE__ */ new Set();
     for (const key of keys) {
       if (key === SCHEMA_KEY) {
@@ -355,14 +470,46 @@ function parseExternalMetadata(raw, collectionWhere, source, toError) {
       }
       owners.set(key, i);
     }
-    return {
+    if (perPage) {
+      const pattern = normalizeManifestPattern(entry.file);
+      const first = patterns.get(pattern);
+      if (first !== void 0) {
+        throw toError(
+          `${source}: ${where}.file resolves to the same manifest as externalMetadata[${String(first)}].file for every page. Give each entry its own file name.`
+        );
+      }
+      patterns.set(pattern, i);
+    }
+    const parsed2 = {
       file: entry.file,
       keys,
       ...typeof entry.tokenEnv === "string" ? { tokenEnv: entry.tokenEnv } : {},
       ...typeof entry.join === "string" ? { join: entry.join } : {}
     };
+    origins.set(parsed2, { source, where });
+    return parsed2;
   });
 }
+function pagePlaceholderProblem(file) {
+  for (const match of file.matchAll(/\{[^{}]*\}/g)) {
+    if (match[0] !== PAGE_PLACEHOLDER) {
+      return `uses "${match[0]}", which is not a placeholder. The only placeholder is ${PAGE_PLACEHOLDER}.`;
+    }
+  }
+  const tokens2 = file.split(PAGE_PLACEHOLDER);
+  const stray = /[{}]/.exec(tokens2.join(""));
+  if (stray !== null) {
+    return `contains "${stray[0]}" outside a ${PAGE_PLACEHOLDER} placeholder. Remove it, or write ${PAGE_PLACEHOLDER}.`;
+  }
+  if (tokens2.length > 2) {
+    return `uses ${PAGE_PLACEHOLDER} twice. One manifest names one page.`;
+  }
+  return null;
+}
+var origins = /* @__PURE__ */ new WeakMap();
+function externalMetadataOrigin(entry) {
+  return origins.get(entry);
+}
 function selectCollections(collections, names, source, toError) {
   if (names === void 0 || names.length === 0) return [...collections];
   const wanted = new Set(names);
@@ -383,6 +530,9 @@ function selectCollections(collections, names, source, toError) {
 function isMember(collection, relPath) {
   if (relPath === STDIN) return false;
   if (relPath.startsWith("../")) return false;
+  return matchesCollectionPaths(collection, relPath);
+}
+function matchesCollectionPaths(collection, relPath) {
   const matched = collection.paths.some((entry) => {
     const normalized = normalizeEntry(entry);
     if (normalized === "") return false;
@@ -393,15 +543,15 @@ function isMember(collection, relPath) {
   return !collection.exclude.some((glob) => matchesFileGlob(relPath, glob));
 }
 function normalizeEntry(entry) {
-  const posix5 = entry.replace(/\\/g, "/").replace(/^\.\//, "");
-  return posix5.endsWith("/") ? posix5.slice(0, -1) : posix5;
+  const posix7 = entry.replace(/\\/g, "/").replace(/^\.\//, "");
+  return posix7.endsWith("/") ? posix7.slice(0, -1) : posix7;
 }
 function isGlob(entry) {
   return picomatch2.scan(entry).isGlob;
 }
 
 // src/shared/run.ts
-import { realpathSync } from "node:fs";
+import { realpathSync as realpathSync2 } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { CommanderError } from "commander";
 
@@ -472,7 +622,7 @@ function isMainModule(moduleUrl) {
   const entry = process.argv[1];
   if (!entry) return false;
   try {
-    return realpathSync(entry) === fileURLToPath(moduleUrl);
+    return realpathSync2(entry) === fileURLToPath(moduleUrl);
   } catch {
     return false;
   }
@@ -532,7 +682,7 @@ function diagnoseIntegrity(bytes, expected) {
 }
 
 // src/meta/extractors/frontmatter.ts
-import { parseDocument, LineCounter, isMap, isSeq, isScalar } from "yaml";
+import { parseDocument as parseDocument2, LineCounter as LineCounter2, isMap as isMap2, isSeq, isScalar as isScalar2 } from "yaml";
 import { parse as parseToml } from "smol-toml";
 
 // src/meta/extractors/date-value.ts
@@ -612,9 +762,9 @@ function buildLineMap(doc, lc, prefixLines) {
   map.set("", 1);
   const lineAt = (offset) => offset == null ? void 0 : lc.linePos(offset).line + prefixLines;
   const walk = (node, pointer) => {
-    if (isMap(node)) {
+    if (isMap2(node)) {
       for (const pair of node.items) {
-        const key = isScalar(pair.key) ? String(pair.key.value) : String(pair.key);
+        const key = isScalar2(pair.key) ? String(pair.key.value) : String(pair.key);
         const ptr = `${pointer}/${escapePointerSegment(key)}`;
         const line = lineAt(
           pair.key?.range?.[0]
@@ -668,8 +818,8 @@ function rootObject(parsed2, label) {
   throw new Error(`Invalid ${label} frontmatter: root must be an object`);
 }
 function parseYamlBlock(raw, prefixLines, format) {
-  const lc = new LineCounter();
-  const doc = parseDocument(raw, { lineCounter: lc });
+  const lc = new LineCounter2();
+  const doc = parseDocument2(raw, { lineCounter: lc });
   if (doc.errors.length > 0) {
     const e = doc.errors[0];
     throw new Error(`Invalid YAML frontmatter: ${e?.message ?? "parse error"}`);
@@ -693,8 +843,8 @@ function parseJsonBlock(raw, prefixLines, format) {
     );
   }
   const data = rootObject(parsed2, "JSON");
-  const lc = new LineCounter();
-  const doc = parseDocument(raw, { lineCounter: lc });
+  const lc = new LineCounter2();
+  const doc = parseDocument2(raw, { lineCounter: lc });
   const map = buildLineMap(doc, lc, prefixLines);
   return { data, present: true, format, lineFor: positionForFactory(map) };
 }
@@ -751,7 +901,7 @@ var DocmetaError = class extends ToolError {
 };
 
 // src/meta/extractors/frontmatter-write.ts
-import { parseDocument as parseDocument2, isMap as isMap2, isCollection } from "yaml";
+import { parseDocument as parseDocument3, isMap as isMap3, isCollection } from "yaml";
 import { parse as parseToml2, stringify as stringifyToml } from "smol-toml";
 
 // src/meta/extractors/patch-util.ts
@@ -874,13 +1024,13 @@ function mergeBlock(flavor, inner, patch, deletions = []) {
   }
 }
 function mergeYaml(inner, patch, deletions = []) {
-  const doc = parseDocument2(inner);
+  const doc = parseDocument3(inner);
   if (doc.errors.length > 0) {
     throw new DocmetaError(
       `Cannot rewrite invalid YAML front matter: ${doc.errors[0]?.message ?? "parse error"}`
     );
   }
-  if (doc.contents != null && !isMap2(doc.contents)) {
+  if (doc.contents != null && !isMap3(doc.contents)) {
     throw new DocmetaError(
       "Cannot rewrite front matter: the root must be a mapping."
     );
@@ -1041,7 +1191,7 @@ function parseBlock(flavor, text2) {
     case "toml":
       return text2.trim() === "" ? {} : parseToml2(text2);
     case "yaml": {
-      const doc = parseDocument2(text2);
+      const doc = parseDocument3(text2);
       if (doc.errors.length > 0) {
         throw new DocmetaError(
           `Cannot rewrite invalid YAML front matter: ${doc.errors[0]?.message ?? "parse error"}`
@@ -1308,8 +1458,8 @@ function ditaShape(content, root, filePath) {
   const lower = filePath?.toLowerCase() ?? "";
   const byExtension2 = (lower.endsWith(".dita") || lower.endsWith(".ditamap")) && DITA_ROOTS.has(name2);
   if (!byDoctype && !byClass && !byArch && !byExtension2) return void 0;
-  const isMap9 = /^\s*[-+]\s+map\//.test(cls) || MAP_ROOTS.has(name2) || lower.endsWith(".ditamap");
-  return isMap9 ? { kind: "map", container: "topicmeta", preamble: /* @__PURE__ */ new Set(["title"]) } : {
+  const isMap10 = /^\s*[-+]\s+map\//.test(cls) || MAP_ROOTS.has(name2) || lower.endsWith(".ditamap");
+  return isMap10 ? { kind: "map", container: "topicmeta", preamble: /* @__PURE__ */ new Set(["title"]) } : {
     kind: "topic",
     container: "metadata",
     preamble: /* @__PURE__ */ new Set([
@@ -2731,8 +2881,8 @@ function listFormats() {
 }
 
 // src/meta/core/write-file.ts
-import { writeFile, rename, rm, stat as stat2, chmod } from "node:fs/promises";
-import { dirname, join, basename, resolve } from "node:path";
+import { writeFile, rename, rm, stat as stat2, chmod, mkdir } from "node:fs/promises";
+import { dirname, join, basename, resolve as resolve2 } from "node:path";
 
 // src/meta/core/manifest-cache.ts
 import { stat } from "node:fs/promises";
@@ -2789,15 +2939,16 @@ 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((resolve22) => {
-  setTimeout(resolve22, ms);
+var wait = (ms) => new Promise((resolve23) => {
+  setTimeout(resolve23, ms);
 });
-async function writeFileAtomic(path, contents) {
+async function writeFileAtomic(path, contents, options = {}) {
   const tmp = join(
     dirname(path),
     `.${basename(path)}.manni-${process.pid}-${Math.random().toString(36).slice(2, 8)}.tmp`
   );
   try {
+    if (options.createParents === true) await mkdir(dirname(path), { recursive: true });
     await writeFile(tmp, contents);
     try {
       const { mode } = await stat2(path);
@@ -2827,13 +2978,13 @@ async function writeFileAtomic(path, contents) {
     }
   } finally {
     await rm(tmp, { force: true });
-    invalidateManifestCache(resolve(path));
+    invalidateManifestCache(resolve2(path));
   }
 }
 
 // src/meta/core/schema-cache.ts
 import { createHash as createHash2 } from "node:crypto";
-import { mkdir, readFile, stat as stat3 } from "node:fs/promises";
+import { mkdir as mkdir2, 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;
@@ -2926,7 +3077,7 @@ var SchemaCache = class {
       schema
     };
     try {
-      await mkdir(this.dir, { recursive: true });
+      await mkdir2(this.dir, { recursive: true });
       await writeFileAtomic(
         this.entryPath(url),
         `${JSON.stringify(entry, null, 2)}
@@ -5344,8 +5495,8 @@ var SCHEMA_KEYS = [
   "multipleOf"
 ];
 var RETRY_DELAY_MS = 500;
-var wait2 = (ms) => new Promise((resolve22) => {
-  setTimeout(resolve22, ms);
+var wait2 = (ms) => new Promise((resolve23) => {
+  setTimeout(resolve23, ms);
 });
 var RetryableFetchError = class extends DocmetaError {
 };
@@ -5598,7 +5749,7 @@ async function loadSchema(ref, options = {}) {
 }
 
 // src/meta/core/resolve-schema.ts
-import { isAbsolute, relative, resolve as resolve2 } from "node:path";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3 } from "node:path";
 var DEFAULT_SCHEMAS = Object.freeze([
   "google:okf:0.1",
   "passo-uno:seven-action:1.0"
@@ -5620,8 +5771,8 @@ function collectSchemaPins(config) {
   return pins;
 }
 function rebaseConfigSchemaRefs(config, configDir, cwd) {
-  if (resolve2(configDir) === resolve2(cwd)) return config;
-  const rebase2 = (ref) => classifyRef(ref).kind === "file" && !isAbsolute(ref) ? resolve2(configDir, ref) : ref;
+  if (resolve3(configDir) === resolve3(cwd)) return config;
+  const rebase2 = (ref) => classifyRef(ref).kind === "file" && !isAbsolute2(ref) ? resolve3(configDir, ref) : ref;
   const rebaseEntry = (entry) => typeof entry === "string" ? rebase2(entry) : {
     ...entry,
     ref: rebase2(entry.ref),
@@ -5697,9 +5848,9 @@ function assertDocumentRefAllowed(ref, mode, params) {
   }
   const root = params.trustRoot;
   if (!root) return;
-  const abs = resolve2(params.fileBase ?? process.cwd(), ref);
-  const within = relative(root.dir, abs);
-  if (within !== "" && !within.startsWith("..") && !isAbsolute(within)) return;
+  const abs = resolve3(params.fileBase ?? process.cwd(), ref);
+  const within = relative2(root.dir, abs);
+  if (within !== "" && !within.startsWith("..") && !isAbsolute2(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`;
   const scope = root.source === "git" ? "the repository" : "the project";
   throw new DocmetaError(
@@ -5849,12 +6000,12 @@ function isPlainObject(v) {
 }
 
 // src/meta/core/config.ts
-import { resolve as resolve6 } from "node:path";
+import { resolve as resolve7 } 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 resolve5 } from "node:path";
+import { basename as basename2, dirname as dirname3, join as join4, relative as relative3, resolve as resolve6 } from "node:path";
 import { parse as parseYaml } from "yaml";
 
 // src/shared/encryption.ts
@@ -5985,9 +6136,9 @@ function keyedPin(text2, key) {
 
 // src/shared/git-root.ts
 import { existsSync } from "node:fs";
-import { dirname as dirname2, join as join3, resolve as resolve3 } from "node:path";
+import { dirname as dirname2, join as join3, resolve as resolve4 } from "node:path";
 function findGitRoot(cwd) {
-  let dir = resolve3(cwd);
+  let dir = resolve4(cwd);
   for (; ; ) {
     if (existsSync(join3(dir, ".git"))) return dir;
     const parent = dirname2(dir);
@@ -5996,7 +6147,7 @@ function findGitRoot(cwd) {
   }
 }
 function searchPath(cwd) {
-  const start = resolve3(cwd);
+  const start = resolve4(cwd);
   const root = findGitRoot(start);
   if (root === null) return [start];
   const chain = [];
@@ -6011,7 +6162,7 @@ function searchPath(cwd) {
 }
 
 // src/shared/tools.ts
-import { isAbsolute as isAbsolute2, resolve as resolve4 } from "node:path";
+import { isAbsolute as isAbsolute3, resolve as resolve5 } from "node:path";
 var TOOL_KEYS = ["vale"];
 var VALE_KEYS = ["config"];
 function isMapping2(value) {
@@ -6056,7 +6207,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 : resolve4(configDir, config);
+  return isAbsolute3(config) ? config : resolve5(configDir, config);
 }
 
 // src/shared/warn.ts
@@ -6161,7 +6312,7 @@ function tolerantKeysOf(document) {
   };
 }
 function relativeSource(cwd, path) {
-  return relative2(cwd, path).replace(/\\/g, "/");
+  return relative3(cwd, path).replace(/\\/g, "/");
 }
 function mooseWarning(name2) {
   return `"${name2}" is the pre-rename name of the family config file. Rename it to "${FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml"}".`;
@@ -6171,7 +6322,7 @@ var FAMILY_FILES = [
   { names: MOOSE_CONFIG_NAMES, kind: "moose" }
 ];
 async function findConfigFile(cwd, opts) {
-  const start = resolve5(cwd);
+  const start = resolve6(cwd);
   for (const dir of searchPath(start)) {
     for (const { names, kind } of FAMILY_FILES) {
       for (const name2 of names) {
@@ -6219,7 +6370,7 @@ async function findConfigFile(cwd, opts) {
   return null;
 }
 async function readConfigFile(explicitPath, cwd, opts) {
-  const path = resolve5(cwd, explicitPath);
+  const path = resolve6(cwd, explicitPath);
   const document = await readDocument(path, explicitPath, opts.toError);
   if (document === null) {
     throw opts.toError(`Config file not found: "${explicitPath}".`);
@@ -6243,7 +6394,7 @@ async function readConfigFile(explicitPath, cwd, opts) {
   };
 }
 async function findFamilyConfigFile(cwd, toError) {
-  const start = resolve5(cwd);
+  const start = resolve6(cwd);
   for (const dir of searchPath(start)) {
     for (const { names, kind } of FAMILY_FILES) {
       for (const name2 of names) {
@@ -6270,7 +6421,7 @@ async function findFamilyConfigFile(cwd, toError) {
   return null;
 }
 async function readFamilyConfigFile(explicitPath, cwd, toError) {
-  const path = resolve5(cwd, explicitPath);
+  const path = resolve6(cwd, explicitPath);
   const document = await readDocument(path, explicitPath, toError);
   if (document === null) {
     throw toError(`Config file not found: "${explicitPath}".`);
@@ -6939,8 +7090,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: resolve6(configDir), source: "config" };
-  return { dir: resolve6(cwd), source: "cwd" };
+  if (configDir !== void 0) return { dir: resolve7(configDir), source: "config" };
+  return { dir: resolve7(cwd), source: "cwd" };
 }
 async function loadConfig(explicitPath, cwd = process.cwd()) {
   const file = explicitPath ? await readConfigFile(explicitPath, cwd, CONFIG_FILE) : await findConfigFile(cwd, CONFIG_FILE);
@@ -7003,23 +7154,23 @@ async function resolveRunConfig(opts) {
 }
 
 // src/meta/reporters/sarif.ts
-import { isAbsolute as isAbsolute3 } from "node:path";
+import { isAbsolute as isAbsolute4 } from "node:path";
 
 // src/meta/core/baseline.ts
 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 resolve9 } from "node:path";
+import { relative as relative6, resolve as resolve10 } from "node:path";
 
 // src/meta/core/load-files.ts
 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 { extname, relative as relative5, resolve as resolve9 } from "node:path";
+import fg2 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 resolve7, sep } from "node:path";
+import { dirname as dirname4, relative as relative4, resolve as resolve8, sep as sep2 } 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(),
@@ -7033,7 +7184,7 @@ async function gitIgnored(paths, cwd) {
   const byRoot = /* @__PURE__ */ new Map();
   let inSomeRepo = false;
   for (const spelled of paths) {
-    const abs = resolve7(cwd, spelled);
+    const abs = resolve8(cwd, spelled);
     const dir = dirname4(abs);
     let root = rootOf.get(dir);
     if (root === void 0) {
@@ -7042,7 +7193,7 @@ async function gitIgnored(paths, cwd) {
     }
     if (root === null) continue;
     inSomeRepo = true;
-    const rel = relative3(root, abs).split(sep).join("/");
+    const rel = relative4(root, abs).split(sep2).join("/");
     const bucket = byRoot.get(root);
     if (bucket) bucket.push({ rel, spelled });
     else byRoot.set(root, [{ rel, spelled }]);
@@ -7145,14 +7296,14 @@ async function resolveTargetSet(opts) {
   for (const input of opts.inputs) {
     if (input === STDIN_TOKEN) continue;
     const posixInput = toPosix(input);
-    const abs = resolve8(cwd, posixInput);
+    const abs = resolve9(cwd, posixInput);
     const st = await statOrNull(abs);
     if (st?.isFile()) {
-      named.add(toPosix(relative4(cwd, abs)));
+      named.add(toPosix(relative5(cwd, abs)));
       continue;
     }
     if (st?.isDirectory()) {
-      const found2 = await fg(`${posixInput}/**/*`, {
+      const found2 = await fg2(`${posixInput}/**/*`, {
         cwd,
         ignore,
         onlyFiles: true,
@@ -7165,7 +7316,7 @@ async function resolveTargetSet(opts) {
       missing.push(posixInput);
       continue;
     }
-    const found = await fg(posixInput, {
+    const found = await fg2(posixInput, {
       cwd,
       ignore,
       onlyFiles: true,
@@ -7230,13 +7381,13 @@ 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, resolve9(from, file)).replace(/\\/g, "/");
+  return relative6(ctx.base, resolve10(from, file)).replace(/\\/g, "/");
 }
 function canonicalSchemaRef(ref, ctx) {
   if (!ctx) return ref;
   if (classifyRef(ref).kind !== "file") return ref;
-  const abs = resolve9(ctx.cwd, ref);
-  return relative5(ctx.base, abs).replace(/\\/g, "/");
+  const abs = resolve10(ctx.cwd, ref);
+  return relative6(ctx.base, abs).replace(/\\/g, "/");
 }
 function fingerprint(e, ctx) {
   const parts = [
@@ -7393,17 +7544,17 @@ function countFingerprints(baseline) {
 }
 function resolveBaselineRequest(opts, configured, configDir, cwd, defaults) {
   const named = (label) => ({
-    absPath: resolve9(cwd, label),
+    absPath: resolve10(cwd, label),
     label
   });
   const implied = () => {
     const base = configDir ?? cwd;
     if (configured !== void 0) {
-      return { absPath: resolve9(base, configured), label: configured };
+      return { absPath: resolve10(base, configured), label: configured };
     }
-    const current = resolve9(base, defaults.current);
+    const current = resolve10(base, defaults.current);
     if (defaults.legacy !== void 0) {
-      const legacy = resolve9(base, defaults.legacy);
+      const legacy = resolve10(base, defaults.legacy);
       if (!existsSync2(current) && existsSync2(legacy)) {
         warn(
           `"${defaults.legacy}" is the pre-rename baseline file name. Rename it to "${defaults.current}".`
@@ -7516,7 +7667,7 @@ function uriFrame(frame) {
 }
 function artifactUri(file, frame) {
   const uri = canonicalFilePath(file, frame);
-  if (uri === "" || uri.startsWith("../") || isAbsolute3(uri)) return null;
+  if (uri === "" || uri.startsWith("../") || isAbsolute4(uri)) return null;
   return uri;
 }
 function renderSarif(results, opts = {}) {
@@ -7910,22 +8061,92 @@ 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 resolve11, sep as sep2 } from "node:path";
+import { isAbsolute as isAbsolute5, relative as relative8, resolve as resolve12, sep as sep3 } from "node:path";
 import {
-  LineCounter as LineCounter2,
-  isMap as isMap4,
-  isNode,
-  isScalar as isScalar2,
+  LineCounter as LineCounter3,
+  isMap as isMap5,
+  isNode as isNode2,
+  isScalar as isScalar3,
   isSeq as isSeq2,
-  parseDocument as parseDocument4
+  parseDocument as parseDocument5
 } from "yaml";
 
+// src/shared/manifest-cas.ts
+import { posix as posix3 } 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, absent = false) {
+  return { path, file, before, text: before, ops: [], bases: /* @__PURE__ */ new Map(), absent };
+}
+function encodeValue(value) {
+  return value === void 0 ? "absent" : JSON.stringify(value);
+}
+function baseKey(at2) {
+  const entry = at2.join === "path" ? posix3.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();
+  held.absent = false;
+}
+async function settle(held, io) {
+  for (let attempt = 1; attempt <= COMMIT_ATTEMPTS; attempt++) {
+    let current;
+    try {
+      current = await io.read(held.path);
+    } catch (error) {
+      if (held.absent && isMissing(error)) {
+        await io.write(held.path, held.text);
+        held.absent = false;
+        return;
+      }
+      const reason = error instanceof Error ? error.message : String(error);
+      throw io.toError(`Manifest ${held.file} could not be read: ${reason}`);
+    }
+    if (!held.absent && 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;
+    held.absent = false;
+  }
+  throw io.toError(conflictRefusal(held.file));
+}
+function isMissing(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
 // 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 resolve10 } from "node:path";
+import { basename as basename4, dirname as dirname6, join as join6, relative as relative7, resolve as resolve11 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
-import { isMap as isMap3, parseDocument as parseDocument3, parse as parseYaml3, stringify } from "yaml";
+import { isMap as isMap4, parseDocument as parseDocument4, parse as parseYaml3, stringify } from "yaml";
 
 // src/shared/write-file.ts
 import { chmod as chmod2, rename as rename2, rm as rm2, stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
@@ -7935,8 +8156,8 @@ 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((resolve22) => {
-  setTimeout(resolve22, ms);
+var wait3 = (ms) => new Promise((resolve23) => {
+  setTimeout(resolve23, ms);
 });
 async function writeTextAtomic(path, text2) {
   const tmp = join5(
@@ -7985,7 +8206,7 @@ function resolveEncryptionKey(opts) {
   return { key: void 0, source: "none" };
 }
 function relativeSource2(cwd, path) {
-  return relative6(resolve10(cwd), path).replace(/\\/g, "/");
+  return relative7(resolve11(cwd), path).replace(/\\/g, "/");
 }
 function errorCode3(err) {
   return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
@@ -8008,7 +8229,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) ?? resolve10(cwd);
+  const root = findGitRoot(cwd) ?? resolve11(cwd);
   for (const name2 of [...FAMILY_CONFIG_NAMES, ...MOOSE_CONFIG_NAMES]) {
     const path2 = join6(root, name2);
     const text2 = await readIfPresent(path2);
@@ -8018,12 +8239,12 @@ async function defaultTarget(cwd) {
   return { path, source: relativeSource2(cwd, path), text: null };
 }
 function withKey(text2, key, previous, source, toError) {
-  const doc = parseDocument3(text2);
+  const doc = parseDocument4(text2);
   const [first] = doc.errors;
   if (first !== void 0) {
     throw toError(`${source}: invalid YAML: ${first.message}`);
   }
-  if (doc.contents !== null && !isMap3(doc.contents)) {
+  if (doc.contents !== null && !isMap4(doc.contents)) {
     throw toError(`${source}: top level must be a mapping.`);
   }
   doc.set(ENCRYPTION_KEY_FIELD, key);
@@ -8293,18 +8514,20 @@ function redactedDerived(f) {
 var EXTERNAL_OWNED_SCHEMA = "external:owned";
 var EXTERNAL_DUPLICATE_SCHEMA = "external:duplicate";
 var EXTERNAL_KEYWORD = "external";
-var PATH_JOIN = "path";
+var PATH_JOIN2 = "path";
 var parsedManifests = new ManifestCache();
-var posix = (p) => p.split(sep2).join("/");
+var perPageRules = /* @__PURE__ */ new WeakMap();
+var strayEntries = /* @__PURE__ */ new WeakSet();
+var posix4 = (p) => p.split(sep3).join("/");
 function reportedPath(abs, base) {
-  const rel = relative7(base, abs);
-  return rel === "" ? "." : posix(rel);
+  const rel = relative8(base, abs);
+  return rel === "" ? "." : posix4(rel);
 }
 function reported(of, file) {
   return of.file === file ? of : { ...of, file };
 }
 function externalMetadataJoin(manifest) {
-  return manifest.join ?? PATH_JOIN;
+  return manifest.join ?? PATH_JOIN2;
 }
 async function loadExternalMetadata(collections, opts) {
   const configured = collections.flatMap(
@@ -8315,7 +8538,17 @@ async function loadExternalMetadata(collections, opts) {
   const byPath = /* @__PURE__ */ new Map();
   const byField = /* @__PURE__ */ new Map();
   const entries = [];
+  const resolvedBy = /* @__PURE__ */ new Map();
+  const rules = [];
   for (const { collection, manifest } of configured) {
+    const declared = collections.find(
+      (c) => c.name === collection && c.externalMetadata.includes(manifest)
+    );
+    if (declared !== void 0 && classifyRef(manifest.file).kind !== "url" && hasPagePlaceholder(manifest.file)) {
+      await loadPerPage(declared, manifest, opts, resolvedBy, { owners, byPath, byField, entries });
+      rules.push({ collection: declared, manifest, configDir: opts.configDir });
+      continue;
+    }
     const join11 = externalMetadataJoin(manifest);
     let parsed2;
     let file;
@@ -8329,7 +8562,7 @@ async function loadExternalMetadata(collections, opts) {
       });
       parsed2 = parseManifest(manifest, collection, text2, file, opts.configDir, join11);
     } else {
-      const abs = isAbsolute4(manifest.file) ? manifest.file : resolve11(opts.configDir, manifest.file);
+      const abs = isAbsolute5(manifest.file) ? manifest.file : resolve12(opts.configDir, manifest.file);
       const label = reportedPath(abs, opts.base);
       file = label;
       parsed2 = await parsedManifests.parse(
@@ -8367,7 +8600,7 @@ async function loadExternalMetadata(collections, opts) {
       else owners.set(key, [{ collection, file }]);
     }
     let target;
-    if (join11 === PATH_JOIN) {
+    if (join11 === PATH_JOIN2) {
       target = byPath;
     } else {
       const existing = byField.get(join11);
@@ -8384,23 +8617,112 @@ async function loadExternalMetadata(collections, opts) {
     }
     for (const entry of parsed2.entries) entries.push(reported(entry, file));
   }
-  return { owners, byPath, byField, entries };
+  const index = { owners, byPath, byField, entries };
+  if (rules.length > 0) perPageRules.set(index, rules);
+  return index;
+}
+async function loadPerPage(declared, manifest, opts, resolvedBy, into) {
+  const collection = declared.name;
+  const join11 = externalMetadataJoin(manifest);
+  for (const key of manifest.keys) {
+    const list2 = into.owners.get(key);
+    if (list2) list2.push({ collection, file: manifest.file });
+    else into.owners.set(key, [{ collection, file: manifest.file }]);
+  }
+  const target = indexFor(join11, into);
+  for (const pageAbs of opts.pages ?? []) {
+    const resolved = pageManifestPath(manifest.file, opts.configDir, pageAbs);
+    if ("outside" in resolved) {
+      if (resolved.pageRel.startsWith("../") && matchesCollectionPaths(declared, resolved.pageRel)) {
+        throw new DocmetaError(outsideRefusal(manifest, collection, resolved.pageRel));
+      }
+      continue;
+    }
+    const rel = posix4(relative8(opts.configDir, pageAbs));
+    if (!isMember(declared, rel)) continue;
+    const earlier = resolvedBy.get(resolved.abs);
+    if (earlier !== void 0 && earlier !== pageAbs) {
+      const [a, b] = [reportedPath(earlier, opts.base), reportedPath(pageAbs, opts.base)].sort();
+      throw new DocmetaError(
+        `${a ?? ""} and ${b ?? ""} both resolve ${PAGE_PLACEHOLDER} to ${reportedPath(resolved.abs, opts.base)}. A ${PAGE_PLACEHOLDER} manifest names one page, so rename one of them.`
+      );
+    }
+    resolvedBy.set(resolved.abs, pageAbs);
+    const label = reportedPath(resolved.abs, opts.base);
+    const parsed2 = await parsedManifests.parse(
+      resolved.abs,
+      JSON.stringify([collection, join11, opts.configDir, [...manifest.keys].sort()]),
+      async () => parseManifest(
+        manifest,
+        collection,
+        await readPageManifest(resolved.abs, label),
+        label,
+        opts.configDir,
+        join11
+      )
+    );
+    const pageLabel = reportedPath(pageAbs, opts.base);
+    for (const entry of parsed2.entries) {
+      if (entry.abs === void 0 || sameFile(entry.abs, pageAbs)) continue;
+      const at2 = entry.line === void 0 ? label : `${label}:${String(entry.line)}`;
+      throw new DocmetaError(
+        `Manifest ${at2} names "${entry.spelled}", but ${PAGE_PLACEHOLDER} resolved this file for "${pageLabel}". A per-page manifest holds one entry, for its own page.`
+      );
+    }
+    for (const [indexKey, values] of parsed2.values) {
+      const key = join11 === PATH_JOIN2 ? pageAbs : indexKey;
+      const merged = target.get(key) ?? /* @__PURE__ */ new Map();
+      for (const [owned, value] of values) merged.set(owned, reported(value, label));
+      target.set(key, merged);
+    }
+    for (const entry of parsed2.entries) {
+      into.entries.push({
+        ...reported(entry, label),
+        ...entry.abs === void 0 ? {} : { abs: pageAbs }
+      });
+    }
+  }
+}
+function indexFor(join11, into) {
+  if (join11 === PATH_JOIN2) return into.byPath;
+  const existing = into.byField.get(join11);
+  if (existing) return existing;
+  const created = /* @__PURE__ */ new Map();
+  into.byField.set(join11, created);
+  return created;
+}
+function outsideRefusal(manifest, collection, pageRel) {
+  const tail = `for "${pageRel}". A ${PAGE_PLACEHOLDER} manifest stays under the config file.`;
+  const origin = externalMetadataOrigin(manifest);
+  if (origin === void 0) {
+    return `externalMetadata file "${manifest.file}" of collection ${collection} resolves outside the config file's directory ${tail}`;
+  }
+  return `${origin.source}: ${origin.where}.file resolves outside ${origin.source}'s directory ${tail}`;
+}
+async function readPageManifest(abs, file) {
+  try {
+    return await readFile6(abs, "utf8");
+  } catch (err) {
+    if (isMissing(err)) return "";
+    throw unreadable(file, err);
+  }
 }
 async function readManifest(abs, file) {
   try {
     return await readFile6(abs, "utf8");
   } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    throw new DocmetaError(
-      `Manifest ${file} could not be read: ${reason}`
-    );
+    throw unreadable(file, err);
   }
 }
+function unreadable(file, err) {
+  const reason = err instanceof Error ? err.message : String(err);
+  return new DocmetaError(`Manifest ${file} could not be read: ${reason}`);
+}
 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 lc = new LineCounter3();
+  const doc = parseDocument5(text2, { lineCounter: lc, uniqueKeys: false });
   const problem = doc.errors[0];
   if (problem) {
     throw new DocmetaError(
@@ -8408,21 +8730,21 @@ function parseManifest(manifest, collection, text2, file, configDir, join11) {
     );
   }
   const root = doc.contents;
-  if (root === null || isScalar2(root) && root.value === null)
+  if (root === null || isScalar3(root) && root.value === null)
     return { values: target, entries };
-  if (!isMap4(root)) {
+  if (!isMap5(root)) {
     throw new DocmetaError(
-      `Manifest ${file}: the manifest must be a mapping from document ${join11 === PATH_JOIN ? "path" : `"${join11}"`} to owned keys.`
+      `Manifest ${file}: the manifest must be a mapping from document ${join11 === PATH_JOIN2 ? "path" : `"${join11}"`} to owned keys.`
     );
   }
   const owned = new Set(manifest.keys);
   const lineAt = (node) => {
-    const range = isNode(node) ? node.range : void 0;
+    const range = isNode2(node) ? node.range : void 0;
     return range ? lc.linePos(range[0]).line : void 0;
   };
   const seen = /* @__PURE__ */ new Map();
   for (const pair of root.items) {
-    const spelled = isScalar2(pair.key) ? String(pair.key.value) : String(pair.key);
+    const spelled = isScalar3(pair.key) ? String(pair.key.value) : String(pair.key);
     const entryLine = lineAt(pair.key);
     const where = entryLine === void 0 ? file : `${file}:${entryLine}`;
     if (seen.has(spelled)) {
@@ -8432,15 +8754,15 @@ function parseManifest(manifest, collection, text2, file, configDir, join11) {
       );
     }
     seen.set(spelled, entryLine);
-    if (!isMap4(pair.value)) {
+    if (!isMap5(pair.value)) {
       throw new DocmetaError(
         `Manifest ${where}: "${spelled}" must be a mapping of owned keys to values.`
       );
     }
-    const indexKey = join11 === PATH_JOIN ? resolve11(configDir, spelled) : spelled;
+    const indexKey = join11 === PATH_JOIN2 ? resolve12(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);
+      const key = isScalar3(kv.key) ? String(kv.key.value) : String(kv.key);
       if (key === FILE_SCHEMA_KEY) {
         throw new DocmetaError(
           `Manifest ${where}: "${spelled}" sets "${FILE_SCHEMA_KEY}" \u2014 a manifest never chooses the schema a document is judged by; use "overrides" in the config.`
@@ -8466,7 +8788,7 @@ function parseManifest(manifest, collection, text2, file, configDir, join11) {
     entries.push({
       collection,
       join: join11,
-      ...join11 === PATH_JOIN ? { abs: indexKey } : {},
+      ...join11 === PATH_JOIN2 ? { abs: indexKey } : {},
       spelled,
       file,
       ...entryLine === void 0 ? {} : { line: entryLine }
@@ -8475,9 +8797,9 @@ function parseManifest(manifest, collection, text2, file, configDir, join11) {
   return { values: target, entries };
 }
 function nodeLines(node, lineAt, prefix = "", out = /* @__PURE__ */ new Map()) {
-  if (isMap4(node)) {
+  if (isMap5(node)) {
     for (const kv of node.items) {
-      const seg = isScalar2(kv.key) ? String(kv.key.value) : String(kv.key);
+      const seg = isScalar3(kv.key) ? String(kv.key.value) : String(kv.key);
       const pointer = `${prefix}/${escapePointerSegment(seg)}`;
       const line = lineAt(kv.key) ?? lineAt(kv.value);
       if (line !== void 0) out.set(pointer, line);
@@ -8516,7 +8838,7 @@ function mergeExternalMetadata(label, extracted, index, memberOf2, base, options
   const sources = [];
   const joins = [];
   if (label !== STDIN_LABEL) {
-    const byPath = index.byPath.get(resolve11(base, label));
+    const byPath = index.byPath.get(resolve12(base, label));
     if (byPath) sources.push(byPath);
   }
   for (const [field, byValue] of index.byField) {
@@ -8611,10 +8933,41 @@ function externalMetadataPointer(key) {
 }
 function orphanEntries(index, loaded, base, collections) {
   if (!index) return [];
-  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)
+  const have = new Set(loaded.map((l) => resolve12(base, l)));
+  const orphans = index.entries.filter(
+    (e) => inCollections(e, collections) && e.join === PATH_JOIN2 && e.abs !== void 0 && !have.has(e.abs)
   );
+  if (collections !== void 0) return orphans;
+  return [...orphans, ...strayManifests(perPageRules.get(index) ?? [], have, base)];
+}
+function strayManifests(rules, loaded, base) {
+  const strays = [];
+  for (const { collection, manifest, configDir } of rules) {
+    const read = /* @__PURE__ */ new Set();
+    for (const pageAbs of loaded) {
+      const resolved = pageManifestPath(manifest.file, configDir, pageAbs);
+      if (!("outside" in resolved)) read.add(resolved.abs);
+    }
+    const found = findPageManifests(manifest.file, configDir, (rel) => isMember(collection, rel));
+    for (const { abs, entries } of found) {
+      if (read.has(abs)) continue;
+      const file = reportedPath(abs, base);
+      for (const entry of entries) {
+        if (loaded.has(entry.pageAbs)) continue;
+        const stray = {
+          collection: collection.name,
+          join: PATH_JOIN2,
+          abs: entry.pageAbs,
+          spelled: entry.spelled,
+          file,
+          ...entry.line === void 0 ? {} : { line: entry.line }
+        };
+        strayEntries.add(stray);
+        strays.push(stray);
+      }
+    }
+  }
+  return strays;
 }
 function inCollections(entry, collections) {
   return collections === void 0 || collections.includes(entry.collection);
@@ -8622,7 +8975,7 @@ function inCollections(entry, collections) {
 function orphanJoins(index, matched, collections) {
   if (!index) return [];
   return index.entries.filter(
-    (e) => inCollections(e, collections) && e.join !== PATH_JOIN && !(matched.get(e.join)?.has(e.spelled) ?? false)
+    (e) => inCollections(e, collections) && e.join !== PATH_JOIN2 && !(matched.get(e.join)?.has(e.spelled) ?? false)
   );
 }
 function orphanError(orphans) {
@@ -8630,9 +8983,10 @@ function orphanError(orphans) {
   if (!first) throw new Error("orphanError called with no orphans");
   const where = first.line === void 0 ? first.file : `${first.file}:${first.line}`;
   const more = orphans.length > 1 ? ` (${orphans.length - 1} more)` : "";
-  const what = first.join === PATH_JOIN ? `names "${first.spelled}", which this run did not load` : `names ${first.join} "${first.spelled}", which no loaded document carries`;
+  const what = first.join === PATH_JOIN2 ? `names "${first.spelled}", which this run did not load` : `names ${first.join} "${first.spelled}", which no loaded document carries`;
+  const remove = strayEntries.has(first) ? "the file" : "it";
   return new DocmetaError(
-    `Manifest ${where} ${what}${more}. Fix the entry, or remove it.`
+    `Manifest ${where} ${what}${more}. Fix the entry, or remove ${remove}.`
   );
 }
 
@@ -8646,7 +9000,7 @@ function isFieldLocation(value) {
 }
 
 // src/meta/core/collections.ts
-import { isAbsolute as isAbsolute5, relative as relative8, resolve as resolvePath2, sep as sep3 } from "node:path";
+import { isAbsolute as isAbsolute6, relative as relative9, resolve as resolvePath2, sep as sep4 } from "node:path";
 
 // src/meta/core/projection.ts
 var SYSTEM_COLUMNS = ["_path", "_format", "_present", "_data"];
@@ -8867,8 +9221,8 @@ function loadSqlite() {
 function memberOf(collections, configDir, base, label) {
   if (collections.length === 0) return [];
   if (label === STDIN_LABEL) return [];
-  const rel = relative8(configDir, resolvePath2(base, label)).split(sep3).join("/");
-  if (isAbsolute5(rel)) return [];
+  const rel = relative9(configDir, resolvePath2(base, label)).split(sep4).join("/");
+  if (isAbsolute6(rel)) return [];
   return collections.filter((c) => isMember(c, rel)).map((c) => c.name);
 }
 function retainMembers(files, membersFor) {
@@ -9322,7 +9676,7 @@ function toFieldError(schema, e, lineFor, colFor, locate) {
 
 // src/meta/core/derive/cache.ts
 import { createHash as createHash4 } from "node:crypto";
-import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join as join7 } from "node:path";
 var REVIEW_CACHE_DIR = ".manni/meta/review-cache";
 var REVIEW_CACHE_VERSION = 1;
@@ -9342,7 +9696,7 @@ var ReviewCache = class {
     if (!this.enabled) return void 0;
     let raw;
     try {
-      raw = JSON.parse(readFileSync(this.entryPath(key), "utf8"));
+      raw = JSON.parse(readFileSync2(this.entryPath(key), "utf8"));
     } catch {
       return void 0;
     }
@@ -9906,12 +10260,12 @@ function utcDate(iso) {
 }
 
 // src/meta/core/derive/index.ts
-import { dirname as dirname9, resolve as resolve13 } from "node:path";
+import { dirname as dirname9, resolve as resolve14 } 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 resolve12, sep as sep4 } from "node:path";
+import { dirname as dirname7, relative as relative10, resolve as resolve13, sep as sep5 } from "node:path";
 import picomatch4 from "picomatch";
 var CODEOWNERS_LOCATIONS = [
   ".github/CODEOWNERS",
@@ -9921,11 +10275,11 @@ var CODEOWNERS_LOCATIONS = [
 ];
 function findCodeowners(root, explicit) {
   if (explicit !== void 0) {
-    const path = resolve12(root, explicit);
+    const path = resolve13(root, explicit);
     return existsSync3(path) ? path : null;
   }
   for (const loc of CODEOWNERS_LOCATIONS) {
-    const path = resolve12(root, ...loc.split("/"));
+    const path = resolve13(root, ...loc.split("/"));
     if (existsSync3(path)) return path;
   }
   return null;
@@ -10040,7 +10394,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 : resolve12(opts.configDir ?? process.cwd(), opts.explicit);
+  const explicitPath = opts.explicit === void 0 ? void 0 : resolve13(opts.configDir ?? process.cwd(), opts.explicit);
   if (explicitPath !== void 0 && !existsSync3(explicitPath)) {
     return {
       status: { available: false, reason: `CODEOWNERS not found at ${explicitPath}` },
@@ -10070,7 +10424,7 @@ async function deriveFromCodeowners(inputs, opts) {
       continue;
     }
     found += 1;
-    const label = toPosix2(relative9(opts.configDir ?? root, path));
+    const label = toPosix2(relative10(opts.configDir ?? root, path));
     const key = `${path}\0${label}`;
     let file = parsed2.get(key);
     if (!file) {
@@ -10092,7 +10446,7 @@ async function deriveFromCodeowners(inputs, opts) {
       };
     }
     for (const input of bucket) {
-      const rel = toPosix2(relative9(root, input.absPath));
+      const rel = toPosix2(relative10(root, input.absPath));
       const hit = ownersFor(owners, rel);
       records.set(
         input.label,
@@ -10116,13 +10470,13 @@ async function deriveFromCodeowners(inputs, opts) {
   return { status: { available: true }, records };
 }
 function toPosix2(p) {
-  return p.split(sep4).join("/");
+  return p.split(sep5).join("/");
 }
 
 // src/meta/core/derive/git.ts
 import { constants as bufferConstants } from "node:buffer";
 import { spawn as spawn3 } from "node:child_process";
-import { dirname as dirname8, extname as extname2, isAbsolute as isAbsolute6, posix as posix2, relative as relative10, sep as sep5 } from "node:path";
+import { dirname as dirname8, extname as extname2, isAbsolute as isAbsolute7, posix as posix5, relative as relative11, sep as sep6 } from "node:path";
 import { parse as parseYaml4 } from "yaml";
 
 // src/shared/pin.ts
@@ -10772,7 +11126,7 @@ function groupByRoot(inputs) {
       rootOf.set(dir, root);
     }
     if (root === null) continue;
-    const rel = relative10(root, input.absPath).split(sep5).join("/");
+    const rel = relative11(root, input.absPath).split(sep6).join("/");
     const bucket = byRoot.get(root);
     if (bucket) bucket.push({ input, rel });
     else byRoot.set(root, [{ input, rel }]);
@@ -11225,14 +11579,14 @@ async function commitEvidence(run2, root, entry, blame, history, blobs, manifest
   return commits;
 }
 function insideRoot(root, abs) {
-  const rel = relative10(root, abs);
-  if (rel === "" || rel.startsWith("..") || isAbsolute6(rel)) return void 0;
-  return rel.split(sep5).join("/");
+  const rel = relative11(root, abs);
+  if (rel === "" || rel.startsWith("..") || isAbsolute7(rel)) return void 0;
+  return rel.split(sep6).join("/");
 }
 function entryAt(entry, rel, relAtCommit) {
   if (relAtCommit === rel) return entry;
-  const fromHere = posix2.relative(posix2.dirname(rel), relAtCommit);
-  return posix2.join(posix2.dirname(entry), fromHere);
+  const fromHere = posix5.relative(posix5.dirname(rel), relAtCommit);
+  return posix5.join(posix5.dirname(entry), fromHere);
 }
 function manifestStamp(text2, key, join11) {
   if (text2 === void 0) return [];
@@ -11244,7 +11598,7 @@ function manifestStamp(text2, key, join11) {
   }
   if (!isRecord5(data)) return [];
   for (const [candidate, value] of Object.entries(data)) {
-    const same2 = join11 === "path" ? posix2.normalize(candidate) === posix2.normalize(key) : candidate === key;
+    const same2 = join11 === "path" ? posix5.normalize(candidate) === posix5.normalize(key) : candidate === key;
     if (same2 && isRecord5(value)) return provenanceEntries(value[PROVENANCE_FIELD]);
   }
   return [];
@@ -11554,7 +11908,7 @@ async function deriveReviewsByRoot(inputs, git2, rootFor, ctx, requested) {
   if (byRoot.size === 0) {
     return unavailable3(requested, "no git repository contains the documents");
   }
-  const cacheDir = resolve13(ctx.configDir ?? ctx.cwd, REVIEW_CACHE_DIR);
+  const cacheDir = resolve14(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();
@@ -11736,33 +12090,33 @@ import { readFile as readFile9 } from "node:fs/promises";
 
 // src/meta/core/relocation.ts
 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 { basename as basename5, extname as extname3, isAbsolute as isAbsolute8, join as join8, relative as relative12, resolve as resolve15, sep as sep7 } from "node:path";
 import picomatch6 from "picomatch";
 import {
-  LineCounter as LineCounter4,
-  isMap as isMap6,
-  isNode as isNode3,
-  isScalar as isScalar4,
+  LineCounter as LineCounter5,
+  isMap as isMap7,
+  isNode as isNode4,
+  isScalar as isScalar5,
   isSeq as isSeq4,
   parse as parseYaml5,
-  parseDocument as parseDocument6
+  parseDocument as parseDocument7
 } from "yaml";
 
 // src/meta/core/external-metadata-write.ts
-import { posix as posix3 } from "node:path";
+import { posix as posix6 } from "node:path";
 import {
-  LineCounter as LineCounter3,
-  isMap as isMap5,
-  isNode as isNode2,
+  LineCounter as LineCounter4,
+  isMap as isMap6,
+  isNode as isNode3,
   isPair,
-  isScalar as isScalar3,
+  isScalar as isScalar4,
   isSeq as isSeq3,
-  parseDocument as parseDocument5,
+  parseDocument as parseDocument6,
   stringify as stringify2
 } from "yaml";
 function spliceManifestValue(text2, options) {
   const { entry, key, value, file } = options;
-  const join11 = options.join ?? PATH_JOIN;
+  const join11 = options.join ?? PATH_JOIN2;
   const at2 = (line2) => {
     const name2 = file === void 0 ? "Manifest" : `Manifest ${file}`;
     if (line2 === void 0) return name2;
@@ -11777,8 +12131,8 @@ function spliceManifestValue(text2, options) {
     throw new DocmetaError(`${at2()}: refusing to write "${key}" for "${entry}" with no value.`);
   }
   const eol = detectEol(text2);
-  const lc = new LineCounter3();
-  const doc = parseDocument5(text2, { lineCounter: lc, uniqueKeys: false });
+  const lc = new LineCounter4();
+  const doc = parseDocument6(text2, { lineCounter: lc, uniqueKeys: false });
   const problem = doc.errors[0];
   if (problem) {
     throw new DocmetaError(`${at2()} is not valid YAML: ${problem.message}`);
@@ -11787,15 +12141,15 @@ function spliceManifestValue(text2, options) {
     const r = rangeOf(node);
     return r ? lc.linePos(r[0]).line : void 0;
   };
-  const same2 = join11 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
+  const same2 = join11 === PATH_JOIN2 ? (a, b) => posix6.normalize(a) === posix6.normalize(b) : (a, b) => a === b;
   const root = doc.contents;
   let spelled = entry;
   let edit;
-  if (root === null || isScalar3(root) && root.value === null && emptySource(text2, root)) {
+  if (root === null || isScalar4(root) && root.value === null && emptySource(text2, root)) {
     edit = startManifest(text2, entry, key, value, eol);
-  } else if (!isMap5(root)) {
+  } else if (!isMap6(root)) {
     throw new DocmetaError(
-      `${at2()}: the manifest must be a mapping from document ${join11 === PATH_JOIN ? "path" : `"${join11}"`} to owned keys.`
+      `${at2()}: the manifest must be a mapping from document ${join11 === PATH_JOIN2 ? "path" : `"${join11}"`} to owned keys.`
     );
   } else {
     const style = detectStyle(text2, root, eol);
@@ -11817,7 +12171,7 @@ function spliceManifestValue(text2, options) {
       spelled = keyString(first.key);
       const where = at2(keyLine(first.key));
       const v = first.value;
-      if (!isMap5(v)) {
+      if (!isMap6(v)) {
         throw new DocmetaError(`${where}: "${spelled}" must be a mapping of owned keys to values.`);
       }
       const hits = v.items.filter((kv) => keyString(kv.key) === key);
@@ -11860,30 +12214,30 @@ function spliceManifestValue(text2, options) {
   return { text: out, line };
 }
 function readManifestValue(text2, options) {
-  const join11 = options.join ?? PATH_JOIN;
-  const doc = parseDocument5(text2, { uniqueKeys: false });
+  const join11 = options.join ?? PATH_JOIN2;
+  const doc = parseDocument6(text2, { uniqueKeys: false });
   if (doc.errors.length > 0) return void 0;
   const root = doc.contents;
-  if (!isMap5(root)) return void 0;
-  const same2 = join11 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
+  if (!isMap6(root)) return void 0;
+  const same2 = join11 === PATH_JOIN2 ? (a, b) => posix6.normalize(a) === posix6.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;
+  if (!isMap6(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;
+  return isNode3(node) ? node.toJSON() : void 0;
 }
 function removeManifestKey(text2, options) {
   const { entry, key, file } = options;
-  const join11 = options.join ?? PATH_JOIN;
+  const join11 = options.join ?? PATH_JOIN2;
   const at2 = (line) => {
     const name2 = file === void 0 ? "Manifest" : `Manifest ${file}`;
     if (line === void 0) return name2;
     return file === void 0 ? `${name2} line ${String(line)}` : `${name2}:${String(line)}`;
   };
   const eol = detectEol(text2);
-  const lc = new LineCounter3();
-  const doc = parseDocument5(text2, { lineCounter: lc, uniqueKeys: false });
+  const lc = new LineCounter4();
+  const doc = parseDocument6(text2, { lineCounter: lc, uniqueKeys: false });
   const problem = doc.errors[0];
   if (problem) {
     throw new DocmetaError(`${at2()} is not valid YAML: ${problem.message}`);
@@ -11893,13 +12247,13 @@ function removeManifestKey(text2, options) {
     return r ? lc.linePos(r[0]).line : void 0;
   };
   const root = doc.contents;
-  if (root === null || isScalar3(root) && root.value === null) return { text: text2 };
-  if (!isMap5(root)) {
+  if (root === null || isScalar4(root) && root.value === null) return { text: text2 };
+  if (!isMap6(root)) {
     throw new DocmetaError(
-      `${at2()}: the manifest must be a mapping from document ${join11 === PATH_JOIN ? "path" : `"${join11}"`} to owned keys.`
+      `${at2()}: the manifest must be a mapping from document ${join11 === PATH_JOIN2 ? "path" : `"${join11}"`} to owned keys.`
     );
   }
-  const same2 = join11 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
+  const same2 = join11 === PATH_JOIN2 ? (a, b) => posix6.normalize(a) === posix6.normalize(b) : (a, b) => a === b;
   const matches = root.items.filter((p) => same2(keyString(p.key), entry));
   const [first, second] = matches;
   if (first && second) {
@@ -11911,7 +12265,7 @@ function removeManifestKey(text2, options) {
   const spelled = keyString(first.key);
   const where = at2(keyLine(first.key));
   const v = first.value;
-  if (!isMap5(v)) {
+  if (!isMap6(v)) {
     throw new DocmetaError(`${where}: "${spelled}" must be a mapping of owned keys to values.`);
   }
   const hits = v.items.filter((kv) => keyString(kv.key) === key);
@@ -11944,7 +12298,7 @@ function removeManifestKey(text2, options) {
     else if (start === 0 && text2.startsWith(eol, end)) end += eol.length;
   }
   const out = text2.slice(0, start) + text2.slice(end);
-  const after = parseDocument5(out, { uniqueKeys: false });
+  const after = parseDocument6(out, { uniqueKeys: false });
   const fail2 = (why) => new DocmetaError(
     `${at2()}: removing "${key}" for "${entry}" did not read back as removed, so nothing was written. ${why}`
   );
@@ -11964,14 +12318,14 @@ function removeManifestKey(text2, options) {
 }
 function renameManifestEntry(text2, options) {
   const { entry, to, file } = options;
-  const join11 = options.join ?? PATH_JOIN;
+  const join11 = options.join ?? PATH_JOIN2;
   const at2 = (line) => {
     const name2 = file === void 0 ? "Manifest" : `Manifest ${file}`;
     if (line === void 0) return name2;
     return file === void 0 ? `${name2} line ${String(line)}` : `${name2}:${String(line)}`;
   };
-  const lc = new LineCounter3();
-  const doc = parseDocument5(text2, { lineCounter: lc, uniqueKeys: false });
+  const lc = new LineCounter4();
+  const doc = parseDocument6(text2, { lineCounter: lc, uniqueKeys: false });
   const problem = doc.errors[0];
   if (problem) {
     throw new DocmetaError(`${at2()} is not valid YAML: ${problem.message}`);
@@ -11981,13 +12335,13 @@ function renameManifestEntry(text2, options) {
     return r2 ? lc.linePos(r2[0]).line : void 0;
   };
   const root = doc.contents;
-  if (root === null || isScalar3(root) && root.value === null) return { text: text2 };
-  if (!isMap5(root)) {
+  if (root === null || isScalar4(root) && root.value === null) return { text: text2 };
+  if (!isMap6(root)) {
     throw new DocmetaError(
-      `${at2()}: the manifest must be a mapping from document ${join11 === PATH_JOIN ? "path" : `"${join11}"`} to owned keys.`
+      `${at2()}: the manifest must be a mapping from document ${join11 === PATH_JOIN2 ? "path" : `"${join11}"`} to owned keys.`
     );
   }
-  const same2 = join11 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
+  const same2 = join11 === PATH_JOIN2 ? (a, b) => posix6.normalize(a) === posix6.normalize(b) : (a, b) => a === b;
   const [first, second] = root.items.filter((p) => same2(keyString(p.key), entry));
   if (first && second) {
     throw new DocmetaError(
@@ -12009,11 +12363,11 @@ function renameManifestEntry(text2, options) {
       `${at2(keyLine(first.key))}: "${spelled}" is written in a form this writer does not edit. Write it as "${spelled}: \u2026".`
     );
   }
-  const quoted = isScalar3(first.key) && (first.key.type === "QUOTE_DOUBLE" || first.key.type === "QUOTE_SINGLE");
+  const quoted = isScalar4(first.key) && (first.key.type === "QUOTE_DOUBLE" || first.key.type === "QUOTE_SINGLE");
   const plain = stringify2(to, { lineWidth: 0 }).replace(/\n$/, "");
   const insert = quoted || plain.includes("\n") ? JSON.stringify(to) : plain;
   const out = text2.slice(0, r[0]) + insert + text2.slice(end);
-  const after = parseDocument5(out, { uniqueKeys: false });
+  const after = parseDocument6(out, { uniqueKeys: false });
   const fail2 = (why) => new DocmetaError(
     `${at2()}: renaming "${spelled}" to "${to}" did not read back as renamed, so nothing was written. ${why}`
   );
@@ -12047,7 +12401,7 @@ function appendEntry(text2, root, entry, key, value, style) {
   const col = firstKey ? colOf(text2, firstKey[0]) : 0;
   const pos = lineEnd(text2, contentEnd(text2, root) ?? text2.length);
   const last = root.items.at(-1);
-  const spaced = root.items.length > 1 && isNode2(last?.key) && last.key.spaceBefore === true;
+  const spaced = root.items.length > 1 && isNode3(last?.key) && last.key.spaceBefore === true;
   return {
     start: pos,
     end: pos,
@@ -12087,7 +12441,7 @@ function replaceBlockValue(text2, pair, value, style) {
     ownLine = true;
   }
   const old = pair.value;
-  const oldEnd = isScalar3(old) && old.value === null && emptySource(text2, old) ? start : contentEnd(text2, old) ?? start;
+  const oldEnd = isScalar4(old) && old.value === null && emptySource(text2, old) ? start : contentEnd(text2, old) ?? start;
   const end = Math.max(start, oldEnd);
   let insert = afterColon(value, keyCol, style);
   if (ownLine && !insert.startsWith(style.eol)) {
@@ -12102,8 +12456,8 @@ function replaceFlowValue(text2, pair, value) {
   return { start: r[0], end, insert: flowText(value) };
 }
 function readBack(before, out, spelled, key, value, fail2) {
-  const lc = new LineCounter3();
-  const after = parseDocument5(out, { lineCounter: lc, uniqueKeys: false });
+  const lc = new LineCounter4();
+  const after = parseDocument6(out, { lineCounter: lc, uniqueKeys: false });
   const problem = after.errors[0];
   if (problem) throw fail2(`The result is not valid YAML: ${problem.message}`);
   const was = before.toJS({ maxAliasCount: 100 });
@@ -12124,9 +12478,9 @@ function readBack(before, out, spelled, key, value, fail2) {
     throw fail2("Another value in the manifest would have changed.");
   }
   const root = after.contents;
-  const pair = isMap5(root) ? root.items.find((p) => keyString(p.key) === spelled) : void 0;
+  const pair = isMap6(root) ? root.items.find((p) => keyString(p.key) === spelled) : void 0;
   const entryMap = pair?.value;
-  const kv = isMap5(entryMap) ? entryMap.items.find((p) => keyString(p.key) === key) : void 0;
+  const kv = isMap6(entryMap) ? entryMap.items.find((p) => keyString(p.key) === key) : void 0;
   const r = rangeOf(kv?.value) ?? rangeOf(kv?.key);
   if (!r) throw fail2("The written value could not be found again.");
   return lc.linePos(r[0]).line;
@@ -12157,7 +12511,7 @@ function detectStyle(text2, root, eol) {
   for (const pair of root.items) {
     const v = pair.value;
     const entryKey = rangeOf(pair.key);
-    const ownedKey = isMap5(v) && v.flow !== true ? rangeOf(v.items[0]?.key) : void 0;
+    const ownedKey = isMap6(v) && v.flow !== true ? rangeOf(v.items[0]?.key) : void 0;
     if (entryKey && ownedKey) {
       const d = colOf(text2, ownedKey[0]) - colOf(text2, entryKey[0]);
       if (d > 0) {
@@ -12169,7 +12523,7 @@ function detectStyle(text2, root, eol) {
   return { step, indentSeq: seqIndented(text2, root) ?? true, eol };
 }
 function seqIndented(text2, node) {
-  if (isMap5(node)) {
+  if (isMap6(node)) {
     for (const pair of node.items) {
       const v = pair.value;
       if (isSeq3(v) && v.flow !== true && v.items.length > 0) {
@@ -12189,7 +12543,7 @@ function seqIndented(text2, node) {
   return void 0;
 }
 function contentEnd(text2, node) {
-  if (isMap5(node) && node.flow !== true) {
+  if (isMap6(node) && node.flow !== true) {
     const last = node.items.at(-1);
     if (last) return contentEnd(text2, last.value) ?? contentEnd(text2, last.key);
   } else if (isSeq3(node) && node.flow !== true) {
@@ -12223,14 +12577,14 @@ function colOf(text2, offset) {
   return offset - start;
 }
 function rangeOf(node) {
-  return isNode2(node) ? node.range ?? void 0 : void 0;
+  return isNode3(node) ? node.range ?? void 0 : void 0;
 }
 function emptySource(text2, node) {
   const r = rangeOf(node);
   return !r || text2.slice(r[0], r[1]).trim() === "";
 }
 function keyString(key) {
-  return isScalar3(key) ? String(key.value) : String(key);
+  return isScalar4(key) ? String(key.value) : String(key);
 }
 function isRecord6(x) {
   return typeof x === "object" && x !== null && !Array.isArray(x);
@@ -12260,13 +12614,13 @@ function relocationContext(run2, extras) {
     ...extras.onNotice !== void 0 ? { onNotice: extras.onNotice } : {}
   };
 }
-var toPosix3 = (p) => p.split(sep6).join("/");
+var toPosix3 = (p) => p.split(sep7).join("/");
 function reported2(abs, base) {
-  const rel = relative11(base, abs);
+  const rel = relative12(base, abs);
   return rel === "" ? "." : toPosix3(rel);
 }
 function configSource(path, cwd) {
-  return toPosix3(relative11(cwd, path)) || basename5(path);
+  return toPosix3(relative12(cwd, path)) || basename5(path);
 }
 function cloneCollection(c) {
   return {
@@ -12284,7 +12638,8 @@ 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 : resolve14(configDir, m.file);
+        const perPage = !url && hasPagePlaceholder(m.file);
+        const absPath = url || perPage ? void 0 : isAbsolute8(m.file) ? m.file : resolve15(configDir, m.file);
         this.manifests.push({
           collection: c.name,
           index,
@@ -12293,6 +12648,7 @@ var Model = class {
           absPath,
           file: absPath === void 0 ? m.file : reported2(absPath, ctx.base),
           join: externalMetadataJoin(m),
+          perPage,
           created: false,
           keysBefore: [...m.keys],
           keysAdded: [],
@@ -12319,6 +12675,22 @@ var Model = class {
   manifestsOf(collection) {
     return this.manifests.filter((m) => m.collection === collection);
   }
+  /**
+   * The one file `m` keeps a page's values in, and how the run reports it:
+   * the page's own for a `{page}` manifest (proposal 0058), the declared file
+   * for any other. `abs` is undefined only for a URL manifest.
+   */
+  fileFor(m, pageAbs) {
+    if (!m.perPage) return { abs: m.absPath, file: m.file };
+    const resolved = pageManifestPath(m.written, this.configDir, pageAbs);
+    if ("outside" in resolved) {
+      const declared = this.ctx.declaredCollections.find((c) => c.name === m.collection)?.externalMetadata[m.index];
+      throw new DocmetaError(
+        outsideRefusal(declared ?? { file: m.written, keys: [] }, m.collection, resolved.pageRel)
+      );
+    }
+    return { abs: resolved.abs, file: reported2(resolved.abs, this.ctx.base) };
+  }
   /** The manifest of one of `members` that owns `key`, in declaration order. */
   ownerOf(key, members) {
     return this.manifests.find(
@@ -12404,7 +12776,8 @@ var Model = class {
       url: false,
       absPath,
       file,
-      join: PATH_JOIN,
+      join: PATH_JOIN2,
+      perPage: false,
       created: true,
       keysBefore: [],
       keysAdded: [],
@@ -12441,8 +12814,8 @@ 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, resolve14(this.ctx.base, label)));
-    return isAbsolute7(rel) || rel.startsWith("../") ? void 0 : rel;
+    const rel = toPosix3(relative12(this.configDir, resolve15(this.ctx.base, label)));
+    return isAbsolute8(rel) || rel.startsWith("../") ? void 0 : rel;
   }
 };
 function dedupe2(xs) {
@@ -12453,17 +12826,17 @@ function bare(path) {
 }
 async function collectionPath(target, cwd, configDir) {
   if (target === STDIN_TOKEN) return void 0;
-  const posix5 = target.replace(/\\/g, "/");
-  const scanned = picomatch6.scan(posix5);
+  const posix7 = target.replace(/\\/g, "/");
+  const scanned = picomatch6.scan(posix7);
   if (scanned.isGlob) {
-    const rel2 = toPosix3(relative11(configDir, resolve14(cwd, scanned.base === "" ? "." : scanned.base)));
-    if (isAbsolute7(rel2) || rel2 === ".." || rel2.startsWith("../")) return void 0;
+    const rel2 = toPosix3(relative12(configDir, resolve15(cwd, scanned.base === "" ? "." : scanned.base)));
+    if (isAbsolute8(rel2) || rel2 === ".." || rel2.startsWith("../")) return void 0;
     return rel2 === "" ? scanned.glob : `${rel2}/${scanned.glob}`;
   }
-  const abs = resolve14(cwd, posix5);
-  const rel = toPosix3(relative11(configDir, abs));
-  if (isAbsolute7(rel) || rel.startsWith("..")) return void 0;
-  let directory = posix5.endsWith("/");
+  const abs = resolve15(cwd, posix7);
+  const rel = toPosix3(relative12(configDir, abs));
+  if (isAbsolute8(rel) || rel.startsWith("..")) return void 0;
+  let directory = posix7.endsWith("/");
   if (!directory) {
     try {
       directory = (await stat6(abs)).isDirectory();
@@ -12484,28 +12857,30 @@ async function exists(absPath, file) {
   }
 }
 function plannedConfigDir(ctx) {
-  return ctx.configDir ?? findGitRoot(ctx.cwd) ?? resolve14(ctx.cwd);
+  return ctx.configDir ?? findGitRoot(ctx.cwd) ?? resolve15(ctx.cwd);
 }
 async function keyHome(ctx, label, data, key) {
   const model = new Model(ctx, plannedConfigDir(ctx));
   const owner = model.ownerOf(key, model.members(label));
   if (owner !== void 0) {
-    if (owner.url || owner.absPath === void 0) {
+    const at2 = model.fileFor(owner, resolve15(ctx.base, label));
+    if (owner.url || at2.abs === void 0) {
       return { kind: "url", collection: owner.collection, file: owner.file };
     }
     return {
       kind: "manifest",
       collection: owner.collection,
-      file: owner.file,
-      absPath: owner.absPath,
+      file: at2.file,
+      absPath: at2.abs,
       join: owner.join,
-      entry: entryFor(owner, label, data, model.configDir, ctx.base, lazyKey(ctx.configFile, ctx.env))
+      entry: entryFor(owner, label, data, model.configDir, ctx.base, lazyKey(ctx.configFile, ctx.env)),
+      perPage: owner.perPage
     };
   }
   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, resolve14(base, label)));
+  if (m.join === PATH_JOIN2) return toPosix3(relative12(configDir, resolve15(base, label)));
   let raw = data[m.join];
   if (isEncryptedValue(raw)) {
     const k = key();
@@ -12522,6 +12897,27 @@ function entryFor(m, label, data, configDir, base, key) {
   if (typeof raw === "number" || typeof raw === "boolean") return String(raw);
   return void 0;
 }
+async function relocationPages(ctx, request) {
+  const pages2 = new Set(request.files.map((label) => resolve15(ctx.base, label)));
+  const root = ctx.configDir ?? ctx.cwd;
+  for (const collection of ctx.declaredCollections) {
+    const perPage = collection.externalMetadata.some(
+      (m) => classifyRef(m.file).kind !== "url" && hasPagePlaceholder(m.file)
+    );
+    if (!perPage) continue;
+    const walked = await resolveTargetSet({
+      inputs: [...collection.paths],
+      cwd: root,
+      allowEmpty: true,
+      ...gitignoreOptions({
+        ...ctx.respectGitignore !== void 0 ? { flag: ctx.respectGitignore } : {},
+        ...ctx.config?.respectGitignore !== void 0 ? { configured: ctx.config.respectGitignore } : {}
+      })
+    });
+    for (const file of walked.files) pages2.add(resolve15(root, file));
+  }
+  return [...pages2];
+}
 async function planRelocation(ctx, request) {
   const configDir = plannedConfigDir(ctx);
   const model = new Model(ctx, configDir);
@@ -12529,7 +12925,8 @@ async function planRelocation(ctx, request) {
   const index = await loadExternalMetadata(ctx.declaredCollections, {
     configDir: ctx.configDir ?? ctx.cwd,
     base: ctx.base,
-    offline: ctx.config?.offline ?? false
+    offline: ctx.config?.offline ?? false,
+    pages: await relocationPages(ctx, request)
   });
   const trustRoot = schemaTrustRoot(ctx.cwd, ctx.configDir);
   const forced = ctx.as !== void 0 ? extractorByName(ctx.as) : void 0;
@@ -12546,17 +12943,17 @@ 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 = resolve14(ctx.base, label);
+    const absPath = resolve15(ctx.base, label);
     const elements = resolveElements(label, ctx.config, currentMembers(label));
     let content = "";
     let own2 = {};
-    let unreadable;
+    let unreadable2;
     if (beyond) {
       try {
         content = await readFile8(absPath, "utf8");
         own2 = extractor.extract(content, label, { elements }).data;
       } catch (err) {
-        unreadable = (errorMessage(err).split("\n")[0] ?? "").replace(/:\s*$/, "");
+        unreadable2 = (errorMessage(err).split("\n")[0] ?? "").replace(/:\s*$/, "");
       }
     } else {
       content = await readFile8(absPath, "utf8");
@@ -12575,7 +12972,7 @@ async function planRelocation(ctx, request) {
       extractor,
       own: own2,
       beyond,
-      ...unreadable !== void 0 ? { unreadable } : {},
+      ...unreadable2 !== void 0 ? { unreadable: unreadable2 } : {},
       intents: /* @__PURE__ */ new Map()
     };
     pages2.set(label, page);
@@ -12584,13 +12981,13 @@ async function planRelocation(ctx, request) {
   const supplied = (m, page, key) => {
     if (m.created || index === null) return void 0;
     let sv;
-    if (m.join === PATH_JOIN) {
+    if (m.join === PATH_JOIN2) {
       sv = index.byPath.get(page.absPath)?.get(key);
     } else {
       const entry = entryFor(m, page.label, page.own, configDir, ctx.base, encryptionKey);
       sv = entry === void 0 ? void 0 : index.byField.get(m.join)?.get(entry)?.get(key);
     }
-    return sv !== void 0 && sv.collection === m.collection && sv.file === m.file ? sv : void 0;
+    return sv !== void 0 && sv.collection === m.collection && sv.file === model.fileFor(m, page.absPath).file ? sv : void 0;
   };
   const stay = (page, key, reason, detail, links = {}) => {
     page.intents.set(key, { kind: "stay", reason, detail, ...links });
@@ -12610,7 +13007,7 @@ async function planRelocation(ctx, request) {
     }
     const held = supplied(m, page, key);
     if (held !== void 0 && !deepEqual(held.value, page.own[key])) {
-      stay(page, key, "values-differ", `the page and ${m.file} hold different values`, { toward: m });
+      stay(page, key, "values-differ", `the page and ${held.file} hold different values`, { toward: m });
       return;
     }
     page.intents.set(key, { kind: "out", manifest: m, reason, drop: held !== void 0, entry });
@@ -12623,7 +13020,7 @@ async function planRelocation(ctx, request) {
     if (entry === void 0) return;
     if (Object.hasOwn(page.own, key)) {
       if (!deepEqual(held.value, page.own[key])) {
-        stay(page, key, "values-differ", `the page and ${m.file} hold different values`, { blocks: m });
+        stay(page, key, "values-differ", `the page and ${held.file} hold different values`, { blocks: m });
         return;
       }
       page.intents.set(key, { kind: "in", manifest: m, drop: true, entry, value: held.value });
@@ -12669,7 +13066,7 @@ async function planRelocation(ctx, request) {
     preferencesOf.set(label, prefs);
     const planned = model.members(label);
     const joins = new Set(
-      model.manifests.filter((m) => planned.includes(m.collection) && m.join !== PATH_JOIN).map((m) => m.join)
+      model.manifests.filter((m) => planned.includes(m.collection) && m.join !== PATH_JOIN2).map((m) => m.join)
     );
     for (const m of model.manifests) {
       if (planned.includes(m.collection)) for (const k of [...m.keysBefore, ...m.keysAdded]) marked.add(k);
@@ -12759,7 +13156,7 @@ async function planRelocation(ctx, request) {
     });
     const labels = dedupe2([
       ...request.files,
-      ...walked.files.map((f) => reported2(resolve14(configDir, f), ctx.base))
+      ...walked.files.map((f) => reported2(resolve15(configDir, f), ctx.base))
     ]).filter((label) => model.members(label).includes(name2));
     for (const label of labels) {
       const page = await load(label, !runSet.has(label));
@@ -12776,7 +13173,7 @@ async function planRelocation(ctx, request) {
           const changing = covered ? out : out.filter((k) => m.keysAdded.includes(k));
           for (const key of changing) if (!page.intents.has(key)) stay(page, key, "unreadable", detail);
           for (const key of m.keysRemoved) {
-            const held = m.join !== PATH_JOIN || !m.created && index?.byPath.get(page.absPath)?.get(key)?.file === m.file;
+            const held = m.join !== PATH_JOIN2 || !m.created && index?.byPath.get(page.absPath)?.get(key)?.file === model.fileFor(m, page.absPath).file;
             if (held && !page.intents.has(key)) stay(page, key, "unreadable", detail, { blocks: m });
           }
           continue;
@@ -12827,35 +13224,50 @@ async function planRelocation(ctx, request) {
   const writes = [];
   const lines = /* @__PURE__ */ new Map();
   for (const m of model.manifests) {
-    if (m.url || m.absPath === void 0) continue;
+    if (m.url) continue;
     const undeclared = model.finalKeys(m).length === 0 && !m.created;
-    const outs = [];
-    const ins = [];
+    const files = /* @__PURE__ */ new Map();
+    const group = (at2) => {
+      if (at2.abs === void 0) return void 0;
+      const have = files.get(at2.abs);
+      if (have !== void 0) return have;
+      const made = { file: at2.file, outs: [], ins: [] };
+      files.set(at2.abs, made);
+      return made;
+    };
+    if (m.created) group({ abs: m.absPath, file: m.file });
     for (const page of orderedPages()) {
       for (const [key, intent] of orderedIntents(page)) {
-        if (intent.kind === "out" && intent.manifest === m) {
-          outs.push({ page: page.label, entry: intent.entry, key, value: page.own[key], drop: intent.drop });
-        } else if (intent.kind === "in" && intent.manifest === m) {
-          ins.push({ entry: intent.entry, key });
+        if ((intent.kind === "out" || intent.kind === "in") && intent.manifest === m) {
+          const into = group(model.fileFor(m, page.absPath));
+          if (intent.kind === "out") {
+            into?.outs.push({ page: page.label, entry: intent.entry, key, value: page.own[key], drop: intent.drop });
+          } else {
+            into?.ins.push({ entry: intent.entry, key });
+          }
         }
       }
     }
-    if (!undeclared) assertNoStrandedEntries(m, index, pages2, configDir);
-    if (undeclared || !m.created && outs.length === 0 && ins.length === 0) continue;
-    let text2 = m.created ? "" : await readManifestText(m);
-    const before = text2;
-    const where = { join: m.join, file: m.file };
-    for (const o of outs) {
-      if (!o.drop) text2 = spliceManifestValue(text2, { ...where, entry: o.entry, key: o.key, value: o.value }).text;
-    }
-    for (const i of ins) text2 = removeManifestKey(text2, { ...where, entry: i.entry, key: i.key }).text;
-    const found = keyLines(text2, m.join);
-    for (const o of outs) {
-      const line = found.get(entryId(o.entry, m.join))?.get(o.key);
-      if (line !== void 0) lines.set(lineId(o.page, m.file, o.key), line);
-    }
-    if (m.created || text2 !== before) {
-      writes.push({ path: m.absPath, text: text2, kind: "manifest", before: m.created ? null : before });
+    if (!undeclared) assertNoStrandedEntries(m, index, pages2, configDir, (abs) => model.fileFor(m, abs).file);
+    if (undeclared) continue;
+    for (const [path, { file, outs, ins }] of files) {
+      if (!m.created && outs.length === 0 && ins.length === 0) continue;
+      const disk = m.created ? null : await readManifestText(path, file, m.perPage);
+      let text2 = disk ?? "";
+      const before = text2;
+      const where = { join: m.join, file };
+      for (const o of outs) {
+        if (!o.drop) text2 = spliceManifestValue(text2, { ...where, entry: o.entry, key: o.key, value: o.value }).text;
+      }
+      for (const i of ins) text2 = removeManifestKey(text2, { ...where, entry: i.entry, key: i.key }).text;
+      const found = keyLines(text2, m.join);
+      for (const o of outs) {
+        const line = found.get(entryId(o.entry, m.join))?.get(o.key);
+        if (line !== void 0) lines.set(lineId(o.page, file, o.key), line);
+      }
+      if (m.created || text2 !== before) {
+        writes.push({ path, text: text2, kind: "manifest", before: disk });
+      }
     }
   }
   const finalCollections = model.final();
@@ -12954,7 +13366,7 @@ function planPageText(page) {
     refuse();
   }
 }
-function assertNoStrandedEntries(m, index, pages2, configDir) {
+function assertNoStrandedEntries(m, index, pages2, configDir, fileOf) {
   if (index === null || m.keysRemoved.length === 0) return;
   for (const key of m.keysRemoved) {
     const moved = /* @__PURE__ */ new Set();
@@ -12962,10 +13374,10 @@ function assertNoStrandedEntries(m, index, pages2, configDir) {
       const i = page.intents.get(key);
       if (i?.kind === "in" && i.manifest === m) moved.add(entryId(i.entry, m.join));
     }
-    const stranded = m.join === PATH_JOIN ? [...index.byPath].filter(([, values]) => {
+    const stranded = m.join === PATH_JOIN2 ? [...index.byPath].filter(([abs, values]) => {
       const sv = values.get(key);
-      return sv !== void 0 && sv.file === m.file && sv.collection === m.collection;
-    }).map(([abs]) => toPosix3(relative11(configDir, abs))) : [...index.byField.get(m.join) ?? /* @__PURE__ */ new Map()].filter(([, values]) => {
+      return sv !== void 0 && sv.collection === m.collection && sv.file === fileOf(abs);
+    }).map(([abs]) => toPosix3(relative12(configDir, abs))) : [...index.byField.get(m.join) ?? /* @__PURE__ */ new Map()].filter(([, values]) => {
       const sv = values.get(key);
       return sv !== void 0 && sv.file === m.file && sv.collection === m.collection;
     }).map(([value]) => value);
@@ -12977,29 +13389,29 @@ function assertNoStrandedEntries(m, index, pages2, configDir) {
     }
   }
 }
-async function readManifestText(m) {
-  if (m.absPath === void 0) return "";
+async function readManifestText(path, file, perPage) {
   try {
-    return await readFile8(m.absPath, "utf8");
+    return await readFile8(path, "utf8");
   } catch (err) {
-    throw new DocmetaError(`Manifest ${m.file} could not be read: ${errorMessage(err)}`);
+    if (perPage && isMissing(err)) return null;
+    throw new DocmetaError(`Manifest ${file} could not be read: ${errorMessage(err)}`);
   }
 }
-var entryId = (entry, join11) => join11 === PATH_JOIN ? toPosix3(entry).replace(/^\.\//, "").replace(/\/+/g, "/") : entry;
+var entryId = (entry, join11) => join11 === PATH_JOIN2 ? toPosix3(entry).replace(/^\.\//, "").replace(/\/+/g, "/") : entry;
 var lineId = (page, manifest, key) => `${page}\0${manifest}\0${key}`;
 function keyLines(text2, join11) {
   const out = /* @__PURE__ */ new Map();
-  const lc = new LineCounter4();
-  const doc = parseDocument6(text2, { lineCounter: lc, uniqueKeys: false });
+  const lc = new LineCounter5();
+  const doc = parseDocument7(text2, { lineCounter: lc, uniqueKeys: false });
   const root = doc.contents;
-  if (!isMap6(root)) return out;
+  if (!isMap7(root)) return out;
   for (const pair of root.items) {
-    const spelled = isScalar4(pair.key) ? String(pair.key.value) : String(pair.key);
-    if (!isMap6(pair.value)) continue;
+    const spelled = isScalar5(pair.key) ? String(pair.key.value) : String(pair.key);
+    if (!isMap7(pair.value)) continue;
     const keys = /* @__PURE__ */ new Map();
     for (const kv of pair.value.items) {
-      const name2 = isScalar4(kv.key) ? String(kv.key.value) : String(kv.key);
-      const range = isNode3(kv.key) ? kv.key.range : void 0;
+      const name2 = isScalar5(kv.key) ? String(kv.key.value) : String(kv.key);
+      const range = isNode4(kv.key) ? kv.key.range : void 0;
       if (range) keys.set(name2, lc.linePos(range[0]).line);
     }
     out.set(entryId(spelled, join11), keys);
@@ -13031,10 +13443,10 @@ async function configTarget(ctx, configDir) {
   return { path: join8(configDir, FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml"), text: null, disk: null };
 }
 function editConfig(text2, model, source) {
-  const doc = parseDocument6(text2 ?? "");
+  const doc = parseDocument7(text2 ?? "");
   const [problem] = doc.errors;
   if (problem !== void 0) throw new DocmetaError(`${source}: invalid YAML: ${problem.message}`);
-  if (doc.contents !== null && !isMap6(doc.contents)) {
+  if (doc.contents !== null && !isMap7(doc.contents)) {
     throw new DocmetaError(`${source}: top level must be a mapping.`);
   }
   const fail2 = () => {
@@ -13044,7 +13456,7 @@ function editConfig(text2, model, source) {
     if (!isSeq4(node)) return;
     node.flow = true;
     if (quoted) {
-      for (const item of node.items) if (isScalar4(item)) item.type = "QUOTE_DOUBLE";
+      for (const item of node.items) if (isScalar5(item)) item.type = "QUOTE_DOUBLE";
     }
   };
   const manifestNode = (d, file, keys) => {
@@ -13058,13 +13470,13 @@ function editConfig(text2, model, source) {
   for (let i = 0; i < declared; i++) {
     const c = model.collections[i];
     const node = isSeq4(existing) ? existing.items[i] : void 0;
-    if (c === void 0 || !isMap6(node)) return fail2();
+    if (c === void 0 || !isMap7(node)) return fail2();
     for (const added of model.pathsAdded.filter((p) => p.collection === c.name)) {
       const paths = node.get("paths", true);
       if (!isSeq4(paths)) return fail2();
       const scalar = doc.createNode(added.path);
       const first = paths.items[0];
-      if (isScalar4(first) && first.type !== void 0) scalar.type = first.type;
+      if (isScalar5(first) && first.type !== void 0) scalar.type = first.type;
       paths.add(scalar);
     }
     const refs = model.manifestsOf(c.name);
@@ -13081,7 +13493,7 @@ function editConfig(text2, model, source) {
       }
       if (m.keysAdded.length === 0) continue;
       const entry = node.getIn(["externalMetadata", m.index], true);
-      const keys = isMap6(entry) ? entry.get("keys", true) : void 0;
+      const keys = isMap7(entry) ? entry.get("keys", true) : void 0;
       if (!isSeq4(keys)) return fail2();
       for (const key of m.keysAdded) keys.add(doc.createNode(key));
     }
@@ -13090,10 +13502,10 @@ function editConfig(text2, model, source) {
       if (m.keysRemoved.length === 0) continue;
       if (!isSeq4(list2)) return fail2();
       const entry = list2.items[m.index];
-      const keys = isMap6(entry) ? entry.get("keys", true) : void 0;
+      const keys = isMap7(entry) ? entry.get("keys", true) : void 0;
       if (!isSeq4(keys)) return fail2();
       for (const key of m.keysRemoved) {
-        const at2 = keys.items.findIndex((item) => (isScalar4(item) ? String(item.value) : String(item)) === key);
+        const at2 = keys.items.findIndex((item) => (isScalar5(item) ? String(item.value) : String(item)) === key);
         if (at2 >= 0) keys.delete(at2);
       }
       if (keys.items.length === 0) list2.delete(m.index);
@@ -13112,7 +13524,7 @@ function editConfig(text2, model, source) {
     flowSeq(node.get("paths", true), true);
     const made = node.get("externalMetadata", true);
     if (isSeq4(made)) {
-      for (const item of made.items) if (isMap6(item)) flowSeq(item.get("keys", true), false);
+      for (const item of made.items) if (isMap7(item)) flowSeq(item.get("keys", true), false);
     }
     const seq = doc.get("collections", true);
     if (isSeq4(seq)) seq.add(node);
@@ -13147,16 +13559,18 @@ function buildResult(input) {
     const moved = [];
     const stayed = [];
     const intents = orderedIntents(page);
+    const fileOf = (m) => model.fileFor(m, page.absPath).file;
     for (const [key, intent] of intents) {
-      if (intent.kind === "in") moved.push({ key, to: "page", from: intent.manifest.file, reason: "preferred" });
+      if (intent.kind === "in") moved.push({ key, to: "page", from: fileOf(intent.manifest), reason: "preferred" });
     }
     for (const [key, intent] of intents) {
       if (intent.kind !== "out") continue;
-      const line = dryRun ? void 0 : lines.get(lineId(page.label, intent.manifest.file, key));
+      const manifest = fileOf(intent.manifest);
+      const line = dryRun ? void 0 : lines.get(lineId(page.label, manifest, key));
       moved.push({
         key,
         to: "manifest",
-        manifest: intent.manifest.file,
+        manifest,
         ...line !== void 0 ? { line } : {},
         reason: intent.reason
       });
@@ -13201,7 +13615,7 @@ function buildResult(input) {
   };
 }
 async function applyRelocation(ctx, plan, io = {}) {
-  const write = io.write ?? ((path, text2) => writeFileAtomic(path, text2));
+  const write = io.write ?? ((path, text2) => writeFileAtomic(path, text2, { createParents: true }));
   const remove = io.remove ?? ((path) => unlink(path));
   const label = (w) => w.kind === "config" ? configSource(w.path, ctx.cwd) : reported2(w.path, ctx.base);
   for (const w of plan.writes) {
@@ -13374,7 +13788,7 @@ function relocationOffers(plan) {
 }
 
 // src/meta/commands/validate.ts
-import { resolve as resolve16, extname as extname4 } from "node:path";
+import { resolve as resolve17, extname as extname4 } from "node:path";
 
 // src/meta/core/checks.ts
 var CHECK_KEYWORD = "check";
@@ -13512,8 +13926,8 @@ async function runChecks(checks, entries, ctx = {}) {
 }
 
 // src/meta/core/derive/provenance-place.ts
-import { isAbsolute as isAbsolute8, relative as relative12, resolve as resolve15, sep as sep7 } from "node:path";
-var toPosix4 = (p) => p.split(sep7).join("/");
+import { isAbsolute as isAbsolute9, relative as relative13, resolve as resolve16, sep as sep8 } from "node:path";
+var toPosix4 = (p) => p.split(sep8).join("/");
 function provenanceManifests(collections, configDir, base) {
   const out = [];
   for (const collection of collections) {
@@ -13524,13 +13938,15 @@ 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 : resolve15(configDir, manifest.file);
-      const rel = relative12(base, absPath);
+      const absPath = isAbsolute9(manifest.file) ? manifest.file : resolve16(configDir, manifest.file);
+      const perPage = hasPagePlaceholder(manifest.file);
       out.push({
         collection: collection.name,
         absPath,
-        file: rel === "" ? "." : toPosix4(rel),
-        join: externalMetadataJoin(manifest)
+        file: perPage ? manifest.file : reportedPath(absPath, base),
+        join: externalMetadataJoin(manifest),
+        perPage,
+        written: manifest.file
       });
     }
   }
@@ -13540,15 +13956,16 @@ function provenancePlace(label, data, manifests, collections, configDir, base) {
   if (manifests.length === 0) return void 0;
   const members = new Set(memberOf(collections, configDir, base, label));
   const owning = manifests.filter((m) => members.has(m.collection));
-  const [manifest, second] = owning;
-  if (manifest === void 0) return void 0;
+  const [declared, second] = owning;
+  if (declared === void 0) return void 0;
   if (second !== void 0) {
     throw new DocmetaError(
-      `${label} is in collections ${manifest.collection} and ${second.collection}, and both keep ${PROVENANCE_FIELD} in a manifest.`
+      `${label} is in collections ${declared.collection} and ${second.collection}, and both keep ${PROVENANCE_FIELD} in a manifest.`
     );
   }
-  if (manifest.join === PATH_JOIN) {
-    const entry = toPosix4(relative12(configDir, resolve15(base, label)));
+  const manifest = declared.perPage ? ownManifest(declared, label, collections, configDir, base) : declared;
+  if (manifest.join === PATH_JOIN2) {
+    const entry = toPosix4(relative13(configDir, resolve16(base, label)));
     return { manifest, absPath: manifest.absPath, entry, join: manifest.join };
   }
   const value = data[manifest.join];
@@ -13559,6 +13976,16 @@ function provenancePlace(label, data, manifests, collections, configDir, base) {
   }
   return { manifest, absPath: manifest.absPath, entry: String(value), join: manifest.join };
 }
+function ownManifest(manifest, label, collections, configDir, base) {
+  const resolved = pageManifestPath(manifest.written, configDir, resolve16(base, label));
+  if ("outside" in resolved) {
+    const declared = collections.find((c) => c.name === manifest.collection)?.externalMetadata.find((m) => m.file === manifest.written);
+    throw new DocmetaError(
+      outsideRefusal(declared ?? { file: manifest.written, keys: [] }, manifest.collection, resolved.pageRel)
+    );
+  }
+  return { ...manifest, absPath: resolved.abs, file: reportedPath(resolved.abs, base) };
+}
 function readerManifests(collections, configDir, base) {
   const local = collections.map((c) => ({
     ...c,
@@ -13657,7 +14084,9 @@ async function runValidate(opts) {
   const externalMetadata = await loadExternalMetadata(collections, {
     configDir: configDir ?? cwd,
     base,
-    offline: opts.offline ?? config?.offline ?? false
+    offline: opts.offline ?? config?.offline ?? false,
+    // A `{page}` manifest (0058) is read for exactly the pages this run reads.
+    pages: files.map((file) => resolve17(base, file))
   });
   const validator = new Validator(
     schemaLoadOptions({
@@ -13688,7 +14117,7 @@ async function runValidate(opts) {
     const owned = new Set(merged.collisions.map((c) => c.key));
     const declaredMembers = declaredCollections === collections ? members : memberOf(declaredCollections, configDir ?? cwd, base, label);
     const joins = new Set(
-      declaredCollections.filter((c) => declaredMembers.includes(c.name)).flatMap((c) => c.externalMetadata.map(externalMetadataJoin)).filter((join11) => join11 !== PATH_JOIN)
+      declaredCollections.filter((c) => declaredMembers.includes(c.name)).flatMap((c) => c.externalMetadata.map(externalMetadataJoin)).filter((join11) => join11 !== PATH_JOIN2)
     );
     const findings = [];
     for (const key of Object.keys(data)) {
@@ -13812,7 +14241,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: resolve16(base, label),
+        absPath: resolve17(base, label),
         content,
         extracted,
         ...place !== void 0 ? { provenanceManifest: place } : {}
@@ -13943,7 +14372,7 @@ async function runValidate(opts) {
     await processOne(STDIN_LABEL, content, forcedExtractor.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile9(resolve16(base, file), "utf8");
+    const content = await readFile9(resolve17(base, file), "utf8");
     await processOne(file, content, extname4(file));
   }
   if (unverified > 0) opts.onNotice?.(unverifiedWarning(unverified));
@@ -14089,7 +14518,7 @@ async function runValidate(opts) {
 
 // src/meta/commands/get.ts
 import { readFile as readFile10 } from "node:fs/promises";
-import { resolve as resolve17, extname as extname5 } from "node:path";
+import { resolve as resolve18, extname as extname5 } from "node:path";
 async function runGet(opts) {
   const cwd = opts.cwd ?? process.cwd();
   if (opts.fields.length === 0) {
@@ -14148,7 +14577,9 @@ async function runGet(opts) {
   const externalMetadata = await loadExternalMetadata(collections, {
     configDir: configDir ?? cwd,
     base,
-    offline: opts.offline ?? config?.offline ?? false
+    offline: opts.offline ?? config?.offline ?? false,
+    // A `{page}` manifest (0058) is read for exactly the pages this run reads.
+    pages: files.map((file) => resolve18(base, file))
   });
   const commands = commandsOf(config?.derive) ?? {};
   const deriving = opts.derived !== false;
@@ -14175,7 +14606,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: resolve17(base, label),
+          absPath: resolve18(base, label),
           content,
           extracted: own2,
           ...place !== void 0 ? { provenanceManifest: place } : {}
@@ -14217,7 +14648,7 @@ async function runGet(opts) {
     readOne(STDIN_LABEL, opts.stdinContent ?? "", forced.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile10(resolve17(base, file), "utf8");
+    const content = await readFile10(resolve18(base, file), "utf8");
     readOne(file, content, extname5(file));
   }
   if (deriving) {
@@ -14343,16 +14774,16 @@ 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 resolve18, sep as sep8 } from "node:path";
-import { parseDocument as parseDocument7, parse as parseYaml6, stringify as stringify3 } from "yaml";
+import { mkdir as mkdir3, readFile as readFile11 } from "node:fs/promises";
+import { dirname as dirname10, extname as extname6, isAbsolute as isAbsolute10, join as join9, relative as relative14, resolve as resolve19, sep as sep9 } from "node:path";
+import { parseDocument as parseDocument8, parse as parseYaml6, stringify as stringify3 } from "yaml";
 function getSchemasInfo() {
   return { builtins: listBuiltins(), formats: listFormats() };
 }
 var DEFAULT_VENDOR_DIR = "./schema";
 var DEFAULT_CONFIG_NAME = "manni.config.yaml";
 function posixRelative(from, to) {
-  return relative13(from, to).split(sep8).join("/");
+  return relative14(from, to).split(sep9).join("/");
 }
 function vendorFileName(url) {
   let parsed2;
@@ -14417,7 +14848,7 @@ function renderConfig(existing, entries, section) {
   if (existing === null) {
     return stringify3({ [META_SECTION]: { schemas: entries } });
   }
-  const doc = parseDocument7(existing);
+  const doc = parseDocument8(existing);
   doc.setIn(section === void 0 ? ["schemas"] : [section, "schemas"], entries);
   return doc.toString();
 }
@@ -14438,13 +14869,13 @@ async function runVendorSchema(opts) {
     );
   }
   const loaded = await loadConfig(opts.configPath, cwd);
-  const configPath = loaded?.path ?? resolve18(cwd, DEFAULT_CONFIG_NAME);
+  const configPath = loaded?.path ?? resolve19(cwd, DEFAULT_CONFIG_NAME);
   const configDir = loaded?.dir ?? cwd;
-  const absDir = resolve18(cwd, opts.dir ?? DEFAULT_VENDOR_DIR);
+  const absDir = resolve19(cwd, opts.dir ?? DEFAULT_VENDOR_DIR);
   const absFile = join9(absDir, vendorFileName(url));
   await assertNotIgnored(absFile, absDir, cwd, opts.onNotice);
   const fromConfig = posixRelative(configDir, absFile);
-  const ref = isAbsolute9(fromConfig) || fromConfig === "" ? absFile : fromConfig.startsWith(".") ? fromConfig : `./${fromConfig}`;
+  const ref = isAbsolute10(fromConfig) || fromConfig === "" ? absFile : fromConfig.startsWith(".") ? fromConfig : `./${fromConfig}`;
   const { bytes } = await fetchSchemaBytes(url, {
     ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
     ...opts.maxBytes !== void 0 ? { maxBytes: opts.maxBytes } : {}
@@ -14467,7 +14898,7 @@ async function runVendorSchema(opts) {
       );
     }
   }
-  await mkdir2(absDir, { recursive: true });
+  await mkdir3(absDir, { recursive: true });
   await writeFileAtomic(absFile, bytes);
   const existing = loaded ? await readFile11(configPath, "utf8") : null;
   const section = loaded ? loaded.section : META_SECTION;
@@ -14598,11 +15029,6 @@ async function runInferSchema(opts) {
   });
   const joinKey = lazyKey(configFile, void 0);
   const usingStdin = inputs.includes(STDIN_TOKEN);
-  const externalMetadata = await loadExternalMetadata(collections, {
-    configDir: configDir ?? cwd,
-    base,
-    offline: opts.offline ?? config?.offline ?? false
-  });
   if (inputs.length === 0) {
     throw new DocmetaError(
       "No files to scan. Pass paths/globs, or declare a collection under `collections:` in manni.config.yaml."
@@ -14621,7 +15047,7 @@ async function runInferSchema(opts) {
   }
   let absOut;
   if (opts.out !== void 0) {
-    absOut = resolve18(cwd, opts.out);
+    absOut = resolve19(cwd, opts.out);
     await assertNotIgnored(
       absOut,
       dirname10(absOut),
@@ -14663,8 +15089,14 @@ async function runInferSchema(opts) {
     gitignoreSkipped,
     action: "scanned"
   });
+  const externalMetadata = await loadExternalMetadata(collections, {
+    configDir: configDir ?? cwd,
+    base,
+    offline: opts.offline ?? config?.offline ?? false,
+    pages: files.map((file) => resolve19(base, file))
+  });
   const stats = /* @__PURE__ */ new Map();
-  const unreadable = [];
+  const unreadable2 = [];
   let filesScanned = 0;
   let filesWithoutMetadata = 0;
   const scanOne = (label, content, extension) => {
@@ -14689,7 +15121,7 @@ async function runInferSchema(opts) {
         { encryptionKey: joinKey }
       ).extracted;
     } catch (err) {
-      unreadable.push({
+      unreadable2.push({
         file: label,
         message: err instanceof Error ? err.message : String(err)
       });
@@ -14709,10 +15141,10 @@ async function runInferSchema(opts) {
     scanOne(STDIN_LABEL, opts.stdinContent ?? "", forced.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile11(resolve18(base, file), "utf8");
+    const content = await readFile11(resolve19(base, file), "utf8");
     scanOne(file, content, extname6(file));
   }
-  for (const u of unreadable) {
+  for (const u of unreadable2) {
     opts.onNotice?.(`could not read metadata from "${u.file}": ${u.message}`);
   }
   const all = [...stats.entries()].map(([key, stat7]) => {
@@ -14751,14 +15183,14 @@ async function runInferSchema(opts) {
   };
   const keys = kept.map(({ sawEmptyString: _drop, ...rest }) => rest);
   if (absOut !== void 0) {
-    await mkdir2(dirname10(absOut), { recursive: true });
+    await mkdir3(dirname10(absOut), { recursive: true });
     await writeFileAtomic(absOut, `${JSON.stringify(draft, null, 2)}
 `);
   }
   return {
     filesScanned,
     filesWithoutMetadata,
-    unreadable,
+    unreadable: unreadable2,
     keys,
     hiddenByMinCoverage: all.length - kept.length,
     draft,
@@ -14770,8 +15202,8 @@ async function runInferSchema(opts) {
 // src/meta/commands/query.ts
 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 resolve19, extname as extname7, sep as sep9 } from "node:path";
+import { mkdir as mkdir4, open as open2, readFile as readFile12, rename as rename3, rm as rm3 } from "node:fs/promises";
+import { dirname as dirname11, isAbsolute as isAbsolute11, resolve as resolve20, extname as extname7, sep as sep10 } from "node:path";
 
 // src/shared/prompt.ts
 import { createInterface } from "node:readline";
@@ -14829,10 +15261,10 @@ async function ensureEncryptionKey(opts) {
 }
 
 // src/meta/commands/query.ts
-import { parseDocument as parseDocument9, isMap as isMap8, isSeq as isSeq5, isScalar as isScalar6 } from "yaml";
+import { parseDocument as parseDocument10, isMap as isMap9, isSeq as isSeq5, isScalar as isScalar7 } from "yaml";
 
 // src/meta/core/location-writes.ts
-import { LineCounter as LineCounter5, isMap as isMap7, isNode as isNode4, isScalar as isScalar5, parseDocument as parseDocument8 } from "yaml";
+import { LineCounter as LineCounter6, isMap as isMap8, isNode as isNode5, isScalar as isScalar6, parseDocument as parseDocument9 } from "yaml";
 var dedupe3 = (xs) => [...new Set(xs)];
 var pages = (n) => `${String(n)} page${n === 1 ? "" : "s"}`;
 async function offerExternalHomes(ctx, writes, hooks) {
@@ -14915,17 +15347,17 @@ function externalWriteWarning(line) {
   return home.reason === "no-config" ? `${head}; ${prefer}, and --no-config leaves ${them} no manifest.` : `${head} that ${line.pages === 1 ? "is" : "are"} in none of the ${String(home.collections)} collections; ${prefer}, and only a collection has a manifest.`;
 }
 function manifestKeyLine(text2, entry, key, join11) {
-  const norm = (e) => join11 === PATH_JOIN ? e.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/") : e;
-  const lc = new LineCounter5();
-  const doc = parseDocument8(text2, { lineCounter: lc, uniqueKeys: false });
+  const norm = (e) => join11 === PATH_JOIN2 ? e.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/") : e;
+  const lc = new LineCounter6();
+  const doc = parseDocument9(text2, { lineCounter: lc, uniqueKeys: false });
   const root = doc.contents;
-  if (!isMap7(root)) return void 0;
+  if (!isMap8(root)) return void 0;
   for (const pair of root.items) {
-    const spelled = isScalar5(pair.key) ? String(pair.key.value) : String(pair.key);
-    if (norm(spelled) !== norm(entry) || !isMap7(pair.value)) continue;
+    const spelled = isScalar6(pair.key) ? String(pair.key.value) : String(pair.key);
+    if (norm(spelled) !== norm(entry) || !isMap8(pair.value)) continue;
     for (const kv of pair.value.items) {
-      const name2 = isScalar5(kv.key) ? String(kv.key.value) : String(kv.key);
-      const range = isNode4(kv.key) ? kv.key.range : void 0;
+      const name2 = isScalar6(kv.key) ? String(kv.key.value) : String(kv.key);
+      const range = isNode5(kv.key) ? kv.key.range : void 0;
       if (name2 === key && range) return lc.linePos(range[0]).line;
     }
   }
@@ -15028,7 +15460,9 @@ async function runQuery(opts) {
   const externalMetadata = await loadExternalMetadata(collections, {
     configDir: configDir ?? cwd,
     base,
-    offline: opts.offline ?? config?.offline ?? false
+    offline: opts.offline ?? config?.offline ?? false,
+    // A `{page}` manifest (0058) is read for exactly the pages this run reads.
+    pages: files.map((file) => resolve20(base, file))
   });
   const configuredKey = lazyKey(configFile, opts.env);
   let ensuredKey;
@@ -15110,10 +15544,10 @@ async function runQuery(opts) {
     readOne(STDIN_LABEL, opts.stdinContent ?? "", ext);
   }
   for (const file of files) {
-    const content = await readFile12(resolve19(base, file), "utf8");
+    const content = await readFile12(resolve20(base, file), "utf8");
     readOne(file, content, extname7(file));
   }
-  const db = opts.db === void 0 ? void 0 : { resolved: resolve19(cwd, opts.db), display: opts.db };
+  const db = opts.db === void 0 ? void 0 : { resolved: resolve20(cwd, opts.db), display: opts.db };
   const run2 = await runSql(sql, entries, {
     target: db,
     params: boundParams,
@@ -15210,7 +15644,7 @@ async function runSql(sql, entries, ctx) {
   );
   const { DatabaseSync } = await loadSqlite();
   if (target) {
-    await mkdir3(dirname11(target.resolved), { recursive: true });
+    await mkdir4(dirname11(target.resolved), { recursive: true });
     await prepareDbTarget(target.resolved, target.display);
   }
   let db;
@@ -15254,7 +15688,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: resolve19(ctx.base, e.label),
+          absPath: resolve20(ctx.base, e.label),
           content: e.content,
           extracted: e.own,
           ...place !== void 0 ? { provenanceManifest: place } : {}
@@ -15719,20 +16153,20 @@ function displayPath(ctx, abs) {
 }
 function assertSchemaWriteWithin(ctx, abs) {
   const within = posixRelative(ctx.trustRoot.dir, abs);
-  if (within !== "" && !within.startsWith("..") && !isAbsolute10(within)) return;
+  if (within !== "" && !within.startsWith("..") && !isAbsolute11(within)) return;
   throw new DocmetaError(
     `The resolved schema "${abs}" lives outside ${ctx.trustRoot.dir}; DDL edits schemas inside the repository. Evolve it where it lives, or vendor a copy in.`
   );
 }
 function foldPath(p) {
-  const abs = resolve19(p);
+  const abs = resolve20(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(resolve19(ctx.cwd, ref)), pin);
+    byPath.set(foldPath(resolve20(ctx.cwd, ref)), pin);
   }
   return byPath;
 }
@@ -15760,7 +16194,7 @@ async function loadSetMembers(refs, ctx) {
       });
       continue;
     }
-    const abs = resolve19(ctx.cwd, ref);
+    const abs = resolve20(ctx.cwd, ref);
     const canon = foldPath(abs);
     if (seenFiles.has(canon)) continue;
     seenFiles.add(canon);
@@ -15965,7 +16399,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 = resolve19(ctx.configDir ?? ctx.cwd, "schemas", forkName);
+    schemaAbs = resolve20(ctx.configDir ?? ctx.cwd, "schemas", forkName);
     assertSchemaWriteWithin(ctx, schemaAbs);
     if (existsSync5(schemaAbs)) {
       throw new DocmetaError(
@@ -16122,17 +16556,17 @@ async function planConfigEdit(ctx, edit, runRefs) {
     return { changes: [], repointed: false };
   }
   const text2 = await readFile12(configPath, "utf8");
-  const doc = parseDocument9(stripBom2(text2));
+  const doc = parseDocument10(stripBom2(text2));
   const display = displayPath(ctx, configPath);
   const rawRefOf = (item) => {
-    if (isScalar6(item) && typeof item.value === "string") return item.value;
-    if (isMap8(item)) {
+    if (isScalar7(item) && typeof item.value === "string") return item.value;
+    if (isMap9(item)) {
       const ref = item.get("ref");
       if (typeof ref === "string") return ref;
     }
     return void 0;
   };
-  const rebaseRaw = (raw) => classifyRef(raw).kind === "file" && !isAbsolute10(raw) ? resolve19(configDir, raw) : raw;
+  const rebaseRaw = (raw) => classifyRef(raw).kind === "file" && !isAbsolute11(raw) ? resolve20(configDir, raw) : raw;
   const wantSet = runRefs.map(rebaseRaw).sort().join("\n");
   const seqResolvesToRunSet = (node) => {
     if (!isSeq5(node)) return false;
@@ -16148,10 +16582,10 @@ async function planConfigEdit(ctx, edit, runRefs) {
     for (const item of node.items) {
       const raw = rawRefOf(item);
       if (raw === void 0 || !wants(raw)) continue;
-      if (isScalar6(item)) {
+      if (isScalar7(item)) {
         item.value = spec.newRef;
         n += 1;
-      } else if (isMap8(item)) {
+      } else if (isMap9(item)) {
         item.set("ref", spec.newRef);
         n += 1;
       }
@@ -16159,13 +16593,13 @@ async function planConfigEdit(ctx, edit, runRefs) {
     return n;
   };
   const root = ctx.configSection === void 0 ? doc : doc.get(ctx.configSection, true);
-  const keyOf2 = (key) => root === doc ? doc.get(key, true) : isMap8(root) ? root.get(key, true) : void 0;
+  const keyOf2 = (key) => root === doc ? doc.get(key, true) : isMap9(root) ? root.get(key, true) : void 0;
   const topSeq = keyOf2("schemas");
   let repointCount = repoint(topSeq);
   const overrides = keyOf2("overrides");
   if (isSeq5(overrides)) {
     for (const entry of overrides.items) {
-      if (isMap8(entry)) repointCount += repoint(entry.get("schemas", true));
+      if (isMap9(entry)) repointCount += repoint(entry.get("schemas", true));
     }
   }
   const repointed = repointCount > 0;
@@ -16174,10 +16608,10 @@ async function planConfigEdit(ctx, edit, runRefs) {
   if (edit.integrity && isSeq5(topSeq)) {
     const wantPath = foldPath(edit.integrity.path);
     for (const item of topSeq.items) {
-      if (!isMap8(item)) continue;
+      if (!isMap9(item)) continue;
       const raw = rawRefOf(item);
       if (raw === void 0 || classifyRef(raw).kind !== "file") continue;
-      const abs = isAbsolute10(raw) ? raw : resolve19(configDir, raw);
+      const abs = isAbsolute11(raw) ? raw : resolve20(configDir, raw);
       if (foldPath(abs) !== wantPath) continue;
       pinFrom = item.get("integrity");
       item.set("integrity", edit.integrity.value);
@@ -16406,7 +16840,7 @@ function buildChanges(diff, entries, sentinel, ctx, renameHints = [], booleanAdd
         `"${file}": no writable format for that extension.`
       );
     }
-    if (existsSync5(resolve19(ctx.base, file))) {
+    if (existsSync5(resolve20(ctx.base, file))) {
       throw new DocmetaError(
         `"${file}" already exists; INSERT creates new files only.`
       );
@@ -16425,7 +16859,7 @@ function buildChanges(diff, entries, sentinel, ctx, renameHints = [], booleanAdd
         `"${from}" -> "${to}": a rename may not change the extension.`
       );
     }
-    if (existsSync5(resolve19(ctx.base, to))) {
+    if (existsSync5(resolve20(ctx.base, to))) {
       throw new DocmetaError(
         `"${to}" already exists; the rename would overwrite it.`
       );
@@ -16454,13 +16888,13 @@ function validateNewPath(p, base) {
   const refuse = (why) => {
     throw new DocmetaError(`"${p}" is not a usable path: ${why}.`);
   };
-  if (isAbsolute10(p)) refuse("it is absolute");
+  if (isAbsolute11(p)) refuse("it is absolute");
   if (p.split(/[\\/]/).some((segment) => segment === "..")) {
     refuse("it traverses upward");
   }
-  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");
+  const abs = resolve20(base, p);
+  if (abs === resolve20(base)) refuse("it points at the corpus root, not a file");
+  if (!abs.startsWith(resolve20(base) + sep10)) refuse("it escapes the corpus");
 }
 function refuseJoinFieldChanges(changes, entries, ctx) {
   const index = ctx.externalMetadata;
@@ -16531,6 +16965,12 @@ function postChangeData(changes, entries) {
   }
   return out;
 }
+function runPages(changes, entries, base) {
+  const labels = new Set(entries.map((e) => e.label));
+  for (const c of changes) if (!("schema" in c) && !("config" in c)) labels.add(c.file);
+  labels.delete(STDIN_LABEL);
+  return [...labels].map((label) => resolve20(base, label));
+}
 async function planManifestEdits(changes, entries, ctx, renameHints) {
   for (const c of changes) {
     delete c.manifest;
@@ -16579,12 +17019,18 @@ async function planManifestEdits(changes, entries, ctx, renameHints) {
     let write = texts.get(home.absPath);
     if (write === void 0) {
       let text2;
+      let expected;
       try {
         text2 = await readFile12(home.absPath, "utf8");
+        expected = text2;
       } catch (err) {
-        throw new DocmetaError(`Manifest ${home.file} could not be read: ${errorMessage(err)}`);
+        if (!home.perPage || !isMissing(err)) {
+          throw new DocmetaError(`Manifest ${home.file} could not be read: ${errorMessage(err)}`);
+        }
+        text2 = "";
+        expected = null;
       }
-      write = { path: home.absPath, display: home.file, text: text2, expected: text2 };
+      write = { path: home.absPath, display: home.file, text: text2, expected };
       texts.set(home.absPath, write);
     }
     write.text = change(write.text);
@@ -16607,13 +17053,13 @@ async function planManifestEdits(changes, entries, ctx, renameHints) {
         ...col,
         externalMetadata: col.externalMetadata.filter((m) => classifyRef(m.file).kind !== "url")
       })),
-      { configDir: ctx.configDir ?? ctx.cwd, base: ctx.base }
+      { configDir: ctx.configDir ?? ctx.cwd, base: ctx.base, pages: runPages(changes, entries, ctx.base) }
     );
     const index = await leftOut;
     if (index === null) return void 0;
-    const abs = resolve19(ctx.base, file);
+    const abs = resolve20(ctx.base, file);
     const named = index.entries.find(
-      (e) => e.join === PATH_JOIN && e.abs === abs && excluded.includes(e.collection)
+      (e) => e.join === PATH_JOIN2 && e.abs === abs && excluded.includes(e.collection)
     );
     if (named !== void 0) return named;
     if (!joins || own2 === void 0) return void 0;
@@ -16658,7 +17104,7 @@ async function planManifestEdits(changes, entries, ctx, renameHints) {
       continue;
     }
     if ("renamed" in c) {
-      const supplied = ctx.externalMetadata?.byPath.get(resolve19(ctx.base, c.file));
+      const supplied = ctx.externalMetadata?.byPath.get(resolve20(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;
@@ -16669,7 +17115,12 @@ async function planManifestEdits(changes, entries, ctx, renameHints) {
             `"${c.file}": manifest ${home.file} names it, which is fetched and cannot be written; rename the entry in that repository.`
           );
         }
-        if (home.kind !== "manifest" || home.join !== PATH_JOIN || home.entry === void 0) continue;
+        if (home.kind === "manifest" && home.perPage) {
+          throw new DocmetaError(
+            `${c.file} cannot move to ${c.renamed}, because its "${key}" lives in ${home.file}, a {page} manifest named after the page's path. Move the page and its manifest together, then rename the entry's key.`
+          );
+        }
+        if (home.kind !== "manifest" || home.join !== PATH_JOIN2 || home.entry === void 0) continue;
         const moved = await keyHome(loc, c.renamed, own2, key);
         if (moved.kind !== "manifest" || moved.absPath !== home.absPath || moved.entry === void 0) {
           throw new DocmetaError(
@@ -16733,7 +17184,7 @@ async function planManifestEdits(changes, entries, ctx, renameHints) {
     }
     pageRoutes.set(c, ops);
   }
-  return [...texts.values()].filter((w) => w.text !== w.expected);
+  return [...texts.values()].filter((w) => w.text !== (w.expected ?? ""));
 }
 async function unhomedWrites(changes, entries, ctx) {
   const written = /* @__PURE__ */ new Map();
@@ -16765,7 +17216,7 @@ async function unhomedWrites(changes, entries, ctx) {
     const prefs = await validator.locationPreferences(data, refs);
     const joins = new Set(
       memberOf(loc.declaredCollections, loc.configDir ?? ctx.cwd, ctx.base, file).flatMap(
-        (name2) => (loc.declaredCollections.find((col) => col.name === name2)?.externalMetadata ?? []).map((m) => externalMetadataJoin(m)).filter((j) => j !== PATH_JOIN)
+        (name2) => (loc.declaredCollections.find((col) => col.name === name2)?.externalMetadata ?? []).map((m) => externalMetadataJoin(m)).filter((j) => j !== PATH_JOIN2)
       )
     );
     for (const key of new Set(w.keys)) {
@@ -16816,7 +17267,8 @@ async function offerRelocation(changes, entries, ctx) {
       ctx.externalMetadata = await loadExternalMetadata(loc.collections, {
         configDir: loc.configDir ?? ctx.cwd,
         base: ctx.base,
-        offline: ctx.location.offline
+        offline: ctx.location.offline,
+        pages: runPages(changes, entries, ctx.base)
       });
       ctx.memberships = (label) => memberOf(loc.collections, loc.configDir ?? ctx.cwd, ctx.base, label);
       unhomed = await unhomedWrites(changes, entries, ctx);
@@ -16960,14 +17412,14 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
   const pendingWrites = [];
   const pendingRenames = [];
   for (const [label, ops] of grouped) {
-    const path = resolve19(ctx.base, label);
+    const path = resolve20(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 = resolve19(ctx.base, ops.renamedTo);
+      const toDisk = resolve20(ctx.base, ops.renamedTo);
       if (existsSync5(toDisk)) {
         throw new DocmetaError(
           `"${ops.renamedTo}" appeared on disk since the plan; re-run the query.`
@@ -17092,7 +17544,7 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
     try {
       now = await readFile12(m.path, "utf8");
     } catch {
-      now = void 0;
+      now = null;
     }
     if (now !== m.expected) {
       throw new DocmetaError(
@@ -17106,7 +17558,10 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
   for (const p of pendingWrites) {
     if (p.ensureDir) dirs.add(dirname11(p.path));
   }
-  for (const d of dirs) await mkdir3(d, { recursive: true });
+  for (const m of manifestWrites) {
+    if (m.expected === null) dirs.add(dirname11(m.path));
+  }
+  for (const d of dirs) await mkdir4(d, { recursive: true });
   const writeSchema = async () => {
     for (const w of schemaWrites) await writeFileAtomic(w.path, w.content);
   };
@@ -17221,7 +17676,7 @@ function skipExpression(sql, from) {
 
 // src/meta/commands/fill.ts
 import { readFile as readFile14 } from "node:fs/promises";
-import { resolve as resolve20, extname as extname8, join as join10 } from "node:path";
+import { resolve as resolve21, extname as extname8, join as join10 } from "node:path";
 import {
   completeValidatedJSON,
   makeProvider,
@@ -17237,68 +17692,6 @@ import {
 
 // 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 };
@@ -17311,11 +17704,12 @@ var manifestCodec = {
 function applyManifestOp(text2, op) {
   return manifestCodec.apply(text2, op);
 }
-async function holdManifestFile(path, file) {
+async function holdManifestFile(path, file, perPage = false) {
   let before;
   try {
     before = await readFile13(path, "utf8");
   } catch (err) {
+    if (perPage && isMissing(err)) return heldManifest(path, file, "", true);
     throw new DocmetaError(`Manifest ${file} could not be read: ${errorMessage(err)}`);
   }
   return heldManifest(path, file, before);
@@ -17328,7 +17722,8 @@ async function settleManifest(held, io = {}) {
   if (held.text === held.before) return false;
   await settle(held, {
     codec: manifestCodec,
-    write: io.write ?? writeFileAtomic,
+    // A per-page manifest (proposal 0058) may be the first file in its directory.
+    write: io.write ?? ((at2, text2) => writeFileAtomic(at2, text2, { createParents: true })),
     read: io.read ?? ((at2) => readFile13(at2, "utf8")),
     toError: (message) => new DocmetaError(message)
   });
@@ -17612,7 +18007,9 @@ async function runFill(opts) {
   const loadManifests = () => loadExternalMetadata(mergedCollections(), {
     configDir: configDir ?? cwd,
     base,
-    offline: opts.offline ?? config?.offline ?? false
+    offline: opts.offline ?? config?.offline ?? false,
+    // A `{page}` manifest (0058) is read for exactly the pages this run fills.
+    pages: files.map((file) => resolve21(base, file))
   });
   const mergeMembersFor = (label) => memberOf(runConfig.declaredCollections, configDir ?? cwd, base, label);
   let externalMetadata = await loadManifests();
@@ -17649,7 +18046,7 @@ async function runFill(opts) {
   };
   const restorePage = async (label, before) => {
     try {
-      await writeFileAtomic(resolve20(base, label), before);
+      await writeFileAtomic(resolve21(base, label), before);
       return `${label} was restored.`;
     } catch (err) {
       return `${label} could not be restored: ${errorMessage(err)}. Restore it from version control.`;
@@ -17658,7 +18055,7 @@ async function runFill(opts) {
   const holdManifest = (home) => {
     let held = holding.get(home.absPath);
     if (held === void 0) {
-      held = holdManifestFile(home.absPath, home.file).then((m) => {
+      held = holdManifestFile(home.absPath, home.file, home.perPage).then((m) => {
         const h = { held: m, saving: Promise.resolve() };
         heldManifests.set(home.absPath, h);
         return h;
@@ -18194,7 +18591,7 @@ async function runFill(opts) {
     const changed = next !== content || manifestChanged;
     const pageWritten = next !== content && !dryRun && label !== "<stdin>";
     if (pageWritten) {
-      await writeFileAtomic(resolve20(base, label), next);
+      await writeFileAtomic(resolve21(base, label), next);
     }
     if (manifestChanged) {
       const perManifest = /* @__PURE__ */ new Map();
@@ -18226,7 +18623,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 readFile14(resolve20(base, file), "utf8");
+      const content = await readFile14(resolve21(base, file), "utf8");
       return prepareOne(file, content, extname8(file));
     })
   });
@@ -18656,7 +19053,7 @@ async function mapConcurrent(items2, limit, fn) {
 
 // src/meta/commands/derive.ts
 import { readFile as readFile15 } from "node:fs/promises";
-import { extname as extname9, relative as relative14, resolve as resolve21, sep as sep10 } from "node:path";
+import { extname as extname9, relative as relative15, resolve as resolve22, sep as sep11 } from "node:path";
 var GENERATED_BY_ENV = "MANNI_GENERATED_BY";
 var SOURCE_HINT = "narrow --sources or --fields";
 async function runDerive(opts) {
@@ -18767,7 +19164,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, resolve21(base, t.page)).split(sep10).join("/");
+    const label = relative15(base, resolve22(base, t.page)).split(sep11).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.`
@@ -18792,7 +19189,7 @@ async function runDerive(opts) {
     const loaded2 = /* @__PURE__ */ new Map();
     const errors2 = /* @__PURE__ */ new Map();
     for (const label of files) {
-      const absPath = resolve21(base, label);
+      const absPath = resolve22(base, label);
       const extractor = forcedExtractor ?? extractorForExtension(extname9(label));
       if (!extractor) {
         errors2.set(label, {
@@ -18818,12 +19215,13 @@ async function runDerive(opts) {
       }
     }
     const provenanceRoot = configDir ?? cwd;
+    const pages2 = files.map((label) => resolve22(base, label));
     const manifests = wantsProvenance ? provenanceManifests(declaredCollections, provenanceRoot, base) : [];
     const provenanceCollections = declaredCollections.map((c) => ({
       ...c,
       externalMetadata: c.externalMetadata.filter((m) => m.keys.includes(PROVENANCE_FIELD))
     })).filter((c) => c.externalMetadata.length > 0);
-    const provenanceIndex = manifests.length === 0 ? null : await loadExternalMetadata(provenanceCollections, { configDir: provenanceRoot, base });
+    const provenanceIndex = manifests.length === 0 ? null : await loadExternalMetadata(provenanceCollections, { configDir: provenanceRoot, base, pages: pages2 });
     const places2 = /* @__PURE__ */ new Map();
     for (const doc of loaded2.values()) {
       if (!wantsProvenance) break;
@@ -18850,7 +19248,7 @@ async function runDerive(opts) {
         (m) => classifyRef(m.file).kind !== "url" && m.keys.some((k) => k !== PROVENANCE_FIELD && fields.includes(k))
       )
     })).filter((c) => c.externalMetadata.length > 0);
-    const ownedIndex = ownedCollections.length === 0 ? null : await loadExternalMetadata(ownedCollections, { configDir: provenanceRoot, base });
+    const ownedIndex = ownedCollections.length === 0 ? null : await loadExternalMetadata(ownedCollections, { configDir: provenanceRoot, base, pages: pages2 });
     const derived2 = await deriveMetadata([...loaded2.values()], {
       cwd,
       base,
@@ -18945,8 +19343,8 @@ async function runDerive(opts) {
             error: `${at2} is encrypted, and no encryption key is available to compare it. Set ${ENCRYPTION_KEY_ENV}, or run \`manni key set\`.`
           };
         }
-        const unreadable = view.unreadable.find((p) => isAtOrUnder(p, at2));
-        if (unreadable !== void 0) return { error: unreadableMessage(unreadable) };
+        const unreadable2 = view.unreadable.find((p) => isAtOrUnder(p, at2));
+        if (unreadable2 !== void 0) return { error: unreadableMessage(unreadable2) };
       }
       const stamped = { ...view.data };
       for (const field of fields) {
@@ -19022,7 +19420,7 @@ async function runDerive(opts) {
   const holdManifest = async (manifest) => {
     const already = heldManifests.get(manifest.absPath);
     if (already !== void 0) return already;
-    const held = await holdManifestFile(manifest.absPath, manifest.file);
+    const held = await holdManifestFile(manifest.absPath, manifest.file, manifest.perPage);
     heldManifests.set(manifest.absPath, held);
     return held;
   };
@@ -19953,6 +20351,9 @@ export {
   palette,
   shouldColor,
   matchesFileGlob,
+  hasPagePlaceholder,
+  pageManifestPath,
+  findPageManifests,
   externalMetadataUrlProblem,
   parseCollections,
   selectCollections,
@@ -19965,6 +20366,7 @@ export {
   findGitRoot,
   valeConfigPath,
   programName,
+  warn,
   notice,
   ToolError,
   errorMessage,
@@ -20005,6 +20407,7 @@ export {
   committedKeyWarning,
   terminalConfirm,
   ensureEncryptionKey,
+  gitIgnored,
   escapePointerSegment,
   hasFrontmatterFence,
   locateFrontmatter,
@@ -20068,6 +20471,10 @@ export {
   isMachineFormat,
   OMITTED_WHEN_CLEAN,
   render,
+  heldManifest,
+  rebaseable,
+  settle,
+  isMissing,
   EXTERNAL_METADATA_FETCH_TIMEOUT_MS,
   EXTERNAL_METADATA_FETCH_MAX_BYTES,
   fetchExternalMetadata,
@@ -20076,7 +20483,7 @@ export {
   EXTERNAL_OWNED_SCHEMA,
   EXTERNAL_DUPLICATE_SCHEMA,
   EXTERNAL_KEYWORD,
-  PATH_JOIN,
+  PATH_JOIN2 as PATH_JOIN,
   externalMetadataJoin,
   loadExternalMetadata,
   mergeExternalMetadata,
@@ -20134,9 +20541,6 @@ export {
   runVendorSchema,
   runInferSchema,
   runQuery,
-  heldManifest,
-  rebaseable,
-  settle,
   runFill,
   runDerive,
   deriveFailed,
@@ -20155,4 +20559,4 @@ export {
   renderQuery,
   renderQueryCsv
 };
-//# sourceMappingURL=chunk-KJLPOY2I.js.map
+//# sourceMappingURL=chunk-BUXVMARH.js.map