@hawkeyexl/manni 4.3.0 → 4.4.0

package/dist/chunk-RLR4TKUZ.js

@@ -0,0 +1,4398 @@
+#!/usr/bin/env node
+import {
+  DERIVED_KEYWORD,
+  DERIVED_STALE_SCHEMA,
+  DocmetaError,
+  FILE_SCHEMA_KEY,
+  ManifestCache,
+  STDIN_LABEL,
+  STDIN_TOKEN,
+  blockLines,
+  classifyRef,
+  colOf,
+  collectSchemaPins,
+  colonEnd,
+  contentEnd,
+  deepEqual,
+  detectEol,
+  detectStyle,
+  emptySource,
+  escapePointerSegment,
+  extractFrontmatter,
+  extractorByName,
+  extractorForExtension,
+  gitignoreOptions,
+  insertKey,
+  integrityOf,
+  keyLines,
+  keyString,
+  lineEnd,
+  loadConfig,
+  loadSchema,
+  locateFrontmatter,
+  positionForFactory,
+  publishedBuiltins,
+  rangeOf,
+  rebaseConfigSchemaRefs,
+  replaceBlockValue,
+  replaceFlowValue,
+  resolveElements,
+  resolveSchemaSetWithSource,
+  resolveTargetSet,
+  schemaLoadOptions,
+  schemaTrustRoot,
+  writeFileAtomic
+} from "./chunk-JVTNMVYU.js";
+import {
+  STDIN_LINES_MARKER
+} from "./chunk-YEUYKR62.js";
+import {
+  ENCRYPTION_KEY_FIELD,
+  ENCRYPTION_KEY_PREVIOUS_FIELD,
+  FAMILY_CONFIG_NAMES,
+  KEYED_PIN_PREFIX,
+  PAGE_PLACEHOLDER,
+  decryptValue,
+  externalMetadataOrigin,
+  findGitRoot,
+  findPageManifests,
+  hasPagePlaceholder,
+  isEncryptedValue,
+  isMember,
+  isValidEncryptionKey,
+  keyedPin,
+  matchesCollectionPaths,
+  neverOwned,
+  ownsKey,
+  pageManifestPath,
+  parseCollections,
+  sameFile
+} from "./chunk-Q35YIDBV.js";
+import {
+  ToolError,
+  errorMessage
+} from "./chunk-G3T47CFV.js";
+
+// src/meta/core/external-metadata-fetch.ts
+var EXTERNAL_METADATA_FETCH_TIMEOUT_MS = 1e4;
+var EXTERNAL_METADATA_FETCH_MAX_BYTES = 5 * 1024 * 1024;
+var MAX_REDIRECTS = 5;
+var RETRY_DELAY_MS = 500;
+async function fetchExternalMetadata(url, opts = {}) {
+  if (opts.offline) {
+    throw new DocmetaError(
+      `Manifest ${url} is remote and the run is offline. Vendor it to a path, or drop --offline.`
+    );
+  }
+  const timeoutMs = opts.timeoutMs ?? EXTERNAL_METADATA_FETCH_TIMEOUT_MS;
+  const maxBytes = opts.maxBytes ?? EXTERNAL_METADATA_FETCH_MAX_BYTES;
+  const env = opts.env ?? process.env;
+  let token;
+  if (opts.tokenEnv !== void 0) {
+    token = env[opts.tokenEnv];
+    if (token === void 0 || token === "") {
+      throw new DocmetaError(
+        `Manifest ${url}: the environment variable ${opts.tokenEnv} named by "tokenEnv" is not set.`
+      );
+    }
+  }
+  let res = await requestWithRedirects(url, token, timeoutMs);
+  if (res instanceof Error || res.status >= 500) {
+    await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+    res = await requestWithRedirects(url, token, timeoutMs);
+  }
+  if (res instanceof Error) {
+    throw new DocmetaError(
+      `Manifest ${url} could not be fetched: ${res.message}`
+    );
+  }
+  if (!res.ok) {
+    const hint = res.status === 404 && token === void 0 ? ' (a private file answers 404 without a token; set "tokenEnv")' : res.status === 404 ? " (a private file answers 404 without a valid token)" : "";
+    throw new DocmetaError(
+      `Manifest ${url} could not be fetched: HTTP ${res.status}${hint}.`
+    );
+  }
+  return readCapped(url, res, maxBytes);
+}
+async function requestWithRedirects(url, token, timeoutMs) {
+  const origin = new URL(url).origin;
+  let current = url;
+  for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+    const sameOrigin = new URL(current).origin === origin;
+    const headers = { accept: "text/plain, application/x-yaml, */*" };
+    if (token !== void 0 && sameOrigin) headers.authorization = `Bearer ${token}`;
+    let res;
+    try {
+      res = await fetch(current, {
+        headers,
+        redirect: "manual",
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (err) {
+      const isAbort = err instanceof Error && err.name === "TimeoutError";
+      return isAbort ? new Error(`timed out after ${timeoutMs}ms`) : new Error(err instanceof Error ? err.message : String(err));
+    }
+    if (res.status >= 300 && res.status < 400) {
+      const location = res.headers.get("location");
+      if (location === null) return res;
+      await res.body?.cancel();
+      current = new URL(location, current).toString();
+      continue;
+    }
+    return res;
+  }
+  return new Error(`more than ${MAX_REDIRECTS} redirects`);
+}
+async function readCapped(url, res, maxBytes) {
+  const body = res.body;
+  if (!body) return "";
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done || value === void 0) break;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      await reader.cancel();
+      throw new DocmetaError(
+        `Manifest ${url} is too large: the response exceeds the ${maxBytes}-byte limit.`
+      );
+    }
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+// src/shared/encryption-key.ts
+import { spawnSync } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { basename as basename2, dirname as dirname2, join as join2, relative, resolve } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { isMap, parseDocument, parse as parseYaml, stringify } from "yaml";
+
+// src/shared/write-file.ts
+import { chmod, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+var LOCKED = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
+var RENAME_ATTEMPTS = 3;
+function errorCode(err) {
+  return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
+}
+var wait = (ms) => new Promise((resolve4) => {
+  setTimeout(resolve4, ms);
+});
+async function writeTextAtomic(path, text) {
+  const tmp = join(
+    dirname(path),
+    `.${basename(path)}.manni-${process.pid}-${Math.random().toString(36).slice(2, 8)}.tmp`
+  );
+  try {
+    await writeFile(tmp, text, "utf8");
+    try {
+      const { mode } = await stat(path);
+      await chmod(tmp, mode);
+    } catch {
+    }
+    for (let attempt = 1; ; attempt++) {
+      try {
+        await rename(tmp, path);
+        return;
+      } catch (err) {
+        const code = errorCode(err);
+        if (code === void 0 || !LOCKED.has(code) || attempt >= RENAME_ATTEMPTS) {
+          throw err;
+        }
+        await wait(attempt * 50);
+      }
+    }
+  } finally {
+    await rm(tmp, { force: true });
+  }
+}
+
+// src/shared/encryption-key.ts
+var ENCRYPTION_KEY_ENV = "MANNI_ENCRYPTION_KEY";
+function resolveEncryptionKey(opts) {
+  const env = opts.env ?? process.env;
+  const fromEnv = env[ENCRYPTION_KEY_ENV];
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    if (!isValidEncryptionKey(fromEnv)) {
+      throw opts.toError(
+        `${ENCRYPTION_KEY_ENV} must be at least 32 hex or base64url characters.`
+      );
+    }
+    return { key: fromEnv, source: "env" };
+  }
+  const fromFile = opts.file?.encryptionKey;
+  if (fromFile !== void 0) return { key: fromFile, source: "config" };
+  return { key: void 0, source: "none" };
+}
+function relativeSource(cwd, path) {
+  return relative(resolve(cwd), path).replace(/\\/g, "/");
+}
+function errorCode2(err) {
+  return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
+}
+async function readIfPresent(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (err) {
+    if (errorCode2(err) === "ENOENT") return null;
+    throw err;
+  }
+}
+async function fileTarget(file, toError) {
+  if (file.kind === "legacy" || !file.wrapped) {
+    throw toError(
+      `${file.source} is a single-tool config file, which cannot hold the family ${ENCRYPTION_KEY_FIELD}. Move its keys under the tool's section in ${FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml"}, or set ${ENCRYPTION_KEY_ENV}.`
+    );
+  }
+  const text = await readIfPresent(file.path);
+  return { path: file.path, source: file.source, text: text ?? file.text };
+}
+async function defaultTarget(cwd) {
+  const root = findGitRoot(cwd) ?? resolve(cwd);
+  for (const name of FAMILY_CONFIG_NAMES) {
+    const path2 = join2(root, name);
+    const text = await readIfPresent(path2);
+    if (text !== null) return { path: path2, source: relativeSource(cwd, path2), text };
+  }
+  const path = join2(root, FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml");
+  return { path, source: relativeSource(cwd, path), text: null };
+}
+function withKey(text, key, previous, source, toError) {
+  const doc = parseDocument(text);
+  const [first] = doc.errors;
+  if (first !== void 0) {
+    throw toError(`${source}: invalid YAML: ${first.message}`);
+  }
+  if (doc.contents !== null && !isMap(doc.contents)) {
+    throw toError(`${source}: top level must be a mapping.`);
+  }
+  doc.set(ENCRYPTION_KEY_FIELD, key);
+  if (typeof previous === "string") doc.set(ENCRYPTION_KEY_PREVIOUS_FIELD, previous);
+  if (previous === null) doc.delete(ENCRYPTION_KEY_PREVIOUS_FIELD);
+  return doc.toString();
+}
+function isMapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function verify(before, after, key, previous, source, toError) {
+  const old = before === null ? null : parseYaml(before);
+  const expected = Object.fromEntries(
+    Object.entries({
+      ...isMapping(old) ? old : {},
+      [ENCRYPTION_KEY_FIELD]: key,
+      ...typeof previous === "string" ? { [ENCRYPTION_KEY_PREVIOUS_FIELD]: previous } : {}
+    }).filter(([name]) => previous !== null || name !== ENCRYPTION_KEY_PREVIOUS_FIELD)
+  );
+  const reread = parseYaml(after);
+  if (!isMapping(reread) || !isDeepStrictEqual(reread, expected)) {
+    throw toError(
+      `Could not write ${ENCRYPTION_KEY_FIELD} to ${source}; add the key by hand.`
+    );
+  }
+}
+async function writeEncryptionKey(opts) {
+  const { file, key, toError, previous } = opts;
+  if (!isValidEncryptionKey(key)) {
+    throw toError(
+      `The ${ENCRYPTION_KEY_FIELD} must be at least 32 hex or base64url characters.`
+    );
+  }
+  if (typeof previous === "string" && !isValidEncryptionKey(previous)) {
+    throw toError(
+      `The ${ENCRYPTION_KEY_PREVIOUS_FIELD} must be at least 32 hex or base64url characters.`
+    );
+  }
+  const target = file === null ? await defaultTarget(opts.cwd) : await fileTarget(file, toError);
+  const text = target.text === null ? stringify({
+    [ENCRYPTION_KEY_FIELD]: key,
+    ...typeof previous === "string" ? { [ENCRYPTION_KEY_PREVIOUS_FIELD]: previous } : {}
+  }) : withKey(target.text, key, previous, target.source, toError);
+  verify(target.text, text, key, previous, target.source, toError);
+  if (opts.dryRun !== true) await writeTextAtomic(target.path, text);
+  return { path: target.path, source: target.source, created: target.text === null };
+}
+function isIgnoredByGit(path) {
+  const result = spawnSync("git", ["check-ignore", "-q", "--", basename2(path)], {
+    cwd: dirname2(path),
+    stdio: "ignore",
+    windowsHide: true
+  });
+  if (result.error !== void 0) return void 0;
+  if (result.status === 0) return true;
+  if (result.status === 1) return false;
+  return void 0;
+}
+var committedKeyWarning = (source) => `${source} is not ignored by git: once committed, anyone who can read the repository can decrypt every encrypted value. Prefer MANNI_ENCRYPTION_KEY for a shared repository.`;
+
+// src/meta/core/encrypted.ts
+var ENCRYPT_KEYWORD = "x-manni-encrypt";
+var ENCRYPTED_PLAIN_SCHEMA = "encrypted:plain";
+var ENCRYPTED_UNREADABLE_SCHEMA = "encrypted:unreadable";
+var ENCRYPTED_KEYWORD = "encrypted";
+var ENCRYPTED_PLACEHOLDER = "(encrypted)";
+var META_CONTEXT = "meta";
+var EncryptionRefusal = class extends DocmetaError {
+};
+var plainMessage = (pointer) => `${pointer} holds a plain value; its schema marks it ${ENCRYPT_KEYWORD}.`;
+var unreadableMessage = (pointer) => `${pointer} does not decrypt under the current key: encrypted under another key, or edited by hand.`;
+function unverifiedWarning(count2) {
+  const what = count2 === 1 ? "1 encrypted value was not verified" : `${count2} encrypted values were not verified`;
+  return `${what}: no encryption key is available. Set ${ENCRYPTION_KEY_ENV}, or run \`manni key set\`.`;
+}
+function lazyKey(file, env) {
+  let resolved;
+  return () => {
+    resolved ??= {
+      key: resolveEncryptionKey({
+        ...env === void 0 ? {} : { env },
+        file: file ?? null,
+        toError: (m) => new EncryptionRefusal(m)
+      }).key
+    };
+    return resolved.key;
+  };
+}
+function pointerOf(key) {
+  return `/${escapePointerSegment(key)}`;
+}
+function segments(pointer) {
+  if (pointer === "") return [];
+  return pointer.slice(1).split("/").map((s) => s.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function topLevelKeyOf(pointer) {
+  const parts = segments(pointer);
+  return parts.length === 1 ? parts[0] : void 0;
+}
+function isAtOrUnder(pointer, ancestor) {
+  return pointer === ancestor || ancestor === "" || pointer.startsWith(`${ancestor}/`);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function valueAt(data, pointer) {
+  let node = data;
+  for (const seg of segments(pointer)) {
+    if (Array.isArray(node)) {
+      const items = node;
+      node = /^\d+$/.test(seg) ? items[Number(seg)] : void 0;
+    } else if (isRecord(node)) {
+      node = Object.hasOwn(node, seg) ? node[seg] : void 0;
+    } else {
+      return void 0;
+    }
+  }
+  return node;
+}
+function withValueAt(root, pointer, value) {
+  const parts = segments(pointer);
+  const set = (node, i) => {
+    const seg = parts[i];
+    if (seg === void 0) return value;
+    if (Array.isArray(node)) {
+      const items = [...node];
+      if (!/^\d+$/.test(seg) || Number(seg) >= items.length) return node;
+      items[Number(seg)] = set(items[Number(seg)], i + 1);
+      return items;
+    }
+    if (isRecord(node) && Object.hasOwn(node, seg)) {
+      return { ...node, [seg]: set(node[seg], i + 1) };
+    }
+    return node;
+  };
+  return set(root, 0);
+}
+var MAX_ROUNDS = 8;
+async function encryptionView(opts) {
+  const { data, refs, validator, key, locate } = opts;
+  const view = {
+    data,
+    marked: [],
+    plain: [],
+    decrypted: [],
+    unreadable: [],
+    unverified: []
+  };
+  const seen = /* @__PURE__ */ new Set();
+  const sealed = [];
+  for (let round = 0; round < MAX_ROUNDS; round++) {
+    const marks = await validator.markedPointers(view.data, refs);
+    const fresh = [...marks].filter((p) => !seen.has(p)).sort((a, b) => segments(a).length - segments(b).length);
+    if (fresh.length === 0) break;
+    for (const pointer of fresh) {
+      seen.add(pointer);
+      if (sealed.some((s) => isAtOrUnder(pointer, s))) continue;
+      const value = valueAt(data, pointer);
+      if (value === void 0) continue;
+      view.marked.push(pointer);
+      if (!isEncryptedValue(value)) {
+        if (locate?.(pointer) === void 0) view.plain.push(pointer);
+        continue;
+      }
+      sealed.push(pointer);
+      const k = key();
+      if (k === void 0) {
+        view.unverified.push(pointer);
+        continue;
+      }
+      const opened = decryptValue(value, k, META_CONTEXT);
+      if (!opened.ok) {
+        view.unreadable.push(pointer);
+        continue;
+      }
+      view.decrypted.push(pointer);
+      view.data = withValueAt(view.data, pointer, opened.value);
+    }
+  }
+  return view;
+}
+var VALUE_NAMING = /* @__PURE__ */ new Map([
+  ["additionalProperties", "must NOT have additional properties"],
+  ["unevaluatedProperties", "must NOT have unevaluated properties"],
+  ["propertyNames", "property name must be valid"]
+]);
+function at(pointer, pos, locate) {
+  const located = locate?.(pointer);
+  if (located) {
+    return {
+      file: located.file,
+      ...located.line != null ? { line: located.line } : {},
+      ...located.col != null ? { col: located.col } : {}
+    };
+  }
+  const line = pos.lineFor(pointer);
+  const col = pos.colFor?.(pointer);
+  return { ...line != null ? { line } : {}, ...col != null ? { col } : {} };
+}
+function settleFindings(errors, view, pos, locate) {
+  const hidden = [...view.unreadable, ...view.unverified];
+  const out = [];
+  for (const e of errors) {
+    if (hidden.some((p) => isAtOrUnder(e.instancePath, p))) continue;
+    const inside = view.decrypted.find((p) => isAtOrUnder(e.instancePath, p));
+    const generic = VALUE_NAMING.get(e.keyword);
+    if (inside === void 0 || e.instancePath === inside && generic === void 0) {
+      out.push(e);
+      continue;
+    }
+    const { subject, file: _file, line: _line, col: _col, ...rest } = e;
+    void _file;
+    void _line;
+    void _col;
+    out.push({
+      ...rest,
+      instancePath: inside,
+      message: generic ?? e.message,
+      ...generic === void 0 && subject !== void 0 ? { subject } : {},
+      ...at(inside, pos, locate)
+    });
+  }
+  return out;
+}
+function encryptionFindings(view, pos, locate) {
+  return [
+    ...view.plain.map((p) => ({ p, schema: ENCRYPTED_PLAIN_SCHEMA, message: plainMessage(p) })),
+    ...view.unreadable.map((p) => ({
+      p,
+      schema: ENCRYPTED_UNREADABLE_SCHEMA,
+      message: unreadableMessage(p)
+    }))
+  ].map(({ p, schema, message }) => ({
+    schema,
+    keyword: ENCRYPTED_KEYWORD,
+    instancePath: p,
+    message,
+    ...at(p, pos, locate)
+  }));
+}
+function redactForModel(data, marked) {
+  let out = data;
+  for (const pointer of marked) {
+    if (valueAt(out, pointer) !== void 0) {
+      out = withValueAt(out, pointer, ENCRYPTED_PLACEHOLDER);
+    }
+  }
+  const scrub = (node) => {
+    if (isEncryptedValue(node)) return ENCRYPTED_PLACEHOLDER;
+    if (Array.isArray(node)) return node.map(scrub);
+    if (isRecord(node)) {
+      return Object.fromEntries(Object.entries(node).map(([k, v]) => [k, scrub(v)]));
+    }
+    return node;
+  };
+  return scrub(out);
+}
+function redactedDerived(f) {
+  return {
+    ...f,
+    ...f.asserted !== void 0 ? { asserted: ENCRYPTED_PLACEHOLDER } : {},
+    ...f.derived !== null ? { derived: ENCRYPTED_PLACEHOLDER } : {}
+  };
+}
+
+// src/meta/core/external-metadata.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { isAbsolute, relative as relative2, resolve as resolve2, sep } from "node:path";
+import {
+  LineCounter,
+  isMap as isMap2,
+  isNode,
+  isScalar,
+  isSeq,
+  parseDocument as parseDocument2
+} from "yaml";
+
+// src/shared/manifest-cas.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { posix } 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" ? posix.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 text = current;
+  for (const op of held.ops) text = codec.apply(text, op);
+  return text;
+}
+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";
+}
+async function readManifestOrEmpty(absPath, perPage) {
+  try {
+    return await readFile2(absPath, "utf8");
+  } catch (e) {
+    if (perPage && isMissing(e)) return "";
+    throw e;
+  }
+}
+
+// src/meta/core/external-metadata.ts
+var EXTERNAL_OWNED_SCHEMA = "external:owned";
+var EXTERNAL_DUPLICATE_SCHEMA = "external:duplicate";
+var EXTERNAL_KEYWORD = "external";
+var PATH_JOIN = "path";
+var parsedManifests = new ManifestCache();
+var impliedOwners = /* @__PURE__ */ new WeakMap();
+var perPageRules = /* @__PURE__ */ new WeakMap();
+var strayEntries = /* @__PURE__ */ new WeakSet();
+var posix2 = (p) => p.split(sep).join("/");
+function reportedPath(abs, base) {
+  const rel = relative2(base, abs);
+  return rel === "" ? "." : posix2(rel);
+}
+function reported(of, file) {
+  return of.file === file ? of : { ...of, file };
+}
+function externalMetadataJoin(manifest) {
+  return manifest.join ?? PATH_JOIN;
+}
+async function loadExternalMetadata(collections, opts) {
+  const configured = collections.flatMap(
+    (c) => c.externalMetadata.map((m) => ({ collection: c.name, manifest: m }))
+  );
+  if (configured.length === 0) return null;
+  const owners = /* @__PURE__ */ new Map();
+  const byPath = /* @__PURE__ */ new Map();
+  const byField = /* @__PURE__ */ new Map();
+  const entries = [];
+  const resolvedBy = /* @__PURE__ */ new Map();
+  const rules = [];
+  const implied = [];
+  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)) {
+      const owner = await loadPerPage(declared, manifest, opts, resolvedBy, { owners, byPath, byField, entries });
+      if (owner !== void 0) implied.push(owner);
+      rules.push({ collection: declared, manifest, configDir: opts.configDir });
+      continue;
+    }
+    const join4 = externalMetadataJoin(manifest);
+    let parsed;
+    let file;
+    if (classifyRef(manifest.file).kind === "url") {
+      file = manifest.file;
+      const text = await fetchExternalMetadata(manifest.file, {
+        ...manifest.tokenEnv !== void 0 ? { tokenEnv: manifest.tokenEnv } : {},
+        ...opts.offline !== void 0 ? { offline: opts.offline } : {},
+        ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
+        ...opts.env !== void 0 ? { env: opts.env } : {}
+      });
+      parsed = parseManifest(manifest, collection, text, file, opts.configDir, join4, ownership(declared, manifest));
+    } else {
+      const abs = isAbsolute(manifest.file) ? manifest.file : resolve2(opts.configDir, manifest.file);
+      const label = reportedPath(abs, opts.base);
+      file = label;
+      parsed = await parsedManifests.parse(
+        abs,
+        // `label` is deliberately not part of this. It is the manifest as this
+        // run reports it, which is a function of the run's base rather than of
+        // the bytes, so two runs over one corpus from two directories parse
+        // identically and differ only in a string each value carries. Keying
+        // on it would miss the cache for exactly the runs that share a
+        // process, which is what a test suite is. The copy-in below writes
+        // this run's spelling onto every value and entry instead.
+        JSON.stringify([
+          collection,
+          join4,
+          opts.configDir,
+          variantOf(declared, manifest)
+        ]),
+        async () => parseManifest(
+          manifest,
+          collection,
+          await readManifest(abs, label),
+          label,
+          opts.configDir,
+          join4,
+          ownership(declared, manifest)
+        )
+      );
+    }
+    if (manifest.keys === void 0 && declared !== void 0) {
+      implied.push({ collection: declared, manifest, file, files: /* @__PURE__ */ new Set([file]) });
+    }
+    for (const key of manifest.keys ?? []) {
+      const list2 = owners.get(key);
+      if (list2) list2.push({ collection, file });
+      else owners.set(key, [{ collection, file }]);
+    }
+    let target;
+    if (join4 === PATH_JOIN) {
+      target = byPath;
+    } else {
+      const existing = byField.get(join4);
+      if (existing) target = existing;
+      else {
+        target = /* @__PURE__ */ new Map();
+        byField.set(join4, target);
+      }
+    }
+    for (const [indexKey, values] of parsed.values) {
+      const into = target.get(indexKey) ?? /* @__PURE__ */ new Map();
+      for (const [key, value] of values) into.set(key, reported(value, file));
+      target.set(indexKey, into);
+    }
+    for (const entry of parsed.entries) entries.push(reported(entry, file));
+  }
+  const index = { owners, byPath, byField, entries };
+  if (rules.length > 0) perPageRules.set(index, rules);
+  if (implied.length > 0) impliedOwners.set(index, implied);
+  return index;
+}
+function ownership(declared, manifest) {
+  if (manifest.keys !== void 0) {
+    const owned = new Set(manifest.keys);
+    return {
+      may: (key) => owned.has(key),
+      why: () => `which this manifest does not own. Add it to the manifest's "keys", or remove it from the entry.`
+    };
+  }
+  const never = neverOwned(declared ?? { externalMetadata: [manifest] }, manifest);
+  return {
+    may: (key) => !never.has(key),
+    why: (key) => key === manifest.join ? "the field this manifest joins on, which the page carries. Remove it from the entry." : `which another manifest of this collection names in its "keys". Move it to that manifest, or remove it from the entry.`
+  };
+}
+function variantOf(declared, manifest) {
+  if (manifest.keys !== void 0) return [...manifest.keys].sort();
+  return { never: [...neverOwned(declared ?? { externalMetadata: [manifest] }, manifest)].sort() };
+}
+async function loadPerPage(declared, manifest, opts, resolvedBy, into) {
+  const collection = declared.name;
+  const join4 = externalMetadataJoin(manifest);
+  const implied = manifest.keys === void 0 ? { collection: declared, manifest, file: manifest.file, files: /* @__PURE__ */ new Set() } : void 0;
+  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(join4, 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 = posix2(relative2(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 parsed = await parsedManifests.parse(
+      resolved.abs,
+      JSON.stringify([collection, join4, opts.configDir, variantOf(declared, manifest)]),
+      async () => parseManifest(
+        manifest,
+        collection,
+        await readPageManifest(resolved.abs, label),
+        label,
+        opts.configDir,
+        join4,
+        ownership(declared, manifest)
+      )
+    );
+    implied?.files.add(label);
+    const pageLabel = reportedPath(pageAbs, opts.base);
+    for (const entry of parsed.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 parsed.values) {
+      const key = join4 === PATH_JOIN ? 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 parsed.entries) {
+      into.entries.push({
+        ...reported(entry, label),
+        ...entry.abs === void 0 ? {} : { abs: pageAbs }
+      });
+    }
+  }
+  return implied;
+}
+function indexFor(join4, into) {
+  if (join4 === PATH_JOIN) return into.byPath;
+  const existing = into.byField.get(join4);
+  if (existing) return existing;
+  const created = /* @__PURE__ */ new Map();
+  into.byField.set(join4, 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 readFile3(abs, "utf8");
+  } catch (err) {
+    if (isMissing(err)) return "";
+    throw unreadable(file, err);
+  }
+}
+async function readManifest(abs, file) {
+  try {
+    return await readFile3(abs, "utf8");
+  } catch (err) {
+    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, text, file, configDir, join4, owns) {
+  const target = /* @__PURE__ */ new Map();
+  const entries = [];
+  const lc = new LineCounter();
+  const doc = parseDocument2(text, { lineCounter: lc, uniqueKeys: false });
+  const problem = doc.errors[0];
+  if (problem) {
+    throw new DocmetaError(
+      `Manifest ${file} is not valid YAML: ${problem.message}`
+    );
+  }
+  const root = doc.contents;
+  if (root === null || isScalar(root) && root.value === null)
+    return { values: target, entries };
+  if (!isMap2(root)) {
+    throw new DocmetaError(
+      `Manifest ${file}: the manifest must be a mapping from document ${join4 === PATH_JOIN ? "path" : `"${join4}"`} to owned keys.`
+    );
+  }
+  const lineAt = (node) => {
+    const range = isNode(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 = isScalar(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)) {
+      const first = seen.get(spelled);
+      throw new DocmetaError(
+        `Manifest ${where}: "${spelled}" is named twice (first at line ${first ?? "?"}). Merge the two entries into one.`
+      );
+    }
+    seen.set(spelled, entryLine);
+    if (!isMap2(pair.value)) {
+      throw new DocmetaError(
+        `Manifest ${where}: "${spelled}" must be a mapping of owned keys to values.`
+      );
+    }
+    const indexKey = join4 === PATH_JOIN ? resolve2(configDir, spelled) : spelled;
+    const values = target.get(indexKey) ?? /* @__PURE__ */ new Map();
+    for (const kv of pair.value.items) {
+      const key = isScalar(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.`
+        );
+      }
+      if (!owns.may(key)) {
+        throw new DocmetaError(`Manifest ${where}: "${spelled}" sets "${key}", ${owns.why(key)}`);
+      }
+      const value = kv.value === null ? null : kv.value.toJS(doc, { maxAliasCount: 100 });
+      const line = lineAt(kv.key);
+      const lines = nodeLines(kv.value, lineAt);
+      values.set(key, {
+        value,
+        collection,
+        file,
+        ...line === void 0 ? {} : { line },
+        ...lines.size === 0 ? {} : { lines }
+      });
+    }
+    target.set(indexKey, values);
+    entries.push({
+      collection,
+      join: join4,
+      ...join4 === PATH_JOIN ? { abs: indexKey } : {},
+      spelled,
+      file,
+      ...entryLine === void 0 ? {} : { line: entryLine }
+    });
+  }
+  return { values: target, entries };
+}
+function nodeLines(node, lineAt, prefix = "", out = /* @__PURE__ */ new Map()) {
+  if (isMap2(node)) {
+    for (const kv of node.items) {
+      const seg = isScalar(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);
+      nodeLines(kv.value, lineAt, pointer, out);
+    }
+  } else if (isSeq(node)) {
+    node.items.forEach((item, i) => {
+      const pointer = `${prefix}/${String(i)}`;
+      const line = lineAt(item);
+      if (line !== void 0) out.set(pointer, line);
+      nodeLines(item, lineAt, pointer, out);
+    });
+  }
+  return out;
+}
+function joinValue(raw) {
+  if (typeof raw === "string") return raw;
+  if (typeof raw === "number" || typeof raw === "bigint") return String(raw);
+  if (typeof raw === "boolean") return String(raw);
+  return void 0;
+}
+function mergeExternalMetadata(label, extracted, index, memberOf2, base, options = {}) {
+  return mergeWith(label, extracted, index, memberOf2, base, options.encryptionKey, options.marked ?? UNKNOWN);
+}
+var UNKNOWN = /* @__PURE__ */ new Set();
+var PROBE = /* @__PURE__ */ Symbol("probe");
+function mergeWith(label, extracted, index, memberOf2, base, encryptionKey, marked) {
+  const none = () => void 0;
+  if (!index || memberOf2.length === 0) {
+    return { extracted, collisions: [], joins: [], locate: none };
+  }
+  const mine = (collection) => memberOf2.includes(collection);
+  const probing = marked === PROBE;
+  const implied = (impliedOwners.get(index) ?? []).filter((o) => mine(o.collection.name));
+  const impliedOwns = (o, key) => probing ? !neverOwned(o.collection, o.manifest).has(key) : ownsKey(o.collection, o.manifest, key, marked);
+  const ownersOf = (key) => pageOwners(index, key, memberOf2, probing ? void 0 : marked);
+  const impliedFrom = (sv) => implied.find((o) => o.collection.name === sv.collection && o.files.has(sv.file));
+  const collisions = [];
+  if (!probing) {
+    for (const key of Object.keys(extracted.data)) {
+      for (const owner of ownersOf(key)) {
+        collisions.push({ key, file: owner.file, collection: owner.collection });
+      }
+    }
+  }
+  const sources = [];
+  const entryOf = /* @__PURE__ */ new Map();
+  const joins = [];
+  if (label !== STDIN_LABEL) {
+    const byPath = index.byPath.get(resolve2(base, label));
+    if (byPath) {
+      sources.push(byPath);
+      const abs = resolve2(base, label);
+      entryOf.set(byPath, (sv) => index.entries.find((e) => e.file === sv.file && e.abs === abs));
+    }
+  }
+  for (const [field, byValue] of index.byField) {
+    const raw = extracted.data[field];
+    let value;
+    let pageValue;
+    if (isEncryptedValue(raw)) {
+      const joinsHere = [...byValue.values()].some(
+        (supplied) => [...supplied.values()].some((sv) => mine(sv.collection))
+      );
+      if (!joinsHere) continue;
+      const key = encryptionKey?.();
+      if (key === void 0) {
+        throw new EncryptionRefusal(
+          `externalMetadata join field "${field}" is encrypted on these pages, and no encryption key is available to match them.`
+        );
+      }
+      const opened = decryptValue(raw, key, META_CONTEXT);
+      if (!opened.ok) continue;
+      value = joinValue(opened.value);
+      pageValue = raw;
+    } else {
+      value = joinValue(raw);
+    }
+    if (value === void 0) continue;
+    const hit = byValue.get(value);
+    if (!hit) continue;
+    sources.push(hit);
+    const spelled = value;
+    entryOf.set(
+      hit,
+      (sv) => index.entries.find((e) => e.file === sv.file && e.join === field && e.spelled === spelled)
+    );
+    const first = [...hit.values()].find((sv) => mine(sv.collection));
+    if (first) {
+      joins.push({
+        field,
+        value,
+        ...pageValue === void 0 ? {} : { pageValue },
+        file: first.file,
+        collection: first.collection
+      });
+    }
+  }
+  for (const supplied of probing ? [] : sources) {
+    for (const key of supplied.keys()) {
+      const [a, b] = ownersOf(key);
+      if (a && b) {
+        throw new DocmetaError(
+          `${label}: "${key}" is owned by manifests in two of its collections, ${a.collection} (${a.file}) and ${b.collection} (${b.file}); a key has one manifest per file. Narrow one collection's paths or exclude.`
+        );
+      }
+    }
+  }
+  if (sources.length === 0) {
+    return { extracted, collisions, joins, locate: none };
+  }
+  const data = { ...extracted.data };
+  const merged = /* @__PURE__ */ new Map();
+  for (const supplied of sources) {
+    for (const [key, sv] of supplied) {
+      if (!mine(sv.collection)) continue;
+      const from = impliedFrom(sv);
+      if (from !== void 0 && !impliedOwns(from, key)) {
+        if (probing || marked === UNKNOWN) continue;
+        throw unmarkedRefusal(label, key, sv, entryOf.get(supplied)?.(sv));
+      }
+      if (key in extracted.data) continue;
+      data[key] = sv.value;
+      merged.set(key, sv);
+    }
+  }
+  const locate = (pointer) => {
+    const split = splitTopLevel(pointer);
+    if (split === void 0) return void 0;
+    const sv = merged.get(split.key);
+    if (!sv) return void 0;
+    const line = manifestLine(sv, split.rest);
+    return { file: sv.file, ...line === void 0 ? {} : { line } };
+  };
+  return { extracted: { ...extracted, data }, collisions, joins, locate };
+}
+function unmarkedRefusal(label, key, sv, entry) {
+  const line = entry?.line ?? sv.line;
+  const where = line === void 0 ? sv.file : `${sv.file}:${String(line)}`;
+  const spelled = entry?.spelled ?? label;
+  return new DocmetaError(
+    `Manifest ${where}: "${spelled}" sets "${key}", which this manifest does not own, because the page's schemas do not mark it x-manni-location: external. Mark it external in the page's schemas, or remove it from the entry.`
+  );
+}
+async function mergeWithMarks(label, extracted, index, memberOf2, base, options) {
+  const { encryptionKey, marks } = options;
+  if (marks === void 0 || !hasImpliedOwner(index, memberOf2)) {
+    return mergeWith(label, extracted, index, memberOf2, base, encryptionKey, UNKNOWN);
+  }
+  const probe = mergeWith(label, extracted, index, memberOf2, base, encryptionKey, PROBE).extracted.data;
+  const marked = await marks(label, probe, memberOf2);
+  const merged = mergeWith(label, extracted, index, memberOf2, base, encryptionKey, marked ?? UNKNOWN);
+  return marked === void 0 ? merged : { ...merged, marked };
+}
+function hasImpliedOwner(index, memberOf2) {
+  if (index === null) return false;
+  return (impliedOwners.get(index) ?? []).some((o) => memberOf2.includes(o.collection.name));
+}
+function manifestLine(sv, rest) {
+  if (rest === "" || sv.lines === void 0) return sv.line;
+  return positionForFactory(sv.lines)(rest) ?? sv.line;
+}
+function splitTopLevel(pointer) {
+  if (pointer === "") return void 0;
+  if (!pointer.startsWith("/")) return { key: pointer, rest: "" };
+  const slash = pointer.indexOf("/", 1);
+  const seg = slash < 0 ? pointer.slice(1) : pointer.slice(1, slash);
+  return {
+    key: seg.replace(/~1/g, "/").replace(/~0/g, "~"),
+    rest: slash < 0 ? "" : pointer.slice(slash)
+  };
+}
+function externalMetadataPointer(key) {
+  return `/${escapePointerSegment(key)}`;
+}
+function orphanEntries(index, loaded, base, collections) {
+  if (!index) return [];
+  const have = new Set(loaded.map((l) => resolve2(base, l)));
+  const orphans = index.entries.filter(
+    (e) => inCollections(e, collections) && e.join === PATH_JOIN && 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), read);
+    for (const { abs, entries } of found) {
+      const file = reportedPath(abs, base);
+      for (const entry of entries) {
+        if (loaded.has(entry.pageAbs)) continue;
+        const stray = {
+          collection: collection.name,
+          join: PATH_JOIN,
+          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);
+}
+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)
+  );
+}
+function orphanError(orphans) {
+  const first = orphans[0];
+  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 remove = strayEntries.has(first) ? "the file" : "it";
+  return new DocmetaError(
+    `Manifest ${where} ${what}${more}. Fix the entry, or remove ${remove}.`
+  );
+}
+function pageOwners(index, key, memberOf2, marked) {
+  if (index === null) return [];
+  return [
+    ...(index.owners.get(key) ?? []).filter((o) => memberOf2.includes(o.collection)),
+    ...(impliedOwners.get(index) ?? []).filter((o) => memberOf2.includes(o.collection.name) && ownsKey(o.collection, o.manifest, key, marked)).map((o) => ({ collection: o.collection.name, file: o.file }))
+  ];
+}
+
+// src/meta/core/location.ts
+var LOCATION_KEYWORD = "x-manni-location";
+var LOCATION_EXTERNAL_SCHEMA = "location:external";
+var LOCATION_PAGE_SCHEMA = "location:page";
+var LOCATION_FINDING_KEYWORD = "location";
+function isFieldLocation(value) {
+  return value === "page" || value === "external";
+}
+
+// src/meta/core/graph-output.ts
+var GRAPH_OUTPUT_KEYWORD = "x-manni-graph-output";
+
+// src/meta/core/validator.ts
+import * as AjvDraft07Ns from "ajv";
+import * as Ajv2019Ns from "ajv/dist/2019.js";
+import * as Ajv2020Ns from "ajv/dist/2020.js";
+import * as AjvDraft04Ns from "ajv-draft-04";
+import * as addFormatsNs from "ajv-formats";
+import { createRequire } from "node:module";
+var draft06MetaSchema = createRequire(import.meta.url)(
+  "ajv/dist/refs/json-schema-draft-06.json"
+);
+var AjvDraft07 = AjvDraft07Ns.default;
+var Ajv2019 = Ajv2019Ns.default;
+var Ajv2020 = Ajv2020Ns.default;
+var AjvDraft04 = AjvDraft04Ns.default;
+var addFormats = addFormatsNs.default;
+function dialectOf(schema) {
+  const meta = typeof schema.$schema === "string" ? schema.$schema : "";
+  if (meta.includes("2019-09")) return "2019";
+  if (meta.includes("draft-07") || meta.includes("draft/7") || meta.includes("draft-06") || meta.includes("draft/6")) {
+    return "draft7";
+  }
+  if (meta.includes("draft-04") || meta.includes("draft/4")) return "draft4";
+  return "2020";
+}
+function buildAjv(dialect, coerceTypes = false) {
+  const opts = { allErrors: true, strict: false, coerceTypes };
+  const ajv = dialect === "2019" ? new Ajv2019(opts) : dialect === "draft7" ? new AjvDraft07(opts) : dialect === "draft4" ? new AjvDraft04(opts) : new Ajv2020(opts);
+  addFormats(ajv);
+  if (dialect === "draft7") ajv.addMetaSchema(draft06MetaSchema);
+  registerEncryptKeyword(ajv);
+  registerLocationKeyword(ajv);
+  registerGraphOutputKeyword(ajv);
+  registerBuiltins(ajv, dialect);
+  return ajv;
+}
+var markRecorder;
+function registerEncryptKeyword(ajv) {
+  ajv.addKeyword({
+    keyword: ENCRYPT_KEYWORD,
+    metaSchema: { type: "boolean" },
+    errors: false,
+    validate: (schema, _data, _parent, cxt) => {
+      if (schema === true && markRecorder !== void 0) {
+        markRecorder.add(cxt?.instancePath ?? "");
+      }
+      return true;
+    }
+  });
+}
+function isMarkShapeError(err) {
+  return err instanceof Error && err.message.includes(`"${ENCRYPT_KEYWORD}"`);
+}
+var locationRecorder;
+function topLevelKey(instancePath) {
+  if (!instancePath.startsWith("/") || instancePath.indexOf("/", 1) !== -1) {
+    return void 0;
+  }
+  return instancePath.slice(1).replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function registerLocationKeyword(ajv) {
+  ajv.addKeyword({
+    keyword: LOCATION_KEYWORD,
+    metaSchema: { type: "string", enum: ["page", "external"] },
+    errors: false,
+    validate: (schema, _data, _parent, cxt) => {
+      if (locationRecorder !== void 0 && isFieldLocation(schema)) {
+        const key = topLevelKey(cxt?.instancePath ?? "");
+        if (key !== void 0) {
+          const seen = locationRecorder.get(key);
+          if (seen) seen.add(schema);
+          else locationRecorder.set(key, /* @__PURE__ */ new Set([schema]));
+        }
+      }
+      return true;
+    }
+  });
+}
+function isLocationShapeError(err) {
+  return err instanceof Error && err.message.includes(`"${LOCATION_KEYWORD}"`);
+}
+var graphOutputRecorder;
+function registerGraphOutputKeyword(ajv) {
+  ajv.addKeyword({
+    keyword: GRAPH_OUTPUT_KEYWORD,
+    metaSchema: { type: "boolean" },
+    errors: false,
+    validate: (schema, _data, _parent, cxt) => {
+      if (graphOutputRecorder !== void 0 && typeof schema === "boolean") {
+        const key = topLevelKey(cxt?.instancePath ?? "");
+        if (key !== void 0) {
+          const seen = graphOutputRecorder.get(key);
+          if (seen) seen.add(schema);
+          else graphOutputRecorder.set(key, /* @__PURE__ */ new Set([schema]));
+        }
+      }
+      return true;
+    }
+  });
+}
+function isGraphOutputShapeError(err) {
+  return err instanceof Error && err.message.includes(`"${GRAPH_OUTPUT_KEYWORD}"`);
+}
+function marksSchemaExternal(schema) {
+  const properties = schema["properties"];
+  if (typeof properties !== "object" || properties === null) return false;
+  const own = properties[FILE_SCHEMA_KEY];
+  if (typeof own !== "object" || own === null) return false;
+  return own[LOCATION_KEYWORD] === "external";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function definiteMarkConflict(root, keyword, isMark) {
+  const marks = /* @__PURE__ */ new Map();
+  const localRef = (node, embedded) => {
+    const ref = node["$ref"];
+    if (embedded || typeof ref !== "string" || !ref.startsWith("#")) return void 0;
+    const pointer = ref.slice(1);
+    if (pointer === "") return root;
+    if (!pointer.startsWith("/")) return void 0;
+    let at2 = root;
+    for (const raw of pointer.slice(1).split("/")) {
+      let segment;
+      try {
+        segment = decodeURIComponent(raw).replace(/~1/g, "/").replace(/~0/g, "~");
+      } catch {
+        return void 0;
+      }
+      if (Array.isArray(at2)) at2 = at2[Number(segment)];
+      else if (isRecord2(at2)) at2 = at2[segment];
+      else return void 0;
+    }
+    return at2;
+  };
+  const isEmbedded = (node, embedded) => embedded || node !== root && typeof node["$id"] === "string";
+  const allOf = (node) => Array.isArray(node["allOf"]) ? node["allOf"] : [];
+  const property = (key, node, embedded, visited) => {
+    if (!isRecord2(node) || visited.has(node)) return;
+    visited.add(node);
+    const inner = isEmbedded(node, embedded);
+    const mark = node[keyword];
+    if (isMark(mark)) {
+      const seen = marks.get(key);
+      if (seen) seen.add(mark);
+      else marks.set(key, /* @__PURE__ */ new Set([mark]));
+    }
+    for (const entry of allOf(node)) property(key, entry, inner, visited);
+    property(key, localRef(node, inner), inner, visited);
+  };
+  const object = (node, embedded, visited) => {
+    if (!isRecord2(node) || visited.has(node)) return;
+    visited.add(node);
+    const inner = isEmbedded(node, embedded);
+    const properties = node["properties"];
+    if (isRecord2(properties)) {
+      for (const [key, sub] of Object.entries(properties)) property(key, sub, inner, /* @__PURE__ */ new Set());
+    }
+    for (const entry of allOf(node)) object(entry, inner, visited);
+    object(localRef(node, inner), inner, visited);
+  };
+  object(root, false, /* @__PURE__ */ new Set());
+  for (const [key, seen] of marks) if (seen.size > 1) return key;
+  return void 0;
+}
+function registerBuiltins(ajv, dialect) {
+  for (const { id, url, legacyUrl, schema } of publishedBuiltins()) {
+    ajv.addSchema(schema, url, void 0, false);
+    ajv.addSchema(schema, legacyUrl, void 0, false);
+    if (dialect === "draft4") ajv.addSchema(schema, id, void 0, false);
+  }
+}
+function registerRegistered(ajv, dialect, registered) {
+  for (const { id, schema } of registered?.values() ?? []) {
+    ajv.addSchema(schema, dialect === "draft4" ? id : void 0, void 0, false);
+  }
+}
+function compileWithFormats(schema, registered, options = {}) {
+  const ajv = buildAjv("2020", options.coerce === true ? "array" : false);
+  registerRegistered(ajv, "2020", registered);
+  return ajv.compile(schema);
+}
+var formatRegistry;
+function formatsAjv() {
+  if (!formatRegistry) {
+    formatRegistry = new Ajv2020({ strict: false });
+    addFormats(formatRegistry);
+  }
+  return formatRegistry;
+}
+var stringFormatsMemo;
+function stringFormatNames() {
+  if (!stringFormatsMemo) {
+    const names = /* @__PURE__ */ new Set();
+    const registered = formatsAjv().formats;
+    for (const [name, def] of Object.entries(registered)) {
+      const enforcesStrings = def instanceof RegExp || typeof def === "function" || typeof def === "object" && def !== null && (def.type === void 0 || def.type === "string");
+      if (enforcesStrings) names.add(name);
+    }
+    stringFormatsMemo = names;
+  }
+  return stringFormatsMemo;
+}
+var formatCheckers = /* @__PURE__ */ new Map();
+function validatesFormat(name, value) {
+  let fn = formatCheckers.get(name);
+  if (!fn) {
+    fn = formatsAjv().compile({ type: "string", format: name });
+    formatCheckers.set(name, fn);
+  }
+  return fn(value);
+}
+var Validator = class {
+  /**
+   * How this validator's schemas are loaded: the disk cache location, its TTL,
+   * and `--offline`. Held per instance rather than read from module state, so
+   * two differently-configured validations in one process each get their own
+   * settings.
+   *
+   * That is not full isolation, and the difference matters to a library
+   * caller: `schema-registry` keeps a process-wide memo of fetched schemas, so
+   * one validator's successful fetch is visible to another. `offline` is
+   * excluded from that sharing on purpose — an offline validator will not be
+   * served something this process pulled over the network — but the memo is
+   * still shared, so a URL fetched once is not re-fetched per instance.
+   */
+  constructor(schemaOptions = {}) {
+    this.schemaOptions = schemaOptions;
+  }
+  schemaOptions;
+  ajvByDialect = /* @__PURE__ */ new Map();
+  /**
+   * Keyed on the in-flight *promise*, not the resolved validator. Caching the
+   * result made this a check-then-act race: `fill` walks files through a worker
+   * pool, so every worker missed the cache while the first `loadSchema` was
+   * still pending and they all then compiled the same schema into the one
+   * shared per-dialect Ajv. Ajv registers a schema's `$id` on the first compile
+   * and rejects the second with "schema with key or id ... already exists",
+   * which took down any multi-file run against an $id-bearing schema. Storing
+   * the promise before the first await lets the losers await the one compile.
+   */
+  cache = /* @__PURE__ */ new Map();
+  ajvFor(dialect) {
+    let ajv = this.ajvByDialect.get(dialect);
+    if (!ajv) {
+      ajv = buildAjv(dialect);
+      registerRegistered(ajv, dialect, this.schemaOptions.registered);
+      this.ajvByDialect.set(dialect, ajv);
+    }
+    return ajv;
+  }
+  /**
+   * Synchronous by design: the `cache.set` has to happen in the same tick as
+   * the miss, or a second caller can slip in before the entry exists.
+   */
+  compile(ref) {
+    const cached = this.cache.get(ref);
+    if (cached) return cached;
+    const pending = this.compileUncached(ref);
+    this.cache.set(ref, pending);
+    pending.catch(() => {
+      if (this.cache.get(ref) === pending) this.cache.delete(ref);
+    });
+    return pending;
+  }
+  async compileUncached(ref) {
+    const schema = await loadSchema(ref, this.schemaOptions);
+    if (marksSchemaExternal(schema)) {
+      throw new DocmetaError(
+        `${ref}: "${FILE_SCHEMA_KEY}" cannot be stored in external metadata.`
+      );
+    }
+    const contradicted = definiteMarkConflict(schema, LOCATION_KEYWORD, isFieldLocation);
+    if (contradicted !== void 0) {
+      throw new DocmetaError(
+        `${ref}: "${LOCATION_KEYWORD}" says both "page" and "external" for "${contradicted}".`
+      );
+    }
+    const graphContradicted = definiteMarkConflict(
+      schema,
+      GRAPH_OUTPUT_KEYWORD,
+      (value) => typeof value === "boolean"
+    );
+    if (graphContradicted !== void 0) {
+      throw new DocmetaError(
+        `${ref}: "${GRAPH_OUTPUT_KEYWORD}" says both true and false for "${graphContradicted}".`
+      );
+    }
+    try {
+      const ajv = this.ajvFor(dialectOf(schema));
+      const id = typeof schema["$id"] === "string" ? schema["$id"] : void 0;
+      const registered = id != null ? ajv.getSchema(id) : void 0;
+      if (registered) {
+        if (registered.schema === schema) return registered;
+        const { $id: _taken, ...anonymous } = schema;
+        return ajv.compile(anonymous);
+      }
+      return ajv.compile(schema);
+    } catch (err) {
+      if (isMarkShapeError(err)) {
+        throw new DocmetaError(
+          `${ref}: "${ENCRYPT_KEYWORD}" must be true or false.`
+        );
+      }
+      if (isLocationShapeError(err)) {
+        throw new DocmetaError(
+          `${ref}: "${LOCATION_KEYWORD}" must be "page" or "external".`
+        );
+      }
+      if (isGraphOutputShapeError(err)) {
+        throw new DocmetaError(
+          `${ref}: "${GRAPH_OUTPUT_KEYWORD}" must be true or false.`
+        );
+      }
+      throw new DocmetaError(
+        `Schema "${ref}" failed to compile: ${errorMessage(err)}`
+      );
+    }
+  }
+  /**
+   * The instance pointers of `data` that carry `x-manni-encrypt: true` under
+   * any schema in `refs`, in the order the validator evaluated them.
+   *
+   * A first pass with the recording keyword, so a mark counts exactly where
+   * validation would evaluate it. Only present values are marked: Ajv applies
+   * a property's subschema to a property that exists. A branch Ajv does not
+   * take (`then` behind a failing `if`, an `anyOf` branch after a passing
+   * one) contributes nothing; a branch it takes contributes its marks
+   * whether or not the branch passes, because a ciphertext routinely fails
+   * the rest of its own subschema until it is decrypted.
+   */
+  async markedPointers(data, refs) {
+    const { [FILE_SCHEMA_KEY]: _omit, ...subject } = data;
+    void _omit;
+    const marks = /* @__PURE__ */ new Set();
+    for (const ref of refs) {
+      const fn = await this.compile(ref);
+      markRecorder = marks;
+      try {
+        fn(subject);
+      } finally {
+        markRecorder = void 0;
+      }
+    }
+    return marks;
+  }
+  /**
+   * The location each top-level key of `data` prefers under `refs`: `page` or
+   * `external`, and the ref whose `x-manni-location` mark decided it. A key no
+   * schema marks has no entry.
+   *
+   * A first pass with the recording keyword, as `markedPointers` runs, so a
+   * mark counts exactly where validation would evaluate it, and a nested mark
+   * is ignored. Only present values are marked: Ajv applies a property's
+   * subschema to a property that exists. A caller asking where a key it is
+   * about to write belongs passes `data` that already holds the candidate
+   * value. `$schema` is stripped first, as validation does.
+   *
+   * Refs are evaluated in order and a later ref's mark wins. A ref that says
+   * both values for one key unconditionally is refused when it compiles; one
+   * whose evaluated branches say both gives that key no preference.
+   */
+  async locationPreferences(data, refs) {
+    const { [FILE_SCHEMA_KEY]: _omit, ...subject } = data;
+    void _omit;
+    const preferences = /* @__PURE__ */ new Map();
+    for (const ref of refs) {
+      const fn = await this.compile(ref);
+      const seen = /* @__PURE__ */ new Map();
+      locationRecorder = seen;
+      try {
+        fn(subject);
+      } finally {
+        locationRecorder = void 0;
+      }
+      for (const [key, locations] of seen) {
+        const [location, ...others] = [...locations];
+        if (location === void 0 || others.length > 0) continue;
+        preferences.set(key, { location, schema: ref });
+      }
+    }
+    return preferences;
+  }
+  /**
+   * The top-level property names the schemas in `refs` claim: the keys of
+   * each schema's own `properties`, each once. What a page's schema set
+   * claims decides which merge-safe fields a `derive:` block with no `fields`
+   * manages on it (proposal 0069). A property reached only through `allOf`,
+   * `$ref` or a conditional is not counted, so a schema that should manage a
+   * field names it in its root `properties`. A schema that fails to load or
+   * compile throws, as it would for `validate`.
+   */
+  async claimedProperties(refs) {
+    const claimed = /* @__PURE__ */ new Set();
+    for (const ref of refs) {
+      const schema = (await this.compile(ref)).schema;
+      if (typeof schema !== "object" || schema === null) continue;
+      const properties = schema["properties"];
+      if (typeof properties !== "object" || properties === null || Array.isArray(properties)) continue;
+      for (const key of Object.keys(properties)) claimed.add(key);
+    }
+    return claimed;
+  }
+  /**
+   * Whether each top-level key of `data` belongs in a published graph under
+   * `refs`, as its `x-manni-graph-output` mark says. A key no schema marks has no
+   * entry, which the caller reads as `true`: absent means harvested.
+   *
+   * A first pass with the recording keyword, as `locationPreferences` runs, so
+   * a mark counts exactly where validation would evaluate it, and a mark nested
+   * inside `graph` is ignored. Only present values are marked: Ajv applies a
+   * property's subschema to a property that exists. `$schema` is stripped
+   * first, as validation does.
+   *
+   * Refs are evaluated in order and a later ref's mark wins, so a house schema
+   * listed after a vocabulary refines it. A schema that says both on paths
+   * every document takes is refused when it compiles. A ref whose conditional
+   * branches say both `true` and `false` gives that key no preference: with
+   * `allErrors`, Ajv evaluates failing branches too, so neither value is that
+   * ref's answer and an earlier ref's stands.
+   */
+  async graphOutputPreferences(data, refs) {
+    const { [FILE_SCHEMA_KEY]: _omit, ...subject } = data;
+    void _omit;
+    const preferences = /* @__PURE__ */ new Map();
+    for (const ref of refs) {
+      const fn = await this.compile(ref);
+      const seen = /* @__PURE__ */ new Map();
+      graphOutputRecorder = seen;
+      try {
+        fn(subject);
+      } finally {
+        graphOutputRecorder = void 0;
+      }
+      for (const [key, values] of seen) {
+        const [value, ...others] = [...values];
+        if (value === void 0 || others.length > 0) continue;
+        preferences.set(key, value);
+      }
+    }
+    return preferences;
+  }
+  /**
+   * Validate `data` against every schema in `refs`. Returns all violations,
+   * each tagged with the schema that produced it and a source line via
+   * `lineFor`.
+   *
+   * `colFor` is optional and additive: this signature is public, so a fourth
+   * *required* parameter — or a widened third one — would be a consumer break.
+   * Callers with an extractor that supplies no column pass nothing and get the
+   * previous behavior exactly.
+   */
+  async validate(data, refs, lineFor, colFor, locate) {
+    const { [FILE_SCHEMA_KEY]: _omit, ...subject } = data;
+    void _omit;
+    const errors = [];
+    for (const ref of refs) {
+      const fn = await this.compile(ref);
+      const ok = fn(subject);
+      if (ok) continue;
+      for (const e of fn.errors ?? []) {
+        errors.push(toFieldError(ref, e, lineFor, colFor, locate));
+      }
+    }
+    return errors;
+  }
+};
+function subjectOf(e) {
+  switch (e.keyword) {
+    case "required":
+      return e.params.missingProperty;
+    case "additionalProperties":
+      return e.params.additionalProperty;
+    case "format":
+      return e.params.format;
+    case "type":
+      return e.params.type;
+    default:
+      return void 0;
+  }
+}
+function toFieldError(schema, e, lineFor, colFor, locate) {
+  const defined = e;
+  const instancePath = e.instancePath;
+  const subject = subjectOf(defined);
+  let message = e.message ?? "is invalid";
+  let wantsColumn = true;
+  if (defined.keyword === "required") {
+    message = `must have required property '${defined.params.missingProperty}'`;
+    wantsColumn = false;
+  } else if (defined.keyword === "additionalProperties") {
+    message = `must NOT have additional property '${defined.params.additionalProperty}'`;
+    wantsColumn = false;
+  }
+  const located = defined.keyword === "additionalProperties" ? locate?.(
+    `${instancePath}/${escapePointerSegment(defined.params.additionalProperty)}`
+  ) ?? locate?.(instancePath) : locate?.(instancePath);
+  if (located) {
+    return {
+      schema,
+      instancePath,
+      message,
+      keyword: e.keyword,
+      ...subject != null ? { subject } : {},
+      file: located.file,
+      ...located.line != null ? { line: located.line } : {},
+      ...wantsColumn && located.col != null ? { col: located.col } : {}
+    };
+  }
+  const line = lineFor(instancePath);
+  const col = wantsColumn ? colFor?.(instancePath) : void 0;
+  return {
+    schema,
+    instancePath,
+    message,
+    keyword: e.keyword,
+    ...subject != null ? { subject } : {},
+    ...line != null ? { line } : {},
+    ...col != null ? { col } : {}
+  };
+}
+
+// src/meta/core/page-marks.ts
+function pageMarks(opts) {
+  const validator = lazyValidator(opts);
+  return async (label, probe, memberOf2) => {
+    const refs = pageRefs(opts, label, probe, memberOf2);
+    if (refs === void 0) return void 0;
+    try {
+      const preferences = await validator().locationPreferences({ ...probe }, refs);
+      const marked = /* @__PURE__ */ new Set();
+      for (const [key, p] of preferences) if (p.location === "external") marked.add(key);
+      return marked;
+    } catch (err) {
+      if (err instanceof DocmetaError) return void 0;
+      throw err;
+    }
+  };
+}
+function pageClaims(opts) {
+  const validator = lazyValidator(opts);
+  return async (label, probe, memberOf2) => {
+    const refs = pageRefs(opts, label, probe, memberOf2);
+    if (refs === void 0) return void 0;
+    try {
+      return await validator().claimedProperties(refs);
+    } catch (err) {
+      if (err instanceof DocmetaError) return void 0;
+      throw err;
+    }
+  };
+}
+function lazyValidator(opts) {
+  let built;
+  return () => opts.validator instanceof Validator ? opts.validator : built ??= opts.validator();
+}
+function pageSchemaSet(opts, label, probe, memberOf2) {
+  return resolveSchemaSetWithSource({
+    filePath: label,
+    fileSchema: probe[FILE_SCHEMA_KEY],
+    ...opts.cliSchemas !== void 0 ? { cliSchemas: [...opts.cliSchemas] } : {},
+    config: opts.config,
+    memberOf: opts.memberOf?.(label) ?? memberOf2,
+    fileBase: opts.cwd,
+    trustRoot: opts.trustRoot
+  }).schemas;
+}
+function pageRefs(opts, label, probe, memberOf2) {
+  try {
+    return pageSchemaSet(opts, label, probe, memberOf2);
+  } catch (err) {
+    if (err instanceof DocmetaError) return void 0;
+    throw err;
+  }
+}
+function marksValidator(opts) {
+  return () => new Validator(
+    schemaLoadOptions({
+      root: opts.configDir ?? opts.cwd,
+      fileBase: opts.cwd,
+      ttlHours: opts.config?.schemaCache?.ttlHours,
+      offline: opts.offline ?? opts.config?.offline,
+      pins: collectSchemaPins(opts.config),
+      registered: opts.config?.registered
+    })
+  );
+}
+async function configMarks(configPath, cwd) {
+  const loaded = await loadConfig(configPath, cwd);
+  if (loaded === null) return void 0;
+  const config = rebaseConfigSchemaRefs(loaded.config, loaded.dir, cwd);
+  return pageMarks({
+    validator: marksValidator({ config, cwd, configDir: loaded.dir }),
+    config,
+    cwd,
+    trustRoot: schemaTrustRoot(cwd, loaded.dir)
+  });
+}
+async function metaSection(configPath, cwd) {
+  const loaded = await loadConfig(configPath, cwd);
+  if (loaded === null) return null;
+  return rebaseConfigSchemaRefs(loaded.config, loaded.dir, cwd);
+}
+function familyMarks(opts) {
+  let built;
+  const defaults = () => pageMarks({
+    validator: marksValidator({ config: null, cwd: opts.cwd, configDir: opts.configDir }),
+    config: null,
+    cwd: opts.cwd,
+    trustRoot: schemaTrustRoot(opts.cwd, opts.configDir)
+  });
+  return () => built ??= (async () => {
+    if (opts.configPath === void 0) return defaults();
+    try {
+      return await configMarks(opts.configPath, opts.cwd) ?? defaults();
+    } catch (err) {
+      if (err instanceof DocmetaError) return defaults();
+      throw err;
+    }
+  })();
+}
+
+// src/meta/core/projection.ts
+var SYSTEM_COLUMNS = ["_path", "_format", "_present", "_data"];
+var RESERVED = new Set(SYSTEM_COLUMNS);
+function quoteIdent(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function bindValue(value) {
+  if (value === void 0 || value === null) return null;
+  switch (typeof value) {
+    case "boolean":
+      return value ? 1 : 0;
+    case "number":
+      return Number.isFinite(value) ? value : null;
+    case "bigint":
+    case "string":
+      return value;
+    default:
+      return JSON.stringify(value);
+  }
+}
+function corpusDataColumns(entries, extraKeys = []) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const { extracted } of entries) {
+    for (const key of Object.keys(extracted.data)) {
+      if (key !== "" && !RESERVED.has(key)) keys.add(key);
+    }
+  }
+  for (const key of extraKeys) {
+    if (key !== "" && !RESERVED.has(key)) keys.add(key);
+  }
+  return [...keys].sort();
+}
+function createDocsTable(db, entries, dataColumns) {
+  db.exec(
+    `CREATE TABLE docs ("_path" TEXT PRIMARY KEY, "_format" TEXT, "_present" INTEGER, "_data" TEXT${dataColumns.map((c) => `, ${quoteIdent(c)}`).join("")})`
+  );
+  const insert = db.prepare(
+    `INSERT INTO docs VALUES (${["?", "?", "?", "?", ...dataColumns.map(() => "?")].join(", ")})`
+  );
+  db.exec("BEGIN");
+  let committed = false;
+  try {
+    for (const { label, extracted } of entries) {
+      insert.run(
+        label,
+        extracted.format,
+        extracted.present ? 1 : 0,
+        JSON.stringify(extracted.data),
+        ...dataColumns.map((c) => bindValue(extracted.data[c]))
+      );
+    }
+    db.exec("COMMIT");
+    committed = true;
+  } finally {
+    if (!committed) db.exec("ROLLBACK");
+  }
+}
+function registerLineFor(db, entries) {
+  const byLabel = new Map(entries.map((e) => [e.label, e.extracted]));
+  db.function("lineFor", { deterministic: true }, (path, key) => {
+    if (typeof path !== "string" || typeof key !== "string") return null;
+    return byLabel.get(path)?.lineFor(key) ?? null;
+  });
+}
+function assertSingleStatement(sql) {
+  const cut = topLevelSemicolon(sql);
+  if (cut === -1) return;
+  if (!isTrivia(sql.slice(cut + 1))) {
+    throw new DocmetaError(
+      "Run a single SQL statement per query; text after the first `;` would be silently ignored."
+    );
+  }
+}
+function startsStringOrIdent(sql, i) {
+  const ch = sql[i];
+  return ch === "'" || ch === '"' || ch === "`" || ch === "[";
+}
+function startsComment(sql, i) {
+  const ch = sql[i];
+  return ch === "-" && sql[i + 1] === "-" || ch === "/" && sql[i + 1] === "*";
+}
+function skipStringOrIdent(sql, i) {
+  const quote = sql[i];
+  if (quote === "[") {
+    let j2 = i + 1;
+    while (j2 < sql.length && sql[j2] !== "]") j2++;
+    return j2 + 1;
+  }
+  let j = i + 1;
+  while (j < sql.length) {
+    if (sql[j] === quote) {
+      if (sql[j + 1] === quote) {
+        j += 2;
+        continue;
+      }
+      return j + 1;
+    }
+    j++;
+  }
+  return j;
+}
+function skipComment(sql, i) {
+  if (sql[i] === "-") {
+    let j = i + 2;
+    while (j < sql.length && sql[j] !== "\n") j++;
+    return j < sql.length ? j + 1 : j;
+  }
+  const end = sql.indexOf("*/", i + 2);
+  return end === -1 ? sql.length : end + 2;
+}
+function topLevelSemicolon(sql) {
+  let i = 0;
+  while (i < sql.length) {
+    if (startsStringOrIdent(sql, i)) {
+      i = skipStringOrIdent(sql, i);
+    } else if (startsComment(sql, i)) {
+      i = skipComment(sql, i);
+    } else if (sql[i] === ";") {
+      return i;
+    } else {
+      i++;
+    }
+  }
+  return -1;
+}
+var PARAM_NAME_HEAD = /^[A-Za-z_][A-Za-z0-9_]*/;
+function isParamName(name) {
+  return PARAM_NAME_HEAD.exec(name)?.[0] === name;
+}
+function collectNamedParameters(sql) {
+  const tokens = [];
+  const seen = /* @__PURE__ */ new Set();
+  const prefixOf = /* @__PURE__ */ new Map();
+  let i = 0;
+  while (i < sql.length) {
+    const ch = sql[i];
+    if (startsStringOrIdent(sql, i)) {
+      i = skipStringOrIdent(sql, i);
+    } else if (startsComment(sql, i)) {
+      i = skipComment(sql, i);
+    } else if (ch === "$" || ch === ":" || ch === "@") {
+      if (ch === ":" && sql[i + 1] === ":") {
+        i += 2;
+        continue;
+      }
+      const m = PARAM_NAME_HEAD.exec(sql.slice(i + 1));
+      if (!m) {
+        i++;
+        continue;
+      }
+      const token = ch + m[0];
+      const priorPrefix = prefixOf.get(m[0]);
+      if (priorPrefix !== void 0 && priorPrefix !== ch) {
+        throw new DocmetaError(
+          `The statement references both ${priorPrefix}${m[0]} and ${token} \u2014 one name under two prefixes, which the engine rejects as conflicting. Use one spelling throughout.`
+        );
+      }
+      prefixOf.set(m[0], ch);
+      if (!seen.has(token)) {
+        seen.add(token);
+        tokens.push(token);
+      }
+      i += 1 + m[0].length;
+    } else {
+      i++;
+    }
+  }
+  return tokens;
+}
+function stripLeadingTrivia(sql) {
+  let i = 0;
+  for (; ; ) {
+    while (i < sql.length && /\s/.test(sql[i] ?? "")) i++;
+    if (startsComment(sql, i)) {
+      i = skipComment(sql, i);
+      continue;
+    }
+    return sql.slice(i);
+  }
+}
+function isTrivia(text) {
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === void 0 || /\s/.test(ch) || ch === ";") {
+      i++;
+      continue;
+    }
+    if (startsComment(text, i)) {
+      i = skipComment(text, i);
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+var sqliteModule;
+function loadSqlite() {
+  sqliteModule ??= (async () => {
+    const original = process.emitWarning.bind(process);
+    const filtered = (warning, ...rest) => {
+      const text = typeof warning === "string" ? warning : warning.message;
+      if (text.includes("SQLite is an experimental feature")) return;
+      Reflect.apply(original, process, [warning, ...rest]);
+    };
+    process.emitWarning = filtered;
+    try {
+      return await import("node:sqlite");
+    } finally {
+      process.emitWarning = original;
+    }
+  })();
+  return sqliteModule;
+}
+
+// src/meta/core/collections.ts
+import { isAbsolute as isAbsolute2, relative as relative3, resolve as resolvePath, sep as sep2 } from "node:path";
+function memberOf(collections, configDir, base, label) {
+  if (collections.length === 0) return [];
+  if (label === STDIN_LABEL) return [];
+  const rel = relative3(configDir, resolvePath(base, label)).split(sep2).join("/");
+  if (isAbsolute2(rel)) return [];
+  return collections.filter((c) => isMember(c, rel)).map((c) => c.name);
+}
+function retainMembers(files, membersFor) {
+  return files.filter((label) => membersFor(label).length > 0);
+}
+function collectionNames(collections) {
+  return (collections ?? []).map((c) => c.name);
+}
+function collectCollections(entries, params) {
+  const declared = params.collections ?? [];
+  if (declared.length === 0) return [];
+  const base = params.base ?? ".";
+  const configDir = params.configDir ?? base;
+  const members = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const name of memberOf(declared, configDir, base, entry.label)) {
+      const list2 = members.get(name);
+      if (list2) list2.push(entry.label);
+      else members.set(name, [entry.label]);
+    }
+  }
+  return declared.map((c) => ({ name: c.name, members: members.get(c.name) ?? [] }));
+}
+function quoteSqlString(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function createCollectionViews(db, collections) {
+  for (const c of collections) {
+    const where = c.members.length === 0 ? "0" : `_path IN (${c.members.map(quoteSqlString).join(", ")})`;
+    db.exec(
+      `CREATE VIEW ${quoteIdent(c.name)} AS SELECT * FROM docs WHERE ${where}`
+    );
+  }
+}
+
+// src/meta/core/relocation.ts
+import { access, readFile as readFile4, stat as stat2, unlink } from "node:fs/promises";
+import { basename as basename3, extname, isAbsolute as isAbsolute3, join as join3, relative as relative4, resolve as resolve3, sep as sep3 } from "node:path";
+import picomatch from "picomatch";
+import {
+  LineCounter as LineCounter3,
+  isMap as isMap4,
+  isNode as isNode3,
+  isScalar as isScalar3,
+  isSeq as isSeq2,
+  parse as parseYaml2,
+  parseDocument as parseDocument4
+} from "yaml";
+
+// src/meta/core/external-metadata-write.ts
+import { posix as posix3 } from "node:path";
+import {
+  LineCounter as LineCounter2,
+  isMap as isMap3,
+  isNode as isNode2,
+  isScalar as isScalar2,
+  parseDocument as parseDocument3,
+  stringify as stringify2
+} from "yaml";
+function spliceManifestValue(text, options) {
+  const { entry, key, value, file } = options;
+  const join4 = options.join ?? PATH_JOIN;
+  const at2 = (line2) => {
+    const name = file === void 0 ? "Manifest" : `Manifest ${file}`;
+    if (line2 === void 0) return name;
+    return file === void 0 ? `${name} line ${String(line2)}` : `${name}:${String(line2)}`;
+  };
+  if (key === FILE_SCHEMA_KEY) {
+    throw new DocmetaError(
+      `${at2()}: refusing to write "${FILE_SCHEMA_KEY}" for "${entry}"; a manifest never chooses the schema a document is judged by. Use "overrides" in the config.`
+    );
+  }
+  if (value === void 0) {
+    throw new DocmetaError(`${at2()}: refusing to write "${key}" for "${entry}" with no value.`);
+  }
+  const eol = detectEol(text);
+  const lc = new LineCounter2();
+  const doc = parseDocument3(text, { lineCounter: lc, uniqueKeys: false });
+  const problem = doc.errors[0];
+  if (problem) {
+    throw new DocmetaError(`${at2()} is not valid YAML: ${problem.message}`);
+  }
+  const keyLine = (node) => {
+    const r = rangeOf(node);
+    return r ? lc.linePos(r[0]).line : void 0;
+  };
+  const same = join4 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
+  const root = doc.contents;
+  let spelled = entry;
+  let edit;
+  if (root === null || isScalar2(root) && root.value === null && emptySource(text, root)) {
+    edit = startManifest(text, entry, key, value, eol);
+  } else if (!isMap3(root)) {
+    throw new DocmetaError(
+      `${at2()}: the manifest must be a mapping from document ${join4 === PATH_JOIN ? "path" : `"${join4}"`} to owned keys.`
+    );
+  } else {
+    const style = detectStyle(text, root, eol);
+    const matches = root.items.filter((p) => same(keyString(p.key), entry));
+    const [first, second] = matches;
+    if (first && second) {
+      throw new DocmetaError(
+        `${at2(keyLine(second.key))}: "${keyString(second.key)}" is named twice (first at line ${String(keyLine(first.key) ?? "?")}). Merge the two entries into one.`
+      );
+    }
+    if (first === void 0) {
+      if (root.flow === true && root.items.length > 0) {
+        throw new DocmetaError(
+          `${at2()}: the manifest is a flow mapping ({ \u2026 }), which this writer does not add entries to. Rewrite it in block style.`
+        );
+      }
+      edit = appendEntry(text, root, entry, key, value, style);
+    } else {
+      spelled = keyString(first.key);
+      const where = at2(keyLine(first.key));
+      const v = first.value;
+      if (!isMap3(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);
+      const [hit, again] = hits;
+      if (hit && again) {
+        throw new DocmetaError(
+          `${at2(keyLine(again.key))}: "${spelled}" sets "${key}" twice (first at line ${String(keyLine(hit.key) ?? "?")}). Remove one.`
+        );
+      }
+      const flowRefusal = () => new DocmetaError(
+        `${where}: "${spelled}" is a flow mapping ({ \u2026 }), which this writer does not add keys to. Rewrite the entry in block style.`
+      );
+      const formRefusal = () => new DocmetaError(
+        `${where}: "${spelled}" writes a key in a form this writer does not edit. Write it as "${key}: \u2026".`
+      );
+      let made;
+      if (v.flow === true) {
+        if (hit) made = replaceFlowValue(text, hit, value);
+        else if (v.items.length === 0) made = fillEmptyEntry(text, first, key, value, style);
+        else throw flowRefusal();
+        if (!made) throw hit ? flowRefusal() : formRefusal();
+      } else {
+        made = hit ? replaceBlockValue(text, hit, value, style) : insertKey(text, v, key, value, style);
+        if (!made) throw formRefusal();
+      }
+      edit = made;
+    }
+  }
+  const out = text.slice(0, edit.start) + edit.insert + text.slice(edit.end);
+  const line = readBack(
+    doc,
+    out,
+    spelled,
+    key,
+    value,
+    (why) => new DocmetaError(
+      `${at2()}: writing "${key}" for "${entry}" did not read back as written, so nothing was written. ${why}`
+    )
+  );
+  return { text: out, line };
+}
+function readManifestValue(text, options) {
+  const join4 = options.join ?? PATH_JOIN;
+  const doc = parseDocument3(text, { uniqueKeys: false });
+  if (doc.errors.length > 0) return void 0;
+  const root = doc.contents;
+  if (!isMap3(root)) return void 0;
+  const same = join4 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
+  const pair = root.items.find((p) => same(keyString(p.key), options.entry));
+  const held = pair?.value;
+  if (!isMap3(held)) return void 0;
+  const kv = held.items.find((p) => keyString(p.key) === options.key);
+  const node = kv?.value;
+  return isNode2(node) ? node.toJSON() : void 0;
+}
+function removeManifestKey(text, options) {
+  const { entry, key, file } = options;
+  const join4 = options.join ?? PATH_JOIN;
+  const at2 = (line) => {
+    const name = file === void 0 ? "Manifest" : `Manifest ${file}`;
+    if (line === void 0) return name;
+    return file === void 0 ? `${name} line ${String(line)}` : `${name}:${String(line)}`;
+  };
+  const eol = detectEol(text);
+  const lc = new LineCounter2();
+  const doc = parseDocument3(text, { lineCounter: lc, uniqueKeys: false });
+  const problem = doc.errors[0];
+  if (problem) {
+    throw new DocmetaError(`${at2()} is not valid YAML: ${problem.message}`);
+  }
+  const keyLine = (node) => {
+    const r = rangeOf(node);
+    return r ? lc.linePos(r[0]).line : void 0;
+  };
+  const root = doc.contents;
+  if (root === null || isScalar2(root) && root.value === null) return { text };
+  if (!isMap3(root)) {
+    throw new DocmetaError(
+      `${at2()}: the manifest must be a mapping from document ${join4 === PATH_JOIN ? "path" : `"${join4}"`} to owned keys.`
+    );
+  }
+  const same = join4 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
+  const matches = root.items.filter((p) => same(keyString(p.key), entry));
+  const [first, second] = matches;
+  if (first && second) {
+    throw new DocmetaError(
+      `${at2(keyLine(second.key))}: "${keyString(second.key)}" is named twice (first at line ${String(keyLine(first.key) ?? "?")}). Merge the two entries into one.`
+    );
+  }
+  if (first === void 0) return { text };
+  const spelled = keyString(first.key);
+  const where = at2(keyLine(first.key));
+  const v = first.value;
+  if (!isMap3(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);
+  const [hit, again] = hits;
+  if (hit && again) {
+    throw new DocmetaError(
+      `${at2(keyLine(again.key))}: "${spelled}" sets "${key}" twice (first at line ${String(keyLine(hit.key) ?? "?")}). Remove one.`
+    );
+  }
+  if (hit === void 0) return { text };
+  const whole = v.items.length === 1;
+  if (!whole && v.flow === true) {
+    throw new DocmetaError(
+      `${where}: "${spelled}" is a flow mapping ({ \u2026 }), which this writer does not remove keys from. Rewrite the entry in block style.`
+    );
+  }
+  const from = rangeOf(whole ? first.key : hit.key);
+  const to = whole ? contentEnd(text, v) : contentEnd(text, hit.value) ?? contentEnd(text, hit.key);
+  if (!from || to === void 0) {
+    throw new DocmetaError(
+      `${where}: "${spelled}" writes a key in a form this writer does not edit. Write it as "${key}: \u2026".`
+    );
+  }
+  let { start, end } = keyLines(text, from[0], to, eol);
+  if (whole) {
+    if (text.slice(start - 2 * eol.length, start) === eol + eol) start -= eol.length;
+    else if (start === 0 && text.startsWith(eol, end)) end += eol.length;
+  }
+  const out = text.slice(0, start) + text.slice(end);
+  const after = parseDocument3(out, { uniqueKeys: false });
+  const fail = (why) => new DocmetaError(
+    `${at2()}: removing "${key}" for "${entry}" did not read back as removed, so nothing was written. ${why}`
+  );
+  if (after.errors[0]) throw fail(`The result is not valid YAML: ${after.errors[0].message}`);
+  const was = doc.toJS({ maxAliasCount: 100 });
+  const wasRoot = isRecord3(was) ? was : {};
+  const wasEntry = wasRoot[spelled];
+  const rest = Object.fromEntries(
+    Object.entries(isRecord3(wasEntry) ? wasEntry : {}).filter(([k]) => k !== key)
+  );
+  const kept = Object.entries(wasRoot).filter(([k]) => k !== spelled);
+  if (Object.keys(rest).length > 0) kept.push([spelled, rest]);
+  const now = after.toJS({ maxAliasCount: 100 });
+  const expected = kept.length === 0 ? null : Object.fromEntries(kept);
+  if (!deepEqual(now ?? null, expected)) throw fail("Another value in the manifest would have changed.");
+  return { text: out };
+}
+function renameManifestEntry(text, options) {
+  const { entry, to, file } = options;
+  const join4 = options.join ?? PATH_JOIN;
+  const at2 = (line) => {
+    const name = file === void 0 ? "Manifest" : `Manifest ${file}`;
+    if (line === void 0) return name;
+    return file === void 0 ? `${name} line ${String(line)}` : `${name}:${String(line)}`;
+  };
+  const lc = new LineCounter2();
+  const doc = parseDocument3(text, { lineCounter: lc, uniqueKeys: false });
+  const problem = doc.errors[0];
+  if (problem) {
+    throw new DocmetaError(`${at2()} is not valid YAML: ${problem.message}`);
+  }
+  const keyLine = (node) => {
+    const r2 = rangeOf(node);
+    return r2 ? lc.linePos(r2[0]).line : void 0;
+  };
+  const root = doc.contents;
+  if (root === null || isScalar2(root) && root.value === null) return { text };
+  if (!isMap3(root)) {
+    throw new DocmetaError(
+      `${at2()}: the manifest must be a mapping from document ${join4 === PATH_JOIN ? "path" : `"${join4}"`} to owned keys.`
+    );
+  }
+  const same = join4 === PATH_JOIN ? (a, b) => posix3.normalize(a) === posix3.normalize(b) : (a, b) => a === b;
+  const [first, second] = root.items.filter((p) => same(keyString(p.key), entry));
+  if (first && second) {
+    throw new DocmetaError(
+      `${at2(keyLine(second.key))}: "${keyString(second.key)}" is named twice (first at line ${String(keyLine(first.key) ?? "?")}). Merge the two entries into one.`
+    );
+  }
+  if (first === void 0) return { text };
+  const taken = root.items.find((p) => same(keyString(p.key), to));
+  if (taken !== void 0) {
+    throw new DocmetaError(
+      `${at2(keyLine(taken.key))}: "${keyString(taken.key)}" already has an entry, so "${keyString(first.key)}" cannot be renamed to it. Merge the two entries into one.`
+    );
+  }
+  const spelled = keyString(first.key);
+  const r = rangeOf(first.key);
+  const end = contentEnd(text, first.key);
+  if (!r || end === void 0 || colonEnd(text, first) === void 0) {
+    throw new DocmetaError(
+      `${at2(keyLine(first.key))}: "${spelled}" is written in a form this writer does not edit. Write it as "${spelled}: \u2026".`
+    );
+  }
+  const quoted = isScalar2(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 = text.slice(0, r[0]) + insert + text.slice(end);
+  const after = parseDocument3(out, { uniqueKeys: false });
+  const fail = (why) => new DocmetaError(
+    `${at2()}: renaming "${spelled}" to "${to}" did not read back as renamed, so nothing was written. ${why}`
+  );
+  if (after.errors[0]) throw fail(`The result is not valid YAML: ${after.errors[0].message}`);
+  const was = doc.toJS({ maxAliasCount: 100 });
+  const wasRoot = isRecord3(was) ? was : {};
+  const expected = Object.fromEntries(
+    Object.entries(wasRoot).map(([k, v]) => [k === spelled ? to : k, v])
+  );
+  const now = after.toJS({ maxAliasCount: 100 });
+  if (!deepEqual(now, expected)) throw fail("Another value in the manifest would have changed.");
+  return { text: out };
+}
+function startManifest(text, entry, key, value, eol) {
+  const style = { step: 2, indentSeq: true, eol };
+  const block = blockLines({ [entry]: { [key]: value } }, 0, style);
+  let insert;
+  if (text === "" || text.endsWith("\n")) insert = block + eol;
+  else insert = eol + block;
+  return { start: text.length, end: text.length, insert };
+}
+function appendEntry(text, root, entry, key, value, style) {
+  const body = { [entry]: { [key]: value } };
+  if (root.flow === true) {
+    const r = rangeOf(root);
+    const start = r ? r[0] : text.length;
+    const end = contentEnd(text, root) ?? start;
+    return { start, end, insert: blockLines(body, colOf(text, start), style) };
+  }
+  const firstKey = rangeOf(root.items[0]?.key);
+  const col = firstKey ? colOf(text, firstKey[0]) : 0;
+  const pos = lineEnd(text, contentEnd(text, root) ?? text.length);
+  const last = root.items.at(-1);
+  const spaced = root.items.length > 1 && isNode2(last?.key) && last.key.spaceBefore === true;
+  return {
+    start: pos,
+    end: pos,
+    insert: style.eol + (spaced ? style.eol : "") + blockLines(body, col, style)
+  };
+}
+function fillEmptyEntry(text, entryPair, key, value, style) {
+  const start = colonEnd(text, entryPair);
+  const keyRange = rangeOf(entryPair.key);
+  const end = contentEnd(text, entryPair.value);
+  if (start === void 0 || !keyRange || end === void 0) return void 0;
+  const col = colOf(text, keyRange[0]) + style.step;
+  return { start, end, insert: style.eol + blockLines({ [key]: value }, col, style) };
+}
+function readBack(before, out, spelled, key, value, fail) {
+  const lc = new LineCounter2();
+  const after = parseDocument3(out, { lineCounter: lc, uniqueKeys: false });
+  const problem = after.errors[0];
+  if (problem) throw fail(`The result is not valid YAML: ${problem.message}`);
+  const was = before.toJS({ maxAliasCount: 100 });
+  const now = after.toJS({ maxAliasCount: 100 });
+  const wasRoot = isRecord3(was) ? was : {};
+  const wasEntry = wasRoot[spelled];
+  const expected = {
+    ...wasRoot,
+    [spelled]: { ...isRecord3(wasEntry) ? wasEntry : {}, [key]: value }
+  };
+  const nowEntry = isRecord3(now) ? now[spelled] : void 0;
+  if (!isRecord3(nowEntry) || !deepEqual(nowEntry[key], value)) {
+    throw fail(
+      "The value reads back differently. A Date, an undefined member, or another value YAML cannot hold does not survive the trip."
+    );
+  }
+  if (!deepEqual(now, expected)) {
+    throw fail("Another value in the manifest would have changed.");
+  }
+  const root = after.contents;
+  const pair = isMap3(root) ? root.items.find((p) => keyString(p.key) === spelled) : void 0;
+  const entryMap = pair?.value;
+  const kv = isMap3(entryMap) ? entryMap.items.find((p) => keyString(p.key) === key) : void 0;
+  const r = rangeOf(kv?.value) ?? rangeOf(kv?.key);
+  if (!r) throw fail("The written value could not be found again.");
+  return lc.linePos(r[0]).line;
+}
+function isRecord3(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+
+// src/meta/core/relocation.ts
+function relocateFailed(result) {
+  return result.summary.stayed > 0;
+}
+function relocationContext(run, extras) {
+  return {
+    cwd: extras.cwd,
+    base: run.base,
+    noConfig: extras.noConfig ?? false,
+    config: run.config,
+    ...run.configDir !== void 0 ? { configDir: run.configDir } : {},
+    ...run.configPath !== void 0 ? { configPath: run.configPath } : {},
+    ...run.configFile !== void 0 ? { configFile: run.configFile } : {},
+    collections: run.collections,
+    declaredCollections: run.declaredCollections,
+    targets: extras.targets.filter((t) => t !== STDIN_TOKEN),
+    ...extras.cliSchemas !== void 0 ? { cliSchemas: extras.cliSchemas } : {},
+    validator: extras.validator,
+    ...extras.as !== void 0 ? { as: extras.as } : {},
+    ...extras.respectGitignore !== void 0 ? { respectGitignore: extras.respectGitignore } : {},
+    ...extras.env !== void 0 ? { env: extras.env } : {},
+    ...extras.onNotice !== void 0 ? { onNotice: extras.onNotice } : {}
+  };
+}
+var toPosix = (p) => p.split(sep3).join("/");
+function reported2(abs, base) {
+  const rel = relative4(base, abs);
+  return rel === "" ? "." : toPosix(rel);
+}
+function configSource(path, cwd) {
+  return toPosix(relative4(cwd, path)) || basename3(path);
+}
+function cloneCollection(c) {
+  return {
+    ...c,
+    paths: [...c.paths],
+    exclude: [...c.exclude],
+    externalMetadata: c.externalMetadata.map((m) => m.keys === void 0 ? { ...m } : { ...m, keys: [...m.keys] })
+  };
+}
+var Model = class {
+  constructor(ctx, configDir) {
+    this.ctx = ctx;
+    this.configDir = configDir;
+    this.collections = ctx.declaredCollections.map(cloneCollection);
+    for (const c of this.collections) {
+      c.externalMetadata.forEach((m, index) => {
+        const url = classifyRef(m.file).kind === "url";
+        const perPage = !url && hasPagePlaceholder(m.file);
+        const absPath = url || perPage ? void 0 : isAbsolute3(m.file) ? m.file : resolve3(configDir, m.file);
+        this.manifests.push({
+          collection: c.name,
+          index,
+          written: m.file,
+          url,
+          absPath,
+          file: absPath === void 0 ? m.file : reported2(absPath, ctx.base),
+          join: externalMetadataJoin(m),
+          perPage,
+          created: false,
+          implied: m.keys === void 0,
+          keysBefore: [...m.keys ?? []],
+          keysAdded: [],
+          keysRemoved: []
+        });
+      });
+    }
+  }
+  ctx;
+  configDir;
+  collections;
+  manifests = [];
+  created = [];
+  pathsAdded = [];
+  targets;
+  members(label) {
+    return memberOf(this.collections, this.configDir, this.ctx.base, label);
+  }
+  /** The run's targets as `paths:` entries, in target order; resolved once, on first use. */
+  targetPaths() {
+    this.targets ??= Promise.all(this.ctx.targets.map((t) => collectionPath(t, this.ctx.cwd, this.configDir)));
+    return this.targets;
+  }
+  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 }, 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.
+   * `marked` is what the page's schemas mark external, which is what a
+   * manifest with no `keys` owns (proposal 0068).
+   */
+  ownerOf(key, members, marked) {
+    return this.manifests.find(
+      (m) => members.includes(m.collection) && (m.implied ? this.impliedOwns(m, key, marked) : m.keysBefore.includes(key) || m.keysAdded.includes(key))
+    );
+  }
+  /** Does a keyless manifest own `key` for a page whose schemas mark `marked`? */
+  impliedOwns(m, key, marked) {
+    const collection = this.collections.find((c) => c.name === m.collection);
+    const declared = collection?.externalMetadata[m.index];
+    return collection !== void 0 && declared !== void 0 && ownsKey(collection, declared, key, marked);
+  }
+  /** Does one of `members` declare a manifest with no `keys`? */
+  hasImplied(members) {
+    return this.manifests.some((m) => m.implied && members.includes(m.collection));
+  }
+  /** The page's collection to home a new key in, first by the run's selection. */
+  pick(members) {
+    const selected = new Set(this.ctx.collections.map((c) => c.name));
+    return members.find((m) => selected.has(m)) ?? members[0];
+  }
+  /**
+   * §3's four cases. `commit` makes the choice part of the model (a created
+   * collection, an appended path, a new manifest), which planning wants and a
+   * lookup does not.
+   */
+  async home(label, commit, owns = () => false) {
+    if (this.ctx.noConfig) {
+      return { proposed: { kind: "none", reason: "no-config", collections: this.collections.length } };
+    }
+    const members = this.members(label);
+    let collection = this.pick(members);
+    let createsCollection = false;
+    let addsPath;
+    if (collection === void 0) {
+      const rel = this.relative(label);
+      if (this.collections.length === 0) {
+        const paths = dedupe(
+          (await this.targetPaths()).flatMap((p) => p === void 0 ? [] : [p])
+        );
+        if (rel === void 0 || !paths.some((p) => isMember(bare(p), rel))) {
+          return { proposed: { kind: "none", reason: "collections", collections: 0 } };
+        }
+        collection = "default";
+        createsCollection = true;
+        if (commit) {
+          this.collections.push({ name: collection, paths, exclude: [], externalMetadata: [] });
+          this.created.push({ name: collection, paths: [...paths] });
+        }
+      } else if (this.collections.length === 1 && this.collections[0] !== void 0) {
+        const only = this.collections[0];
+        const target = (await this.targetPaths()).find(
+          (p) => p !== void 0 && rel !== void 0 && isMember(bare(p), rel)
+        );
+        if (target === void 0) {
+          return { proposed: { kind: "none", reason: "collections", collections: 1 } };
+        }
+        collection = only.name;
+        addsPath = target;
+        if (commit) {
+          only.paths.push(target);
+          this.pathsAdded.push({ collection: only.name, path: target });
+        }
+      } else {
+        return { proposed: { kind: "none", reason: "collections", collections: this.collections.length } };
+      }
+    }
+    const name = collection;
+    const local = this.manifestsOf(name).find((m) => !m.url && (!m.implied || owns(m)));
+    const proposedOf = (m) => ({
+      kind: "collection",
+      collection: name,
+      manifest: m.file,
+      createsManifest: m.created,
+      createsCollection,
+      ...addsPath !== void 0 ? { addsPath } : {}
+    });
+    if (local !== void 0) return { manifest: local, proposed: proposedOf(local) };
+    const fileName = `${name}.metadata.yaml`;
+    const absPath = join3(this.configDir, fileName);
+    const file = reported2(absPath, this.ctx.base);
+    if (!commit) return { proposed: proposedOf({ file, created: true }) };
+    if (await exists(absPath, file)) {
+      throw new DocmetaError(
+        `${file} already exists and is not a manifest of collection ${name}; declare it under externalMetadata, or move it.`
+      );
+    }
+    const owner = this.collections.find((c) => c.name === name);
+    const ref = {
+      collection: name,
+      index: owner?.externalMetadata.length ?? 0,
+      written: `./${fileName}`,
+      url: false,
+      absPath,
+      file,
+      join: PATH_JOIN,
+      perPage: false,
+      created: true,
+      implied: false,
+      keysBefore: [],
+      keysAdded: [],
+      keysRemoved: []
+    };
+    owner?.externalMetadata.push({ file: ref.written, keys: [] });
+    this.manifests.push(ref);
+    return { manifest: ref, proposed: proposedOf(ref) };
+  }
+  addKey(m, key) {
+    if (m.implied || m.keysBefore.includes(key) || m.keysAdded.includes(key)) return;
+    m.keysAdded.push(key);
+    this.collections.find((c) => c.name === m.collection)?.externalMetadata[m.index]?.keys?.push(key);
+  }
+  removeKey(m, key) {
+    if (!m.keysBefore.includes(key) || m.keysRemoved.includes(key)) return;
+    m.keysRemoved.push(key);
+  }
+  /** The keys a manifest owns once the plan is applied. */
+  finalKeys(m) {
+    return [...m.keysBefore.filter((k) => !m.keysRemoved.includes(k)), ...m.keysAdded];
+  }
+  /** The collections as the config will declare them: removals applied, emptied manifests gone. */
+  final() {
+    return this.collections.map((c) => ({
+      ...c,
+      externalMetadata: c.externalMetadata.flatMap((em, index) => {
+        const ref = this.manifests.find((m) => m.collection === c.name && m.index === index);
+        if (ref?.implied === true || ref === void 0 && em.keys === void 0) return [em];
+        const keys = ref === void 0 ? em.keys ?? [] : this.finalKeys(ref);
+        return keys.length === 0 ? [] : [{ ...em, keys }];
+      })
+    }));
+  }
+  /** A label relative to the config directory, posix; undefined outside it. */
+  relative(label) {
+    if (label === "<stdin>") return void 0;
+    const rel = toPosix(relative4(this.configDir, resolve3(this.ctx.base, label)));
+    return isAbsolute3(rel) || rel.startsWith("../") ? void 0 : rel;
+  }
+};
+function dedupe(xs) {
+  return [...new Set(xs)];
+}
+function bare(path) {
+  return { name: "", paths: [path], exclude: [], externalMetadata: [] };
+}
+async function collectionPath(target, cwd, configDir) {
+  if (target === STDIN_TOKEN) return void 0;
+  const posix4 = target.replace(/\\/g, "/");
+  const scanned = picomatch.scan(posix4);
+  if (scanned.isGlob) {
+    const rel2 = toPosix(relative4(configDir, resolve3(cwd, scanned.base === "" ? "." : scanned.base)));
+    if (isAbsolute3(rel2) || rel2 === ".." || rel2.startsWith("../")) return void 0;
+    return rel2 === "" ? scanned.glob : `${rel2}/${scanned.glob}`;
+  }
+  const abs = resolve3(cwd, posix4);
+  const rel = toPosix(relative4(configDir, abs));
+  if (isAbsolute3(rel) || rel.startsWith("..")) return void 0;
+  let directory = posix4.endsWith("/");
+  if (!directory) {
+    try {
+      directory = (await stat2(abs)).isDirectory();
+    } catch {
+      directory = false;
+    }
+  }
+  if (!directory) return rel;
+  return rel === "" ? "**" : `${rel}/**`;
+}
+async function exists(absPath, file) {
+  try {
+    await access(absPath);
+    return true;
+  } catch (err) {
+    if (err.code === "ENOENT") return false;
+    throw new DocmetaError(`${file} could not be checked: ${errorMessage(err)}`);
+  }
+}
+function plannedConfigDir(ctx) {
+  return ctx.configDir ?? findGitRoot(ctx.cwd) ?? resolve3(ctx.cwd);
+}
+async function keyHome(ctx, label, data, key) {
+  const model = new Model(ctx, plannedConfigDir(ctx));
+  const members = model.members(label);
+  const marked = model.hasImplied(members) ? await marksOf(ctx)(
+    label,
+    Object.hasOwn(data, key) ? data : { ...data, [key]: null },
+    memberOf(ctx.declaredCollections, ctx.configDir ?? ctx.cwd, ctx.base, label)
+  ) : void 0;
+  const owner = model.ownerOf(key, members, marked);
+  if (owner !== void 0) {
+    const at2 = model.fileFor(owner, resolve3(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: at2.file,
+      absPath: at2.abs,
+      join: owner.join,
+      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 marksOf(ctx) {
+  return pageMarks({
+    validator: ctx.validator,
+    config: ctx.config,
+    cwd: ctx.cwd,
+    trustRoot: schemaTrustRoot(ctx.cwd, ctx.configDir),
+    ...ctx.cliSchemas !== void 0 ? { cliSchemas: ctx.cliSchemas } : {}
+  });
+}
+function entryFor(m, label, data, configDir, base, key) {
+  if (m.join === PATH_JOIN) return toPosix(relative4(configDir, resolve3(base, label)));
+  let raw = data[m.join];
+  if (isEncryptedValue(raw)) {
+    const k = key();
+    if (k === void 0) {
+      throw new EncryptionRefusal(
+        `externalMetadata join field "${m.join}" is encrypted on these pages, and no encryption key is available to match them.`
+      );
+    }
+    const opened = decryptValue(raw, k, META_CONTEXT);
+    if (!opened.ok) return void 0;
+    raw = opened.value;
+  }
+  if (typeof raw === "string") return raw;
+  if (typeof raw === "number" || typeof raw === "boolean") return String(raw);
+  return void 0;
+}
+async function relocationPages(ctx, request) {
+  const pages = new Set(request.files.map((label) => resolve3(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) pages.add(resolve3(root, file));
+  }
+  return [...pages];
+}
+async function planRelocation(ctx, request) {
+  const configDir = plannedConfigDir(ctx);
+  const model = new Model(ctx, configDir);
+  const encryptionKey = lazyKey(ctx.configFile, ctx.env);
+  const marks = marksOf(ctx);
+  const index = await loadExternalMetadata(ctx.declaredCollections, {
+    configDir: ctx.configDir ?? ctx.cwd,
+    base: ctx.base,
+    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;
+  const fields = request.fields === void 0 ? void 0 : new Set(request.fields);
+  const wanted = (key) => key !== FILE_SCHEMA_KEY && (fields === void 0 || fields.has(key));
+  const currentMembers = (label) => memberOf(ctx.declaredCollections, ctx.configDir ?? ctx.cwd, ctx.base, label);
+  const pages = /* @__PURE__ */ new Map();
+  const runSet = new Set(request.files);
+  const load = async (label, beyond) => {
+    const have = pages.get(label);
+    if (have !== void 0) return have;
+    const extractor = (beyond ? void 0 : forced) ?? extractorForExtension(extname(label));
+    if (extractor === void 0) {
+      if (beyond) return void 0;
+      throw new DocmetaError(`Unsupported file type "${extname(label)}" for "${label}". Use --as to override.`);
+    }
+    const absPath = resolve3(ctx.base, label);
+    const elements = resolveElements(label, ctx.config, currentMembers(label));
+    let content = "";
+    let own = {};
+    let unreadable2;
+    if (beyond) {
+      try {
+        content = await readFile4(absPath, "utf8");
+        own = extractor.extract(content, label, { elements }).data;
+      } catch (err) {
+        unreadable2 = (errorMessage(err).split("\n")[0] ?? "").replace(/:\s*$/, "");
+      }
+    } else {
+      content = await readFile4(absPath, "utf8");
+      try {
+        own = extractor.extract(content, label, { elements }).data;
+      } catch (err) {
+        throw new DocmetaError(`${label}: ${errorMessage(err)}`);
+      }
+    }
+    const page = {
+      label,
+      absPath,
+      format: extractor.name,
+      content,
+      elements,
+      extractor,
+      own,
+      beyond,
+      ...unreadable2 !== void 0 ? { unreadable: unreadable2 } : {},
+      intents: /* @__PURE__ */ new Map()
+    };
+    pages.set(label, page);
+    return page;
+  };
+  const supplied = (m, page, key) => {
+    if (m.created || index === null) return void 0;
+    let sv;
+    if (m.join === PATH_JOIN) {
+      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 === 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 });
+  };
+  const urlDetail = (m) => `${m.file} is fetched and cannot be written`;
+  const unreadableDetail = (page) => `this document could not be parsed: ${page.unreadable ?? ""}`;
+  const planOut = (page, m, key, reason) => {
+    if (page.intents.has(key)) return;
+    if (m.url) {
+      stay(page, key, "url-manifest", urlDetail(m), { toward: m });
+      return;
+    }
+    const entry = entryFor(m, page.label, page.own, configDir, ctx.base, encryptionKey);
+    if (entry === void 0) {
+      stay(page, key, "no-join-value", `this document has no ${m.join}, which ${m.file} joins on`, { toward: m });
+      return;
+    }
+    const held = supplied(m, page, key);
+    if (held !== void 0 && !deepEqual(held.value, page.own[key])) {
+      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 });
+  };
+  const planIn = (page, m, key) => {
+    if (page.intents.has(key)) return;
+    const held = supplied(m, page, key);
+    if (held === void 0) return;
+    const entry = entryFor(m, page.label, page.own, configDir, ctx.base, encryptionKey);
+    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 ${held.file} hold different values`, { blocks: m });
+        return;
+      }
+      page.intents.set(key, { kind: "in", manifest: m, drop: true, entry, value: held.value });
+      return;
+    }
+    page.intents.set(key, { kind: "in", manifest: m, drop: false, entry, value: held.value });
+  };
+  const preferencesOf = /* @__PURE__ */ new Map();
+  const homeless = /* @__PURE__ */ new Map();
+  const marked = /* @__PURE__ */ new Set();
+  for (const label of request.files) {
+    const page = await load(label, false);
+    if (page === void 0) continue;
+    const members = currentMembers(label);
+    const merged = await mergeWithMarks(
+      label,
+      { data: page.own, present: true, format: page.format, lineFor: () => void 0 },
+      index,
+      members,
+      ctx.base,
+      { encryptionKey, marks }
+    );
+    const data = merged.extracted.data;
+    const required = request.require?.get(label) ?? [];
+    const resolved = resolveSchemaSetWithSource({
+      filePath: label,
+      fileSchema: data[FILE_SCHEMA_KEY],
+      ...ctx.cliSchemas !== void 0 ? { cliSchemas: [...ctx.cliSchemas] } : {},
+      config: ctx.config,
+      memberOf: members,
+      fileBase: ctx.cwd,
+      trustRoot,
+      ...ctx.onNotice !== void 0 ? { onNotice: ctx.onNotice } : {}
+    });
+    const probe = { ...data };
+    for (const key of required) if (!(key in probe)) probe[key] = null;
+    const prefs = /* @__PURE__ */ new Map();
+    const external = /* @__PURE__ */ new Set();
+    for (const [key, p] of await ctx.validator.locationPreferences(probe, resolved.schemas)) {
+      prefs.set(key, p.location);
+      marked.add(key);
+      if (p.location === "external") external.add(key);
+    }
+    for (const key of required) if (!prefs.has(key)) prefs.set(key, "external");
+    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)
+    );
+    for (const m of model.manifests) {
+      if (planned.includes(m.collection)) for (const k of [...m.keysBefore, ...m.keysAdded]) marked.add(k);
+    }
+    const keys = dedupe([...Object.keys(data), ...required]).filter(wanted);
+    for (const key of keys) {
+      if (joins.has(key)) continue;
+      const pref = prefs.get(key);
+      const inPage = Object.hasOwn(page.own, key);
+      const owner = model.ownerOf(key, model.members(label), external);
+      if (owner !== void 0) {
+        if (pref === "page") {
+          if (owner.url) {
+            if (supplied(owner, page, key) !== void 0) stay(page, key, "url-manifest", urlDetail(owner));
+          } else if (owner.keysBefore.includes(key)) {
+            model.removeKey(owner, key);
+          }
+        } else if (inPage) {
+          planOut(page, owner, key, pref === "external" ? "preferred" : "owned");
+        }
+        continue;
+      }
+      if (pref !== "external" || !(inPage || required.includes(key))) continue;
+      const chosen = await model.home(label, true, (m) => model.impliedOwns(m, key, external));
+      if ("manifest" in chosen) {
+        if (chosen.manifest.implied) {
+          if (inPage) planOut(page, chosen.manifest, key, "preferred");
+          continue;
+        }
+        model.addKey(chosen.manifest, key);
+        continue;
+      }
+      if (chosen.proposed.kind !== "none") continue;
+      if (inPage) {
+        stay(
+          page,
+          key,
+          "no-home",
+          chosen.proposed.reason === "no-config" ? "--no-config leaves this document no manifest" : `this document is in none of the ${chosen.proposed.collections} collections, so it has no manifest`
+        );
+      }
+      const entry = homeless.get(label) ?? {
+        keys: [],
+        reason: chosen.proposed.reason,
+        collections: chosen.proposed.collections
+      };
+      entry.keys.push(key);
+      homeless.set(label, entry);
+    }
+  }
+  if (fields !== void 0) {
+    for (const f of fields) {
+      if (!marked.has(f) && !(request.require !== void 0 && [...request.require.values()].some((ks) => ks.includes(f)))) {
+        throw new DocmetaError(
+          `"${f}" has no x-manni-location mark and no owning manifest for any file in this run.`
+        );
+      }
+    }
+  }
+  const suspended = [];
+  for (const page of pages.values()) {
+    for (const [key, intent] of [...page.intents]) {
+      const m = intent.kind === "out" ? intent.manifest : intent.kind === "stay" ? intent.toward : void 0;
+      if (m === void 0 || !m.keysRemoved.includes(key)) continue;
+      page.intents.delete(key);
+      const prefs = preferencesOf.get(page.label);
+      suspended.push({
+        page,
+        manifest: m,
+        key,
+        reason: intent.kind === "out" ? intent.reason : prefs?.get(key) === "external" ? "preferred" : "owned"
+      });
+    }
+  }
+  const grown = new Set(model.pathsAdded.map((p) => p.collection));
+  const affected = new Set(grown);
+  for (const m of model.manifests) {
+    if (m.keysAdded.length > 0 || m.keysRemoved.length > 0) affected.add(m.collection);
+  }
+  for (const name of affected) {
+    const collection = model.collections.find((c) => c.name === name);
+    if (collection === void 0) continue;
+    const walked = await resolveTargetSet({
+      inputs: [...collection.paths],
+      cwd: configDir,
+      allowEmpty: true,
+      ...gitignoreOptions({
+        ...ctx.respectGitignore !== void 0 ? { flag: ctx.respectGitignore } : {},
+        ...ctx.config?.respectGitignore !== void 0 ? { configured: ctx.config.respectGitignore } : {}
+      })
+    });
+    const labels = dedupe([
+      ...request.files,
+      ...walked.files.map((f) => reported2(resolve3(configDir, f), ctx.base))
+    ]).filter((label) => model.members(label).includes(name));
+    for (const label of labels) {
+      const page = await load(label, !runSet.has(label));
+      if (page === void 0) continue;
+      const prefs = preferencesOf.get(label);
+      const covered = grown.has(name) && !currentMembers(label).includes(name);
+      for (const m of model.manifestsOf(name)) {
+        const out = dedupe([
+          ...m.keysAdded,
+          ...grown.has(name) ? m.keysBefore.filter((k) => !m.keysRemoved.includes(k)) : []
+        ]).filter((k) => covered ? k !== FILE_SCHEMA_KEY : wanted(k));
+        if (page.unreadable !== void 0) {
+          const detail = unreadableDetail(page);
+          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 === model.fileFor(m, page.absPath).file;
+            if (held && !page.intents.has(key)) stay(page, key, "unreadable", detail, { blocks: m });
+          }
+          continue;
+        }
+        for (const key of out) {
+          if (!Object.hasOwn(page.own, key)) continue;
+          const reason = m.keysAdded.includes(key) || prefs?.get(key) === "external" ? "preferred" : "owned";
+          planOut(page, m, key, reason);
+        }
+        for (const key of m.keysRemoved) planIn(page, m, key);
+      }
+    }
+  }
+  const orderedPages = () => {
+    const all = [...pages.values()];
+    const run = all.filter((p) => !p.beyond).sort((a, b) => compare(a.label, b.label));
+    const beyond = all.filter((p) => p.beyond).sort((a, b) => compare(a.label, b.label));
+    return [...run, ...beyond];
+  };
+  let dirty = new Set(pages.values());
+  while (dirty.size > 0) {
+    const pass = [...pages.values()].filter((p) => dirty.has(p));
+    for (const page of pass) planPageText(page);
+    const touched = /* @__PURE__ */ new Set();
+    for (const page of pass) {
+      for (const [key, intent] of page.intents) {
+        if (intent.kind !== "stay" || intent.blocks === void 0) continue;
+        const m = intent.blocks;
+        if (!m.keysRemoved.includes(key)) continue;
+        m.keysRemoved.splice(m.keysRemoved.indexOf(key), 1);
+        for (const other of pages.values()) {
+          const i = other.intents.get(key);
+          if (i?.kind === "in" && i.manifest === m) {
+            other.intents.delete(key);
+            touched.add(other);
+          }
+        }
+        for (const s of suspended) {
+          if (s.manifest === m && s.key === key) {
+            planOut(s.page, m, key, s.reason);
+            touched.add(s.page);
+          }
+        }
+      }
+    }
+    dirty = touched;
+  }
+  const writes = [];
+  const lines = /* @__PURE__ */ new Map();
+  for (const m of model.manifests) {
+    if (m.url) continue;
+    const undeclared = !m.implied && model.finalKeys(m).length === 0 && !m.created;
+    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.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, pages, 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 text = disk ?? "";
+      const before = text;
+      const where = { join: m.join, file };
+      for (const o of outs) {
+        if (!o.drop) text = spliceManifestValue(text, { ...where, entry: o.entry, key: o.key, value: o.value }).text;
+      }
+      for (const i of ins) text = removeManifestKey(text, { ...where, entry: i.entry, key: i.key }).text;
+      const found = keyLines2(text, 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 || text !== before) {
+        writes.push({ path, text, kind: "manifest", before: disk });
+      }
+    }
+  }
+  const finalCollections = model.final();
+  const needsConfig = model.created.length > 0 || model.pathsAdded.length > 0 || model.manifests.some((m) => m.created || m.keysAdded.length > 0 || m.keysRemoved.length > 0);
+  const target = await configTarget(ctx, configDir);
+  let configCreated = false;
+  if (needsConfig) {
+    if (ctx.configFile !== void 0 && (ctx.configFile.kind === "legacy" || !ctx.configFile.wrapped)) {
+      throw new DocmetaError(
+        `${ctx.configFile.source} is a single-tool config file, which cannot hold collections:. Move its keys under meta: in ${FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml"}.`
+      );
+    }
+    const text = editConfig(target.text, model, configSource(target.path, ctx.cwd));
+    verifyConfig(target.text, text, finalCollections, configSource(target.path, ctx.cwd));
+    writes.push({ path: target.path, text, kind: "config", before: target.disk });
+    configCreated = target.text === null;
+  }
+  for (const page of orderedPages()) {
+    if (page.text !== void 0 && page.text !== page.content) {
+      writes.push({ path: page.absPath, text: page.text, kind: "page", before: page.content });
+    }
+  }
+  const result = buildResult({
+    model,
+    pages: orderedPages(),
+    dryRun: true,
+    lines: /* @__PURE__ */ new Map(),
+    config: {
+      file: needsConfig || ctx.configPath !== void 0 ? configSource(target.path, ctx.cwd) : null,
+      created: configCreated,
+      collectionsCreated: model.created,
+      pathsAdded: model.pathsAdded
+    }
+  });
+  return {
+    result,
+    writes,
+    lines,
+    collections: finalCollections,
+    configDir,
+    configPath: target.path,
+    offers: buildOffers(model, orderedPages(), result, needsConfig ? configSource(target.path, ctx.cwd) : void 0),
+    homeless: [...homeless].map(([file, h]) => ({ file, ...h }))
+  };
+}
+var compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function orderedIntents(page) {
+  const order = Object.keys(page.own);
+  const rank = (key) => {
+    const i = order.indexOf(key);
+    return i === -1 ? order.length : i;
+  };
+  return [...page.intents].sort(([a], [b]) => rank(a) - rank(b));
+}
+function planPageText(page) {
+  const patch = {};
+  const deletions = [];
+  for (const [key, intent] of page.intents) {
+    if (intent.kind === "out") deletions.push(key);
+    else if (intent.kind === "in" && !intent.drop) patch[key] = intent.value;
+  }
+  delete page.text;
+  if (deletions.length === 0 && Object.keys(patch).length === 0) return;
+  const refuse = () => {
+    for (const [key, intent] of page.intents) {
+      if (intent.kind === "out" || intent.kind === "in" && !intent.drop) {
+        page.intents.set(key, {
+          kind: "stay",
+          reason: "read-only-format",
+          detail: `the ${page.format} format cannot write this document's metadata`,
+          ...intent.kind === "in" ? { blocks: intent.manifest } : {}
+        });
+      }
+    }
+  };
+  const apply = page.extractor.apply;
+  if (typeof apply !== "function") {
+    refuse();
+    return;
+  }
+  try {
+    const next = apply(page.content, patch, {
+      filePath: page.label,
+      elements: page.elements,
+      ...deletions.length > 0 ? { deletions } : {}
+    });
+    const after = page.extractor.extract(next, page.label, { elements: page.elements }).data;
+    const wrote = deletions.every((k) => !Object.hasOwn(after, k)) && Object.entries(patch).every(([k, v]) => deepEqual(after[k], v));
+    if (!wrote) {
+      refuse();
+      return;
+    }
+    page.text = next;
+  } catch (err) {
+    if (!(err instanceof DocmetaError)) throw err;
+    refuse();
+  }
+}
+function assertNoStrandedEntries(m, index, pages, configDir, fileOf) {
+  if (index === null || m.keysRemoved.length === 0) return;
+  for (const key of m.keysRemoved) {
+    const moved = /* @__PURE__ */ new Set();
+    for (const page of pages.values()) {
+      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(([abs, values]) => {
+      const sv = values.get(key);
+      return sv !== void 0 && sv.collection === m.collection && sv.file === fileOf(abs);
+    }).map(([abs]) => toPosix(relative4(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);
+    const first = stranded.find((e) => !moved.has(entryId(e, m.join)));
+    if (first !== void 0) {
+      throw new DocmetaError(
+        `Manifest ${m.file} names "${first}", which is not a page of collection ${m.collection}, so ${key} cannot leave its keys while that entry sets it. Fix the entry, or remove it.`
+      );
+    }
+  }
+}
+async function readManifestText(path, file, perPage) {
+  try {
+    return await readFile4(path, "utf8");
+  } catch (err) {
+    if (perPage && isMissing(err)) return null;
+    throw new DocmetaError(`Manifest ${file} could not be read: ${errorMessage(err)}`);
+  }
+}
+var entryId = (entry, join4) => join4 === PATH_JOIN ? toPosix(entry).replace(/^\.\//, "").replace(/\/+/g, "/") : entry;
+var lineId = (page, manifest, key) => `${page}\0${manifest}\0${key}`;
+function keyLines2(text, join4) {
+  const out = /* @__PURE__ */ new Map();
+  const lc = new LineCounter3();
+  const doc = parseDocument4(text, { lineCounter: lc, uniqueKeys: false });
+  const root = doc.contents;
+  if (!isMap4(root)) return out;
+  for (const pair of root.items) {
+    const spelled = isScalar3(pair.key) ? String(pair.key.value) : String(pair.key);
+    if (!isMap4(pair.value)) continue;
+    const keys = /* @__PURE__ */ new Map();
+    for (const kv of pair.value.items) {
+      const name = isScalar3(kv.key) ? String(kv.key.value) : String(kv.key);
+      const range = isNode3(kv.key) ? kv.key.range : void 0;
+      if (range) keys.set(name, lc.linePos(range[0]).line);
+    }
+    out.set(entryId(spelled, join4), keys);
+  }
+  return out;
+}
+async function configTarget(ctx, configDir) {
+  if (ctx.configPath !== void 0) {
+    try {
+      const text = await readFile4(ctx.configPath, "utf8");
+      return { path: ctx.configPath, text, disk: text };
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        throw new DocmetaError(
+          `Config file ${configSource(ctx.configPath, ctx.cwd)} could not be read: ${errorMessage(err)}`
+        );
+      }
+      return { path: ctx.configPath, text: ctx.configFile?.text ?? null, disk: null };
+    }
+  }
+  for (const name of FAMILY_CONFIG_NAMES) {
+    const path = join3(configDir, name);
+    try {
+      const text = await readFile4(path, "utf8");
+      return { path, text, disk: text };
+    } catch {
+    }
+  }
+  return { path: join3(configDir, FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml"), text: null, disk: null };
+}
+function editConfig(text, model, source) {
+  const doc = parseDocument4(text ?? "");
+  const [problem] = doc.errors;
+  if (problem !== void 0) throw new DocmetaError(`${source}: invalid YAML: ${problem.message}`);
+  if (doc.contents !== null && !isMap4(doc.contents)) {
+    throw new DocmetaError(`${source}: top level must be a mapping.`);
+  }
+  const fail = () => {
+    throw new DocmetaError(`Could not edit collections: in ${source}; make the change by hand.`);
+  };
+  const flowSeq = (node, quoted) => {
+    if (!isSeq2(node)) return;
+    node.flow = true;
+    if (quoted) {
+      for (const item of node.items) if (isScalar3(item)) item.type = "QUOTE_DOUBLE";
+    }
+  };
+  const manifestNode = (d, file, keys) => {
+    const node = d.createNode({ file, keys });
+    flowSeq(node.get("keys", true), false);
+    return node;
+  };
+  const declared = model.collections.length - model.created.length;
+  const existing = doc.get("collections", true);
+  if (declared > 0 && !isSeq2(existing)) fail();
+  for (let i = 0; i < declared; i++) {
+    const c = model.collections[i];
+    const node = isSeq2(existing) ? existing.items[i] : void 0;
+    if (c === void 0 || !isMap4(node)) return fail();
+    for (const added of model.pathsAdded.filter((p) => p.collection === c.name)) {
+      const paths = node.get("paths", true);
+      if (!isSeq2(paths)) return fail();
+      const scalar = doc.createNode(added.path);
+      const first = paths.items[0];
+      if (isScalar3(first) && first.type !== void 0) scalar.type = first.type;
+      paths.add(scalar);
+    }
+    const refs = model.manifestsOf(c.name);
+    for (const m of refs) {
+      if (m.created) {
+        let list3 = node.get("externalMetadata", true);
+        if (!isSeq2(list3)) {
+          node.set("externalMetadata", doc.createNode([]));
+          list3 = node.get("externalMetadata", true);
+        }
+        if (!isSeq2(list3)) return fail();
+        list3.add(manifestNode(doc, m.written, m.keysAdded));
+        continue;
+      }
+      if (m.keysAdded.length === 0) continue;
+      const entry = node.getIn(["externalMetadata", m.index], true);
+      const keys = isMap4(entry) ? entry.get("keys", true) : void 0;
+      if (!isSeq2(keys)) return fail();
+      for (const key of m.keysAdded) keys.add(doc.createNode(key));
+    }
+    const list2 = node.get("externalMetadata", true);
+    for (const m of [...refs].filter((r) => !r.created).sort((a, b) => b.index - a.index)) {
+      if (m.keysRemoved.length === 0) continue;
+      if (!isSeq2(list2)) return fail();
+      const entry = list2.items[m.index];
+      const keys = isMap4(entry) ? entry.get("keys", true) : void 0;
+      if (!isSeq2(keys)) return fail();
+      for (const key of m.keysRemoved) {
+        const at2 = keys.items.findIndex((item) => (isScalar3(item) ? String(item.value) : String(item)) === key);
+        if (at2 >= 0) keys.delete(at2);
+      }
+      if (keys.items.length === 0) list2.delete(m.index);
+    }
+    if (isSeq2(list2) && list2.items.length === 0) node.delete("externalMetadata");
+  }
+  for (const created of model.created) {
+    const c = model.collections.find((x) => x.name === created.name);
+    if (c === void 0) continue;
+    const refs = model.manifestsOf(c.name).filter((m) => m.created);
+    const node = doc.createNode({
+      name: c.name,
+      paths: c.paths,
+      ...refs.length > 0 ? { externalMetadata: refs.map((m) => ({ file: m.written, keys: m.keysAdded })) } : {}
+    });
+    flowSeq(node.get("paths", true), true);
+    const made = node.get("externalMetadata", true);
+    if (isSeq2(made)) {
+      for (const item of made.items) if (isMap4(item)) flowSeq(item.get("keys", true), false);
+    }
+    const seq = doc.get("collections", true);
+    if (isSeq2(seq)) seq.add(node);
+    else doc.set("collections", doc.createNode([node]));
+  }
+  return doc.toString({ flowCollectionPadding: false });
+}
+function verifyConfig(before, after, expected, source) {
+  const fail = (why) => {
+    throw new DocmetaError(`Could not edit collections: in ${source}, so nothing was written. ${why}`);
+  };
+  let old;
+  let now;
+  try {
+    old = before === null ? null : parseYaml2(before);
+    now = parseYaml2(after);
+  } catch (err) {
+    return fail(errorMessage(err));
+  }
+  if (typeof now !== "object" || now === null || Array.isArray(now)) return fail("The result is not a mapping.");
+  const nowMap = now;
+  const oldMap = typeof old === "object" && old !== null && !Array.isArray(old) ? old : {};
+  const parsed = parseCollections(nowMap["collections"], source, (m) => new DocmetaError(m));
+  if (!deepEqual(parsed, expected)) return fail("The collections read back differently.");
+  const rest = (m) => Object.fromEntries(Object.entries(m).filter(([k]) => k !== "collections"));
+  if (!deepEqual(rest(nowMap), rest(oldMap))) return fail("Another key would have changed.");
+}
+function buildResult(input) {
+  const { model, pages, dryRun, lines } = input;
+  const files = [];
+  for (const page of pages) {
+    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: fileOf(intent.manifest), reason: "preferred" });
+    }
+    for (const [key, intent] of intents) {
+      if (intent.kind !== "out") continue;
+      const manifest = fileOf(intent.manifest);
+      const line = dryRun ? void 0 : lines.get(lineId(page.label, manifest, key));
+      moved.push({
+        key,
+        to: "manifest",
+        manifest,
+        ...line !== void 0 ? { line } : {},
+        reason: intent.reason
+      });
+    }
+    for (const [key, intent] of intents) {
+      if (intent.kind === "stay") stayed.push({ key, reason: intent.reason, detail: intent.detail });
+    }
+    if (moved.length > 0 || stayed.length > 0) files.push({ file: page.label, moved, stayed, beyond: page.beyond });
+  }
+  const touches = (m, page) => [...page.intents.values()].some((i) => (i.kind === "in" || i.kind === "out") && i.manifest === m);
+  const manifests = model.manifests.filter(
+    (m) => m.created || m.keysAdded.length > 0 || m.keysRemoved.length > 0 || pages.some((p) => touches(m, p))
+  ).map((m) => {
+    const keys = model.finalKeys(m);
+    return {
+      file: m.file,
+      collection: m.collection,
+      index: m.index,
+      created: m.created,
+      keysAdded: [...m.keysAdded],
+      keysRemoved: [...m.keysRemoved],
+      keys,
+      undeclared: !m.implied && keys.length === 0 && !m.created,
+      beyond: pages.filter(
+        (p) => p.beyond && [...p.intents].some(
+          ([k, i]) => (i.kind === "in" || i.kind === "out") && i.manifest === m || i.kind === "stay" && (m.keysAdded.includes(k) || m.keysRemoved.includes(k))
+        )
+      ).length
+    };
+  });
+  return {
+    dryRun,
+    config: input.config,
+    manifests,
+    files,
+    summary: {
+      files: files.length,
+      moved: files.reduce((n, f) => n + f.moved.length, 0),
+      stayed: files.reduce((n, f) => n + f.stayed.length, 0),
+      manifestsCreated: manifests.filter((m) => m.created).length
+    }
+  };
+}
+async function applyRelocation(ctx, plan, io = {}) {
+  const write = io.write ?? ((path, text) => writeFileAtomic(path, text, { 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) {
+    let now;
+    try {
+      now = await readFile4(w.path, "utf8");
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        throw new DocmetaError(`${label(w)} could not be read: ${errorMessage(err)}`);
+      }
+      now = null;
+    }
+    if (now !== w.before) {
+      throw new DocmetaError(
+        `${label(w)} changed after the relocation was planned, so nothing was written. Run the command again.`
+      );
+    }
+  }
+  const rollBack = async (done, head) => {
+    const failed = [];
+    for (const w of [...done].reverse()) {
+      try {
+        if (w.before === null) await remove(w.path);
+        else await write(w.path, w.before);
+      } catch (err) {
+        failed.push({ file: label(w), reason: errorMessage(err) });
+      }
+    }
+    const [first] = failed;
+    if (first === void 0) {
+      if (done.length === 0) return new DocmetaError(`${head} Nothing was changed.`);
+      const files = done.length === 1 ? "the file already written was" : `the ${String(done.length)} files already written were`;
+      return new DocmetaError(`${head} Nothing was changed: ${files} restored.`);
+    }
+    const one = failed.length === 1;
+    return new DocmetaError(
+      `${head} The run was rolled back, but ${list(failed.map((f) => f.file))} could not be restored: ${first.reason}. Restore ${one ? "it" : "them"} from version control.`
+    );
+  };
+  const written = [];
+  for (const w of plan.writes) {
+    try {
+      await write(w.path, w.text);
+    } catch (err) {
+      throw await rollBack(written, `Could not write ${label(w)}: ${errorMessage(err)}.`);
+    }
+    written.push(w);
+  }
+  if (plan.writes.some((w) => w.kind === "config")) {
+    const narrowed = ctx.collections.length < ctx.declaredCollections.length;
+    for (const next of plan.collections) {
+      const have = ctx.declaredCollections.find((c) => c.name === next.name);
+      if (have !== void 0) {
+        have.paths = next.paths;
+        have.externalMetadata = next.externalMetadata;
+        continue;
+      }
+      ctx.declaredCollections.push(next);
+      if (!narrowed) ctx.collections.push(next);
+    }
+    ctx.configDir ??= plan.configDir;
+    ctx.configPath ??= plan.configPath;
+  }
+  return {
+    ...plan.result,
+    dryRun: false,
+    files: plan.result.files.map((f) => ({
+      ...f,
+      moved: f.moved.map((mv) => {
+        if (mv.to !== "manifest") return mv;
+        const line = plan.lines.get(lineId(f.file, mv.manifest, mv.key));
+        return line === void 0 ? mv : { ...mv, line };
+      })
+    }))
+  };
+}
+function buildOffers(model, pages, result, config) {
+  const names = dedupe(result.manifests.map((m) => m.collection));
+  return names.map((name) => {
+    const manifests = result.manifests.filter((m) => m.collection === name);
+    const outs = pages.flatMap(
+      (p) => [...p.intents].filter(([, i]) => i.kind === "out" && i.manifest.collection === name).map(([k]) => ({ page: p.label, key: k }))
+    );
+    const ins = pages.flatMap(
+      (p) => [...p.intents].filter(([, i]) => i.kind === "in" && i.manifest.collection === name).map(([, i]) => i.kind === "in" ? i.manifest.file : "")
+    );
+    const created = model.created.find((c) => c.name === name);
+    return {
+      collection: name,
+      ...created !== void 0 ? { createsCollection: { paths: [...created.paths] } } : {},
+      pathsAdded: model.pathsAdded.filter((p) => p.collection === name).map((p) => p.path),
+      config,
+      manifests: manifests.map((m) => ({
+        file: m.file,
+        created: m.created,
+        keysAdded: [...m.keysAdded],
+        keysRemoved: [...m.keysRemoved]
+      })),
+      keysOut: dedupe(manifests.flatMap((m) => m.keysAdded)),
+      valuesOut: outs.length,
+      pagesOut: new Set(outs.map((o) => o.page)).size,
+      valuesIn: ins.length,
+      manifestsIn: dedupe(ins)
+    };
+  });
+}
+var count = (n, noun) => `${n} ${noun}${n === 1 ? "" : "s"}`;
+var list = (xs) => xs.join(", ");
+function offerPrompt(offer, kind) {
+  const config = offer.config ?? FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml";
+  if (kind === "validate") {
+    const parts = [];
+    if (offer.valuesOut > 0) {
+      parts.push(
+        `${count(offer.valuesOut, "value")} in ${count(offer.pagesOut, "page")} ${offer.valuesOut === 1 ? "prefers" : "prefer"} external metadata`
+      );
+    }
+    if (offer.valuesIn > 0) {
+      parts.push(
+        `${count(offer.valuesIn, "value")} in ${list(offer.manifestsIn)} ${offer.valuesIn === 1 ? "prefers" : "prefer"} the page`
+      );
+    }
+    const changes = [];
+    if (offer.createsCollection !== void 0) {
+      changes.push(`create collection ${offer.collection} (paths: ${list(offer.createsCollection.paths)})`);
+    }
+    for (const p of offer.pathsAdded) changes.push(`add ${p} to collection ${offer.collection}'s paths`);
+    for (const m of offer.manifests) {
+      if (m.created) changes.push(`create ${m.file}`);
+      if (m.keysRemoved.length > 0) changes.push(`remove ${list(m.keysRemoved)} from ${m.file}'s keys`);
+      if (!m.created && m.keysAdded.length > 0) changes.push(`add ${list(m.keysAdded)} to ${m.file}'s keys`);
+    }
+    return {
+      notice: `in collection ${offer.collection}, ${parts.join(" and ")}.`,
+      question: changes.length === 0 ? "Move them? " : `Move them (${changes.join(", ")})? `
+    };
+  }
+  const keys = list(offer.keysOut);
+  const prefer = offer.keysOut.length === 1 ? "which the schema prefers" : "which their schemas prefer";
+  const move = offer.pagesOut > 0 ? `move them out of ${count(offer.pagesOut, "page")}` : void 0;
+  const tail = (steps2) => {
+    const all = move === void 0 ? steps2 : [...steps2, move];
+    if (all.length === 1) return `${capital(all[0] ?? "")}? `;
+    if (all.length === 2) return `${capital(all[0] ?? "")} and ${all[1] ?? ""}? `;
+    return `${capital(all.slice(0, -1).join(", "))}, and ${all.at(-1) ?? ""}? `;
+  };
+  const created = offer.manifests.find((m) => m.created);
+  if (offer.createsCollection !== void 0) {
+    const make = `Create collection ${offer.collection} (paths: ${list(offer.createsCollection.paths)}), with ${created?.file ?? `${offer.collection}.metadata.yaml`}, in ${config}`;
+    return {
+      notice: `no collection has a manifest for ${keys}, ${prefer} in external metadata.`,
+      question: move === void 0 ? `${make}? ` : `${make}, and ${move}? `
+    };
+  }
+  const steps = offer.pathsAdded.map((p) => `add ${p} to collection ${offer.collection}'s paths`);
+  if (created !== void 0) steps.push(`create ${created.file}`, `add it to ${config}`);
+  for (const m of offer.manifests) {
+    if (!m.created && m.keysAdded.length > 0) steps.push(`add ${list(m.keysAdded)} to ${m.file}'s keys`);
+  }
+  return {
+    notice: `collection ${offer.collection} has no manifest for ${keys}, ${prefer} in external metadata.`,
+    question: tail(steps)
+  };
+}
+function capital(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function relocationOffers(plan) {
+  return plan.offers;
+}
+
+// src/shared/pin.ts
+var LineRangeError = class extends ToolError {
+  constructor(message) {
+    super(message);
+    this.name = "LineRangeError";
+  }
+};
+function normalizeText(text) {
+  const body = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+  return body.replace(/\r\n/g, "\n");
+}
+function splitLines(text) {
+  const parts = normalizeText(text).split("\n");
+  if (parts.length > 0 && parts[parts.length - 1] === "") parts.pop();
+  return parts;
+}
+function sliceLines(lines, range, label) {
+  const start = range?.start;
+  if (start === void 0) return lines.join("\n");
+  const end = range?.end ?? start;
+  if (end < start) {
+    throw new LineRangeError(`${label ?? "the source"} range ${String(start)}-${String(end)} ends before it starts.`);
+  }
+  if (start > lines.length || end > lines.length) {
+    const first = start > lines.length ? start : end;
+    throw new LineRangeError(`${label ?? "the source"} has ${lines.length} lines; line ${first} is out of range.`);
+  }
+  return lines.slice(start - 1, end).join("\n");
+}
+function hashRange(text, range, key) {
+  return hashLines(sliceLines(splitLines(text), range), key);
+}
+function hashLines(joined, key) {
+  return key === void 0 ? integrityOf(Buffer.from(joined, "utf8")) : keyedPin(joined, key);
+}
+function isKeyedPin(pin) {
+  return pin.startsWith(KEYED_PIN_PREFIX);
+}
+function pinOfLines(lines, range) {
+  if (range.start < 1 || range.end > lines.length || range.end < range.start) return void 0;
+  return hashLines(lines.slice(range.start - 1, range.end).join("\n"));
+}
+var MOVE_WINDOW_LINES = 2e3;
+var MOVE_BUDGET_BYTES = 64 * 1024 * 1024;
+var MAX_RANGE_LINES = 5e3;
+function findWindows(lines, length, pin, key, opts) {
+  const starts = [];
+  const lastStart = lines.length - length + 1;
+  if (length < 1 || lastStart < 1) return { starts, truncated: false };
+  const joined = (start) => lines.slice(start - 1, start - 1 + length).join("\n");
+  const original = opts?.original;
+  if (original !== void 0) {
+    const first = original[0];
+    for (let start = 1; start <= lastStart; start++) {
+      if (lines[start - 1] !== first) continue;
+      let same = true;
+      for (let i = 1; i < length; i++) {
+        if (lines[start - 1 + i] !== original[i]) {
+          same = false;
+          break;
+        }
+      }
+      if (same && hashLines(joined(start), key) === pin) starts.push(start);
+    }
+    return { starts, truncated: false };
+  }
+  const counter = opts?.counter;
+  const budget = counter?.left ?? opts?.budget ?? MOVE_BUDGET_BYTES;
+  const around = opts?.around ?? 1;
+  const bandStart = Math.max(1, around - MOVE_WINDOW_LINES);
+  const bandEnd = Math.min(lastStart, around + MOVE_WINDOW_LINES);
+  const order = [];
+  for (let start = bandStart; start <= bandEnd; start++) order.push(start);
+  for (let start = 1; start < bandStart; start++) order.push(start);
+  for (let start = bandEnd + 1; start <= lastStart; start++) order.push(start);
+  let spent = 0;
+  for (const start of order) {
+    const text = joined(start);
+    const bytes = Buffer.byteLength(text, "utf8");
+    if (spent + bytes > budget) {
+      if (counter !== void 0) counter.left = budget - spent;
+      return { starts, truncated: true };
+    }
+    spent += bytes;
+    if (hashLines(text, key) === pin) starts.push(start);
+  }
+  if (counter !== void 0) counter.left = budget - spent;
+  return { starts, truncated: false };
+}
+var RANGE_SPEC = /^([1-9][0-9]*)(?:-([1-9][0-9]*))?$/;
+function parseLines(spec) {
+  if (typeof spec === "number") {
+    return Number.isInteger(spec) && spec >= 1 ? { start: spec, end: spec } : void 0;
+  }
+  const m = RANGE_SPEC.exec(spec);
+  const startText = m?.[1];
+  if (startText === void 0) return void 0;
+  const start = Number(startText);
+  const endText = m?.[2];
+  const end = endText === void 0 ? start : Number(endText);
+  return end < start ? void 0 : { start, end };
+}
+function lineSpec(lines) {
+  return lines.start === lines.end ? lines.start : `${String(lines.start)}-${String(lines.end)}`;
+}
+function spellLines(lines) {
+  return String(lineSpec(lines));
+}
+function toFileLines(lines, bodyLine) {
+  return { start: bodyLine + lines.start - 1, end: bodyLine + lines.end - 1 };
+}
+function toBodyLines(lines, bodyLine) {
+  return { start: lines.start - bodyLine + 1, end: lines.end - bodyLine + 1 };
+}
+function splitPageArgument(arg) {
+  const text = arg.startsWith(STDIN_LINES_MARKER) ? `-${arg.slice(STDIN_LINES_MARKER.length)}` : arg;
+  const m = /:([1-9][0-9]*)(?:-([1-9][0-9]*))?$/.exec(text);
+  const head = m === null ? text : text.slice(0, m.index);
+  if (m === null || head === "") return { page: arg };
+  const start = Number(m[1]);
+  const end = m[2] === void 0 ? start : Number(m[2]);
+  if (end < start) {
+    throw new LineRangeError(`Invalid range "${arg}": end line ${end} is before start line ${start}.`);
+  }
+  return { page: head, lines: { start, end } };
+}
+
+// src/meta/core/derive/provenance.ts
+import picomatch2 from "picomatch";
+var ZERO_SHA = "0000000000000000000000000000000000000000";
+var DEFAULT_MACHINES = ["*[bot]"];
+var PROVENANCE_POINTER = "/provenance";
+function isBlankLine(line) {
+  return (line ?? "").trim() === "";
+}
+function trimBlank(body, span) {
+  let { start, end } = span;
+  while (start <= end && isBlankLine(body[start - 1])) start++;
+  while (end >= start && isBlankLine(body[end - 1])) end--;
+  return start > end ? void 0 : { start, end };
+}
+function blankEdges(body, span) {
+  const first = isBlankLine(body[span.start - 1]);
+  const last = isBlankLine(body[span.end - 1]);
+  if (!first && !last) return void 0;
+  if (trimBlank(body, span) === void 0) return "only";
+  return first && last ? "both" : first ? "start" : "end";
+}
+var PLAIN_PIN = /^sha256-[0-9a-f]{64}$/;
+function provenanceEntries(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const item of value) {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) continue;
+    const record = item;
+    const machine = record["generated-by"];
+    const lines = record.lines;
+    const integrity = record.integrity;
+    if (typeof machine !== "string" || machine === "") continue;
+    if (typeof lines !== "string" && typeof lines !== "number") continue;
+    if (parseLines(lines) === void 0) continue;
+    if (typeof integrity !== "string" || !PLAIN_PIN.test(integrity)) continue;
+    out.push({ ...record, "generated-by": machine, lines, integrity });
+  }
+  return out;
+}
+function readProvenancePage(content, opts) {
+  const lines = splitLines(content);
+  const loc = opts?.fenced === false ? null : locateFrontmatter(content);
+  if (loc === null) return { lines, bodyLine: 1, body: lines, stamp: [] };
+  const head = content.slice(0, loc.closeEnd);
+  const newlines = head.split("\n").length - 1;
+  const bodyLine = newlines + (head.endsWith("\n") ? 1 : 2);
+  let stamp = [];
+  try {
+    stamp = provenanceEntries(extractFrontmatter(content, "markdown").data.provenance);
+  } catch {
+    stamp = [];
+  }
+  return { lines, bodyLine, body: lines.slice(bodyLine - 1), stamp };
+}
+var HEADER = /^([0-9a-f]{40}(?:[0-9a-f]{24})?) ([1-9][0-9]*) ([1-9][0-9]*)(?: ([1-9][0-9]*))?$/;
+var ALL_ZERO = /^0+$/;
+function parseLinePorcelain(text) {
+  const rows = text.split("\n");
+  if (rows.length > 0 && rows[rows.length - 1] === "") rows.pop();
+  const out = [];
+  let i = 0;
+  while (i < rows.length) {
+    const headerRow = rows[i] ?? "";
+    const m = HEADER.exec(headerRow);
+    const sha = m?.[1];
+    const orig = m?.[2];
+    const final = m?.[3];
+    if (sha === void 0 || orig === void 0 || final === void 0) {
+      throw new Error(`porcelain: expected a header at row ${i + 1}, got ${JSON.stringify(headerRow)}`);
+    }
+    const finalLine = Number(final);
+    const count2 = m?.[4];
+    const fields = /* @__PURE__ */ new Map();
+    i++;
+    for (let row = rows[i]; row !== void 0 && !row.startsWith("	"); row = rows[i]) {
+      const space2 = row.indexOf(" ");
+      if (space2 === -1) fields.set(row, true);
+      else fields.set(row.slice(0, space2), row.slice(space2 + 1));
+      i++;
+    }
+    const contentRow = rows[i];
+    if (contentRow === void 0) throw new Error(`porcelain: line ${finalLine} has no content row`);
+    const author = fields.get("author");
+    const filename = fields.get("filename");
+    if (typeof author !== "string" || typeof filename !== "string") {
+      throw new Error(`porcelain: line ${finalLine} has no full header; run blame with --line-porcelain`);
+    }
+    const mail = fields.get("author-mail");
+    const previous = fields.get("previous");
+    const space = typeof previous === "string" ? previous.indexOf(" ") : -1;
+    out.push({
+      sha,
+      origLine: Number(orig),
+      finalLine,
+      ...count2 !== void 0 ? { groupCount: Number(count2) } : {},
+      author,
+      authorMail: typeof mail === "string" ? mail.replace(/^<(.*)>$/, "$1") : "",
+      filename,
+      ...typeof previous === "string" && space !== -1 ? { previous: { sha: previous.slice(0, space), filename: previous.slice(space + 1) } } : {},
+      boundary: fields.get("boundary") === true,
+      uncommitted: ALL_ZERO.test(sha),
+      content: contentRow.slice(1)
+    });
+    i++;
+  }
+  return out;
+}
+var IDENTITY_GLOB = { literalBrackets: true, dot: true, bash: true };
+function machineIdentity(value, machines) {
+  const m = /^(.*?)\s*<([^>]*)>\s*$/.exec(value);
+  const name = m === null ? value.trim() : m[1] ?? "";
+  const email = m === null ? "" : m[2] ?? "";
+  const match = (s) => s !== "" && machines.some((glob) => picomatch2.isMatch(s, glob, IDENTITY_GLOB));
+  if (!match(name) && !match(email)) return void 0;
+  return name !== "" ? name : email;
+}
+function stampEvidence(commit, origLine, fenced) {
+  const stamps = verifiedStamps(commit, fenced);
+  if (stamps === void 0) return void 0;
+  const body = origLine - stamps.bodyLine + 1;
+  if (body < 1) return void 0;
+  return stamps.entries.find((entry) => body >= entry.start && body <= entry.end)?.generatedBy;
+}
+function carriesStamp(commit, fenced) {
+  return (verifiedStamps(commit, fenced)?.entries.length ?? 0) > 0;
+}
+function verifiedStamps(commit, fenced) {
+  if (commit.blob === void 0) return void 0;
+  const memo = fenced === false ? stampsUnfenced : stampsFenced;
+  const known = memo.get(commit);
+  if (known !== void 0) return known;
+  const page = readProvenancePage(commit.blob, fenced === void 0 ? void 0 : { fenced });
+  const entries = [];
+  for (const entry of commit.stamp === void 0 ? page.stamp : provenanceEntries(commit.stamp)) {
+    const span = parseLines(entry.lines);
+    if (span !== void 0 && pinOfLines(page.body, span) === entry.integrity) {
+      entries.push({ start: span.start, end: span.end, generatedBy: entry["generated-by"] });
+    }
+  }
+  const stamps = { bodyLine: page.bodyLine, entries };
+  memo.set(commit, stamps);
+  return stamps;
+}
+var stampsFenced = /* @__PURE__ */ new WeakMap();
+var stampsUnfenced = /* @__PURE__ */ new WeakMap();
+function recordedEvidence(line, ctx) {
+  if (line.uncommitted) return { rule: 5, sha: line.sha };
+  const commit = ctx.commits.get(line.sha);
+  if (commit === void 0) throw new Error(`no commit ${line.sha}`);
+  const stamped = stampEvidence(commit, line.origLine, ctx.fenced);
+  if (stamped !== void 0) return { machine: stamped, rule: 2, sha: line.sha };
+  if (carriesStamp(commit, ctx.fenced)) return { rule: 5, sha: line.sha };
+  const generated = commit.trailers.generatedBy.map((v) => v.trim()).find((v) => v !== "");
+  if (generated !== void 0) return { machine: generated, rule: 3, sha: line.sha };
+  for (const value of commit.trailers.coAuthoredBy) {
+    const machine = machineIdentity(value.trim(), ctx.machines);
+    if (machine !== void 0) return { machine, rule: 4, sha: line.sha };
+  }
+  return { rule: 5, sha: line.sha };
+}
+function resolveLineEvidence(line, ctx) {
+  if (line.uncommitted && ctx.generatedBy !== void 0 && ctx.generatedBy !== "") {
+    return { machine: ctx.generatedBy, rule: 1, sha: line.sha };
+  }
+  return recordedEvidence(line, ctx);
+}
+function pinOf(lines, span) {
+  const pin = pinOfLines(lines, span);
+  if (pin === void 0) throw new Error(`provenance: lines ${spellLines(span)} fall outside the body`);
+  return pin;
+}
+function contextOf(input) {
+  return {
+    commits: input.commits,
+    machines: input.machines ?? DEFAULT_MACHINES,
+    ...input.generatedBy !== void 0 ? { generatedBy: input.generatedBy } : {},
+    ...input.fenced !== void 0 ? { fenced: input.fenced } : {}
+  };
+}
+function readOptions(fenced) {
+  return fenced === void 0 ? void 0 : { fenced };
+}
+function deriveProvenance(input) {
+  const page = readProvenancePage(input.content, readOptions(input.fenced));
+  const ctx = contextOf(input);
+  const evidenceByLine = /* @__PURE__ */ new Map();
+  for (const line of input.blame) {
+    const body = line.finalLine - page.bodyLine + 1;
+    if (body < 1) continue;
+    if (isBlankLine(page.body[body - 1])) continue;
+    evidenceByLine.set(body, resolveLineEvidence(line, ctx));
+  }
+  const groups = [];
+  let open;
+  for (let n = 1; n <= page.body.length; n++) {
+    if (isBlankLine(page.body[n - 1])) continue;
+    const evidence = evidenceByLine.get(n);
+    const machine = evidence?.machine;
+    if (open !== void 0 && machine !== void 0 && machine === open.machine) {
+      open.end = n;
+      continue;
+    }
+    if (open !== void 0) groups.push(open);
+    open = machine === void 0 || evidence === void 0 ? void 0 : { machine, start: n, end: n, first: evidence };
+  }
+  if (open !== void 0) groups.push(open);
+  return {
+    page,
+    evidenceByLine,
+    derived: groups.map((g) => {
+      const span = { start: g.start, end: g.end };
+      return {
+        entry: { "generated-by": g.machine, lines: lineSpec(span), integrity: pinOf(page.body, span) },
+        span,
+        evidence: g.first
+      };
+    })
+  };
+}
+function nearest(candidates, recorded) {
+  let best;
+  for (const c of candidates) {
+    const d = Math.abs(c.span.start - recorded.start);
+    if (best === void 0 || d < best.d || d === best.d && c.span.start < best.c.span.start) best = { c, d };
+  }
+  return best?.c;
+}
+var sameSpan = (a, b) => a.start === b.start && a.end === b.end;
+function scanEvidence(evidenceByLine, span, machine) {
+  let anyMachine = false;
+  for (let n = span.start; n <= span.end; n++) {
+    const evidence = evidenceByLine.get(n);
+    if (evidence?.machine === void 0) continue;
+    anyMachine = true;
+    if (evidence.machine !== machine) return { contradiction: evidence, anyMachine };
+  }
+  return { anyMachine };
+}
+function compareProvenance(stamped, derivation) {
+  const { page, evidenceByLine, derived } = derivation;
+  const claimed = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const entry of provenanceEntries(stamped)) {
+    const recorded = parseLines(entry.lines);
+    if (recorded === void 0) continue;
+    const machine = entry["generated-by"];
+    const takenHere = [...claimed].some((d) => sameSpan(d.span, recorded));
+    if (!takenHere && pinOfLines(page.body, recorded) === entry.integrity) {
+      const here = scanEvidence(evidenceByLine, recorded, machine);
+      const blank2 = blankEdges(page.body, recorded);
+      if (here.contradiction === void 0 && blank2 !== void 0) {
+        results.push({ status: "stale", entry, span: recorded, blank: blank2 });
+        continue;
+      }
+      if (here.contradiction === void 0) {
+        const exact = derived.find(
+          (d) => !claimed.has(d) && sameSpan(d.span, recorded) && d.entry.integrity === entry.integrity
+        );
+        if (exact !== void 0) claimed.add(exact);
+        results.push({ status: "current", entry, span: recorded, ...here.anyMachine ? {} : { noEvidence: true } });
+        continue;
+      }
+    }
+    const pool = derived.filter((d) => !claimed.has(d) && d.entry.integrity === entry.integrity);
+    const hit = nearest(pool, recorded);
+    if (hit !== void 0) {
+      claimed.add(hit);
+      if (hit.entry["generated-by"] !== machine) {
+        results.push({ status: "stale", entry, span: hit.span, evidence: hit.evidence });
+      } else {
+        results.push({ status: sameSpan(hit.span, recorded) ? "current" : "moved", entry, span: hit.span });
+      }
+      continue;
+    }
+    const width = recorded.end - recorded.start + 1;
+    const claimedSpans = [...claimed].map((d) => d.span);
+    const windows = findWindows(page.body, width, entry.integrity, void 0, { around: recorded.start, budget: Infinity }).starts.map((start) => ({ span: { start, end: start + width - 1 } })).filter((w) => !claimedSpans.some((s) => sameSpan(s, w.span)));
+    const found = nearest(windows, recorded);
+    if (found === void 0) {
+      results.push({ status: "changed", entry, span: recorded });
+      continue;
+    }
+    const { contradiction, anyMachine } = scanEvidence(evidenceByLine, found.span, machine);
+    if (contradiction !== void 0) {
+      results.push({ status: "stale", entry, span: found.span, evidence: contradiction });
+      continue;
+    }
+    const blank = blankEdges(page.body, found.span);
+    if (blank !== void 0) {
+      results.push({ status: "stale", entry, span: found.span, blank });
+      continue;
+    }
+    results.push({
+      status: sameSpan(found.span, recorded) ? "current" : "moved",
+      entry,
+      span: found.span,
+      ...anyMachine ? {} : { noEvidence: true }
+    });
+  }
+  const covering = results.map((r) => r.span);
+  for (const d of derived) {
+    if (claimed.has(d)) continue;
+    let uncovered = false;
+    for (let n = d.span.start; n <= d.span.end && !uncovered; n++) {
+      if (isBlankLine(page.body[n - 1])) continue;
+      uncovered = !covering.some((s) => n >= s.start && n <= s.end);
+    }
+    if (uncovered) results.push({ status: "unset", entry: d.entry, span: d.span, evidence: d.evidence });
+  }
+  return results;
+}
+function planProvenanceWrite(comparisons, derivation) {
+  const { body } = derivation.page;
+  const same = (a, b) => a["generated-by"] === b["generated-by"] && String(a.lines) === String(b.lines) && a.integrity === b.integrity;
+  const kept = [];
+  const keep = (entry, span) => {
+    if (!kept.some((k) => same(k.entry, entry))) kept.push({ entry, span });
+  };
+  for (const r of comparisons) {
+    if (r.status === "current") keep(r.entry, r.span);
+    else if (r.status === "moved") keep({ ...r.entry, lines: lineSpec(r.span) }, r.span);
+    else if (r.status === "stale" && r.blank !== void 0) {
+      const span = trimBlank(body, r.span);
+      if (span !== void 0) keep({ ...r.entry, lines: lineSpec(span), integrity: pinOf(body, span) }, span);
+    }
+  }
+  const outside = (k, d) => {
+    if (k.span.end < d.start || k.span.start > d.end) return [k];
+    const pieces = [];
+    if (k.span.start < d.start) pieces.push({ start: k.span.start, end: d.start - 1 });
+    if (k.span.end > d.end) pieces.push({ start: d.end + 1, end: k.span.end });
+    return pieces.flatMap((piece) => {
+      const span = trimBlank(body, piece);
+      if (span === void 0) return [];
+      return [{ entry: { ...k.entry, lines: lineSpec(span), integrity: pinOf(body, span) }, span }];
+    });
+  };
+  let out = [...kept];
+  const derived = /* @__PURE__ */ new Set();
+  for (const d of derivation.derived) {
+    if (kept.some((k) => same(k.entry, d.entry))) continue;
+    out = out.flatMap((k) => derived.has(k) ? [k] : outside(k, d.span));
+    const written = { entry: d.entry, span: d.span };
+    derived.add(written);
+    out.push(written);
+  }
+  const unique = [];
+  for (const k of out) if (!unique.some((u) => same(u.entry, k.entry))) unique.push(k);
+  return unique.sort((a, b) => a.span.start - b.span.start).map((k) => k.entry);
+}
+var short = (sha) => sha.slice(0, 7);
+function fileSpelling(span, bodyLine) {
+  return spellLines(toFileLines(span, bodyLine));
+}
+function evidenceText(evidence) {
+  if (evidence?.machine === void 0) return "pin";
+  return evidence.rule === 1 ? "uncommitted" : `blame ${short(evidence.sha)}`;
+}
+function evidenceRef(evidence) {
+  if (evidence === void 0) return "no evidence";
+  return evidence.rule === 1 ? "uncommitted" : short(evidence.sha);
+}
+function rangeResults(comparisons, bodyLine) {
+  return comparisons.map((r) => {
+    const lines = fileSpelling(r.span, bodyLine);
+    const recorded = parseLines(r.entry.lines);
+    const from = recorded === void 0 ? void 0 : fileSpelling(recorded, bodyLine);
+    const machine = r.entry["generated-by"];
+    switch (r.status) {
+      case "stale":
+        return {
+          lines,
+          "generated-by": r.evidence?.machine ?? machine,
+          integrity: r.entry.integrity,
+          status: r.status,
+          evidence: evidenceText(r.evidence),
+          ...from !== void 0 ? { from: { lines: from, "generated-by": machine } } : {},
+          written: false
+        };
+      case "moved":
+        return {
+          lines,
+          "generated-by": machine,
+          integrity: r.entry.integrity,
+          status: r.status,
+          evidence: "pin",
+          ...from !== void 0 ? { from: { lines: from, "generated-by": machine } } : {},
+          written: false
+        };
+      case "unset":
+        return { lines, "generated-by": machine, integrity: r.entry.integrity, status: r.status, evidence: evidenceText(r.evidence), written: false };
+      case "current":
+      case "changed":
+        return { lines, "generated-by": machine, integrity: r.entry.integrity, status: r.status, evidence: "pin", written: false };
+    }
+  });
+}
+var BLANK_WORDS = {
+  only: "hold only blank lines",
+  start: "start on a blank line",
+  end: "end on a blank line",
+  both: "start and end on blank lines"
+};
+function provenanceFindings(comparisons, bodyLine) {
+  const findings = [];
+  for (const r of comparisons) {
+    const machine = r.entry["generated-by"];
+    const lines = fileSpelling(r.span, bodyLine);
+    let message;
+    switch (r.status) {
+      case "changed":
+        message = `provenance lines ${lines} changed since ${machine} wrote them`;
+        break;
+      case "stale":
+        message = r.blank !== void 0 ? `provenance lines ${lines} say ${machine} but ${BLANK_WORDS[r.blank]}` : `provenance lines ${lines} say ${machine}; blame says ${r.evidence?.machine ?? "another machine"} (${evidenceRef(r.evidence)})`;
+        break;
+      case "unset":
+        message = `provenance is unset for lines ${lines}; blame says ${machine} (${evidenceRef(r.evidence)})`;
+        break;
+      case "current":
+      case "moved":
+        continue;
+    }
+    findings.push({
+      schema: DERIVED_STALE_SCHEMA,
+      keyword: DERIVED_KEYWORD,
+      subject: `provenance ${r.entry.integrity}`,
+      instancePath: PROVENANCE_POINTER,
+      message: `${message} \u2014 run manni meta derive`,
+      line: toFileLines(r.span, bodyLine).start
+    });
+  }
+  return findings;
+}
+function renderProvenanceValue(entries, bodyLine) {
+  return entries.map((e) => {
+    const span = parseLines(e.lines);
+    const lines = span === void 0 ? String(e.lines) : fileSpelling(span, bodyLine);
+    return `lines ${lines} ${e["generated-by"]}`;
+  }).join("; ");
+}
+function parseProvenanceTarget(arg) {
+  try {
+    return splitPageArgument(arg);
+  } catch (err) {
+    if (err instanceof LineRangeError) throw new DocmetaError(`${arg} ends before it starts.`);
+    throw err;
+  }
+}
+function attributeRange(input) {
+  const { target } = input;
+  const { page: path, lines: range } = parseProvenanceTarget(target);
+  if (range === void 0) throw new Error(`provenance: ${target} names no lines`);
+  const page = input.page ?? readProvenancePage(input.content, readOptions(input.fenced));
+  if (range.end > page.lines.length) {
+    throw new DocmetaError(
+      `${path} has no lines ${spellLines(range)}: the file ends at line ${page.lines.length}.`
+    );
+  }
+  if (range.start < page.bodyLine) {
+    throw new DocmetaError(
+      `${target} reaches into the frontmatter; provenance pins body lines, which start at line ${page.bodyLine}.`
+    );
+  }
+  const ctx = contextOf(input);
+  for (const line of input.blame) {
+    if (line.finalLine < range.start || line.finalLine > range.end) continue;
+    if (isBlankLine(page.lines[line.finalLine - 1])) continue;
+    const evidence = recordedEvidence(line, ctx);
+    if (evidence.machine !== void 0 && evidence.machine !== input.generatedBy) {
+      throw new DocmetaError(
+        `${target}: blame attributes these lines to ${evidence.machine} (${short(evidence.sha)}); --generated-by cannot overrule a recorded machine.`
+      );
+    }
+  }
+  const span = trimBlank(page.body, toBodyLines(range, page.bodyLine));
+  if (span === void 0) return void 0;
+  return { "generated-by": input.generatedBy, lines: lineSpec(span), integrity: pinOf(page.body, span) };
+}
+
+export {
+  writeTextAtomic,
+  ENCRYPTION_KEY_ENV,
+  resolveEncryptionKey,
+  writeEncryptionKey,
+  isIgnoredByGit,
+  committedKeyWarning,
+  heldManifest,
+  rebaseable,
+  rebaseline,
+  settle,
+  isMissing,
+  readManifestOrEmpty,
+  EXTERNAL_METADATA_FETCH_TIMEOUT_MS,
+  EXTERNAL_METADATA_FETCH_MAX_BYTES,
+  fetchExternalMetadata,
+  ENCRYPTED_PLACEHOLDER,
+  META_CONTEXT,
+  EncryptionRefusal,
+  unreadableMessage,
+  unverifiedWarning,
+  lazyKey,
+  pointerOf,
+  topLevelKeyOf,
+  isAtOrUnder,
+  valueAt,
+  withValueAt,
+  encryptionView,
+  settleFindings,
+  encryptionFindings,
+  redactForModel,
+  redactedDerived,
+  EXTERNAL_OWNED_SCHEMA,
+  EXTERNAL_DUPLICATE_SCHEMA,
+  EXTERNAL_KEYWORD,
+  PATH_JOIN,
+  reportedPath,
+  externalMetadataJoin,
+  loadExternalMetadata,
+  outsideRefusal,
+  mergeExternalMetadata,
+  mergeWithMarks,
+  externalMetadataPointer,
+  orphanEntries,
+  orphanJoins,
+  orphanError,
+  pageOwners,
+  LOCATION_KEYWORD,
+  LOCATION_EXTERNAL_SCHEMA,
+  LOCATION_PAGE_SCHEMA,
+  LOCATION_FINDING_KEYWORD,
+  GRAPH_OUTPUT_KEYWORD,
+  compileWithFormats,
+  stringFormatNames,
+  validatesFormat,
+  Validator,
+  pageMarks,
+  pageClaims,
+  pageSchemaSet,
+  marksValidator,
+  configMarks,
+  metaSection,
+  familyMarks,
+  SYSTEM_COLUMNS,
+  RESERVED,
+  quoteIdent,
+  bindValue,
+  corpusDataColumns,
+  createDocsTable,
+  registerLineFor,
+  assertSingleStatement,
+  startsStringOrIdent,
+  startsComment,
+  skipStringOrIdent,
+  skipComment,
+  isParamName,
+  collectNamedParameters,
+  stripLeadingTrivia,
+  loadSqlite,
+  memberOf,
+  retainMembers,
+  collectionNames,
+  collectCollections,
+  createCollectionViews,
+  spliceManifestValue,
+  readManifestValue,
+  removeManifestKey,
+  renameManifestEntry,
+  relocateFailed,
+  relocationContext,
+  keyHome,
+  planRelocation,
+  applyRelocation,
+  offerPrompt,
+  relocationOffers,
+  LineRangeError,
+  normalizeText,
+  splitLines,
+  sliceLines,
+  hashRange,
+  hashLines,
+  isKeyedPin,
+  pinOfLines,
+  MOVE_WINDOW_LINES,
+  MOVE_BUDGET_BYTES,
+  MAX_RANGE_LINES,
+  findWindows,
+  parseLines,
+  lineSpec,
+  spellLines,
+  toFileLines,
+  toBodyLines,
+  splitPageArgument,
+  ZERO_SHA,
+  DEFAULT_MACHINES,
+  provenanceEntries,
+  readProvenancePage,
+  parseLinePorcelain,
+  machineIdentity,
+  deriveProvenance,
+  compareProvenance,
+  planProvenanceWrite,
+  rangeResults,
+  provenanceFindings,
+  renderProvenanceValue,
+  parseProvenanceTarget,
+  attributeRange
+};
+//# sourceMappingURL=chunk-RLR4TKUZ.js.map