@hawkeyexl/manni 4.0.3 → 4.1.0

package/dist/{chunk-TQG3WCJY.js → chunk-I57KBF45.js}

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 // package.json
 var package_default = {
   name: "@hawkeyexl/manni",
-  version: "4.0.3",
+  version: "4.1.0",
   description: "One command line for documentation that is meant to be checked. `manni meta` validates the presence and format of document metadata (Markdown frontmatter and more) against JSON Schema, built for CI. Formerly docmeta.",
   type: "module",
   bin: {
@@ -63,6 +63,7 @@ var package_default = {
     "docs:check-action": "node scripts/check-action-reference.mjs",
     "docs:check-api": "node scripts/check-api-reference.mjs",
     "docs:check-links": "node scripts/check-doc-links.mjs",
+    "docs:check-docevals": "node dist/cli.js docevals run --deterministic-only --no-generate",
     "docs:check-tables": "node scripts/check-table-rows.mjs",
     "docs:check-versions": "node scripts/check-versions.mjs",
     "docs:sync-versions": "node scripts/sync-versions.mjs",
@@ -92,7 +93,7 @@ var package_default = {
     "@apidevtools/json-schema-ref-parser": "^11.9.3",
     "@asciidoctor/core": "^3.0.4",
     "@axe-core/playwright": "^4.13.0",
-    "@hawkeyexl/inference": "^0.3.2",
+    "@hawkeyexl/inference": "^0.4.0",
     "@xmldom/xmldom": "^0.9.12",
     ajv: "^8.17.1",
     "ajv-draft-04": "^1.0.0",
@@ -137,6 +138,14 @@ var package_default = {
     typescript: "^6.0.3",
     "typescript-eslint": "^8.68.0",
     vitest: "^4.1.11"
+  },
+  peerDependencies: {
+    "node-llama-cpp": "^3.19.0"
+  },
+  peerDependenciesMeta: {
+    "node-llama-cpp": {
+      optional: true
+    }
   }
 };
 
@@ -3232,8 +3241,8 @@ 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((resolve25) => {
-  setTimeout(resolve25, ms);
+var wait = (ms) => new Promise((resolve26) => {
+  setTimeout(resolve26, ms);
 });
 async function writeFileAtomic(path, contents, options = {}) {
   const tmp = join(
@@ -8578,8 +8587,8 @@ var SCHEMA_KEYS = [
   "multipleOf"
 ];
 var RETRY_DELAY_MS = 500;
-var wait2 = (ms) => new Promise((resolve25) => {
-  setTimeout(resolve25, ms);
+var wait2 = (ms) => new Promise((resolve26) => {
+  setTimeout(resolve26, ms);
 });
 var RetryableFetchError = class extends DocmetaError {
 };
@@ -9146,12 +9155,12 @@ function isPlainObject(v) {
 }
 
 // src/meta/core/config.ts
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 import { parse as parseYaml2 } from "yaml";
 
 // src/shared/config-file.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname3, join as join4, relative as relative3, resolve as resolve6 } from "node:path";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { basename as basename2, dirname as dirname3, join as join4, relative as relative3, resolve as resolve7 } from "node:path";
 import { parse as parseYaml } from "yaml";
 
 // src/shared/encryption.ts
@@ -9280,11 +9289,218 @@ function keyedPin(text2, key) {
   return `${KEYED_PIN_PREFIX}${mac}`;
 }
 
+// src/shared/providers.ts
+import { resolve as resolve4 } from "node:path";
+import {
+  DEFAULT_MODELS,
+  DEFAULT_OPENAI_BASE_URL,
+  InferenceError,
+  resolveProviderIdentityAsync
+} from "@hawkeyexl/inference";
+var DEFAULT_PROVIDER = "auto";
+var PROVIDERS = /* @__PURE__ */ new Set([
+  ...Object.keys(DEFAULT_MODELS),
+  DEFAULT_PROVIDER
+]);
+var NAMEABLE_PROVIDERS = Object.keys(DEFAULT_MODELS).filter(
+  (name2) => name2 !== "mock"
+);
+function assertKnownProvider(name2, toError) {
+  if (PROVIDERS.has(name2)) return;
+  throw toError(
+    `Unknown provider "${name2}". Available: ${[...NAMEABLE_PROVIDERS, DEFAULT_PROVIDER].join(", ")}.`
+  );
+}
+function assertModelHasProvider(name2, model, configKey, toError) {
+  if (name2 !== DEFAULT_PROVIDER || model == null) return;
+  throw toError(
+    `Model "${model}" was given without a provider: a model name does not say which provider owns it. Set --provider or ${configKey} to one of ${NAMEABLE_PROVIDERS.join(", ")}, or drop the model to take the detected provider's default.`
+  );
+}
+var PROVIDERS_KEY = "providers";
+var CONNECTION_KEYS = {
+  anthropic: ["apiKeyEnv"],
+  openai: ["baseUrl", "apiKeyEnv"],
+  "claude-cli": ["command"],
+  "llama-cpp": ["modelsDir", "thoughtTokens"]
+};
+var CONNECTION_NAMES = Object.keys(CONNECTION_KEYS);
+var TOP_LEVEL_KEYS = ["provider", "model", ...CONNECTION_NAMES];
+function isMapping2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rejectUnknown(raw, allowed, label, source, toError) {
+  for (const key of Object.keys(raw)) {
+    if (!allowed.includes(key)) {
+      throw toError(
+        `${source}: "${label}" has unknown key "${key}". Supported keys: ${allowed.join(", ")}.`
+      );
+    }
+  }
+}
+function parseProviders(value, source, dir, toError) {
+  if (value == null) return {};
+  if (!isMapping2(value)) {
+    throw toError(`${source}: "${PROVIDERS_KEY}" must be a mapping.`);
+  }
+  rejectUnknown(value, TOP_LEVEL_KEYS, PROVIDERS_KEY, source, toError);
+  const string = (raw, key, label) => {
+    const v = raw[key];
+    if (v === void 0) return void 0;
+    if (typeof v !== "string") {
+      throw toError(`${source}: "${label}" must be a string.`);
+    }
+    return v;
+  };
+  const parsed2 = {};
+  const provider = string(value, "provider", `${PROVIDERS_KEY}.provider`);
+  if (provider !== void 0) {
+    assertKnownProvider(provider, (message) => toError(`${source}: ${message}`));
+    parsed2.provider = provider;
+  }
+  const model = string(value, "model", `${PROVIDERS_KEY}.model`);
+  if (model !== void 0) {
+    if (provider === void 0 || provider === DEFAULT_PROVIDER) {
+      throw toError(
+        `${source}: "${PROVIDERS_KEY}.model" was given without a provider: a model name does not say which provider owns it. Set ${PROVIDERS_KEY}.provider to one of ${NAMEABLE_PROVIDERS.join(", ")}, or drop the model to take the detected provider's default.`
+      );
+    }
+    parsed2.model = model;
+  }
+  for (const name2 of CONNECTION_NAMES) {
+    const section = value[name2];
+    if (section == null) continue;
+    const label = `${PROVIDERS_KEY}.${name2}`;
+    if (!isMapping2(section)) {
+      throw toError(`${source}: "${label}" must be a mapping.`);
+    }
+    rejectUnknown(section, CONNECTION_KEYS[name2], label, source, toError);
+    const field = (key) => string(section, key, `${label}.${key}`);
+    switch (name2) {
+      case "anthropic": {
+        const apiKeyEnv = field("apiKeyEnv");
+        parsed2.anthropic = apiKeyEnv === void 0 ? {} : { apiKeyEnv };
+        break;
+      }
+      case "openai": {
+        const baseUrl = field("baseUrl");
+        const apiKeyEnv = field("apiKeyEnv");
+        parsed2.openai = {
+          ...baseUrl !== void 0 ? { baseUrl } : {},
+          ...apiKeyEnv !== void 0 ? { apiKeyEnv } : {}
+        };
+        break;
+      }
+      case "claude-cli": {
+        const command = field("command");
+        parsed2["claude-cli"] = command === void 0 ? {} : { command };
+        break;
+      }
+      case "llama-cpp": {
+        const modelsDir = field("modelsDir");
+        const thoughtTokens = section["thoughtTokens"];
+        if (thoughtTokens !== void 0 && (typeof thoughtTokens !== "number" || !Number.isInteger(thoughtTokens) || thoughtTokens < 0)) {
+          throw toError(
+            `${source}: "${label}.thoughtTokens" must be a whole number of 0 or more, got ${JSON.stringify(thoughtTokens)}.`
+          );
+        }
+        parsed2["llama-cpp"] = {
+          ...modelsDir !== void 0 ? { modelsDir: resolve4(dir, modelsDir) } : {},
+          ...thoughtTokens !== void 0 ? { thoughtTokens } : {}
+        };
+        break;
+      }
+    }
+  }
+  return parsed2;
+}
+var LOCAL_PROVIDER = "llama-cpp";
+var LOCAL_FLAG_HELP = "run inference on this machine (llama-cpp); overrides any configured or eval-level provider";
+var LOCAL_COMPATIBLE = /* @__PURE__ */ new Set([LOCAL_PROVIDER, DEFAULT_PROVIDER, "mock"]);
+function assertLocalFlag(flag, toError) {
+  if (flag.local !== true || flag.provider === void 0) return;
+  assertKnownProvider(flag.provider, toError);
+  if (LOCAL_COMPATIBLE.has(flag.provider)) return;
+  throw toError(
+    `--local and --provider ${flag.provider} contradict each other: --local runs inference on this machine with ${LOCAL_PROVIDER}. Drop one of them.`
+  );
+}
+function selectProvider(flag, levels) {
+  if (flag.local === true) return selectLocal(flag, levels);
+  const provider = flag.provider ?? levels.find((level) => level.provider !== void 0)?.provider ?? DEFAULT_PROVIDER;
+  const model = flag.model ?? levels.find(
+    (level) => level.model !== void 0 && (level.provider === void 0 || level.provider === provider)
+  )?.model;
+  return { provider, model };
+}
+function selectLocal(flag, levels) {
+  const provider = flag.provider === "mock" ? "mock" : LOCAL_PROVIDER;
+  const model = flag.model ?? levels.find((level) => level.model !== void 0 && level.provider === provider)?.model;
+  const chosen = flag.provider === void 0 ? levels.find((level) => level.provider !== void 0) : void 0;
+  const replaced = chosen?.provider !== void 0 && chosen.origin !== void 0 && chosen.provider !== provider && chosen.provider !== DEFAULT_PROVIDER ? { provider: chosen.provider, source: chosen.origin } : void 0;
+  return replaced === void 0 ? { provider, model } : { provider, model, replaced };
+}
+function localNotice(selection) {
+  const { replaced } = selection;
+  if (replaced === void 0) return void 0;
+  return `--local: using ${LOCAL_PROVIDER} instead of "${replaced.provider}" from ${replaced.source}.`;
+}
+function providerSpecFor(connections, selection) {
+  const { provider, model } = selection;
+  const local = connections["llama-cpp"] ?? {};
+  const llamaCpp = {
+    thoughtTokens: local.thoughtTokens ?? 0,
+    ...local.modelsDir !== void 0 ? { modelsDirectory: local.modelsDir } : {}
+  };
+  switch (provider) {
+    case "anthropic":
+      return {
+        provider,
+        model,
+        apiKeyEnv: connections.anthropic?.apiKeyEnv ?? "ANTHROPIC_API_KEY"
+      };
+    case "openai":
+      return {
+        provider,
+        model,
+        apiKeyEnv: connections.openai?.apiKeyEnv ?? "OPENAI_API_KEY",
+        baseUrl: connections.openai?.baseUrl ?? DEFAULT_OPENAI_BASE_URL
+      };
+    case "claude-cli":
+      return { provider, model, command: connections["claude-cli"]?.command ?? "claude" };
+    case "llama-cpp":
+      return { provider, model, llamaCpp };
+    case "mock":
+      return { provider, model };
+    case "auto": {
+      const baseUrl = connections.openai?.baseUrl;
+      const command = connections["claude-cli"]?.command;
+      const configuredLocal = local.thoughtTokens !== void 0 || local.modelsDir !== void 0;
+      return {
+        provider,
+        model,
+        ...baseUrl !== void 0 ? { baseUrl } : {},
+        ...command !== void 0 ? { command } : {},
+        ...configuredLocal ? { llamaCpp } : {}
+      };
+    }
+  }
+}
+async function resolveIdentity(spec, toError) {
+  try {
+    return await resolveProviderIdentityAsync(spec);
+  } catch (err) {
+    throw toError(
+      err instanceof InferenceError ? err.message : `Could not resolve provider "${String(spec.provider)}": ${errorMessage(err)}`
+    );
+  }
+}
+
 // src/shared/git-root.ts
 import { existsSync } from "node:fs";
-import { dirname as dirname2, join as join3, resolve as resolve4 } from "node:path";
+import { dirname as dirname2, join as join3, resolve as resolve5 } from "node:path";
 function findGitRoot(cwd) {
-  let dir = resolve4(cwd);
+  let dir = resolve5(cwd);
   for (; ; ) {
     if (existsSync(join3(dir, ".git"))) return dir;
     const parent = dirname2(dir);
@@ -9293,7 +9509,7 @@ function findGitRoot(cwd) {
   }
 }
 function searchPath(cwd) {
-  const start = resolve4(cwd);
+  const start = resolve5(cwd);
   const root = findGitRoot(start);
   if (root === null) return [start];
   const chain = [];
@@ -9308,11 +9524,11 @@ function searchPath(cwd) {
 }
 
 // src/shared/tools.ts
-import { isAbsolute as isAbsolute3, resolve as resolve5 } from "node:path";
+import { isAbsolute as isAbsolute3, resolve as resolve6 } from "node:path";
 var TOOL_KEYS = ["vale", "dita-ot"];
 var VALE_KEYS = ["config"];
 var DITA_OT_KEYS = ["home"];
-function isMapping2(value) {
+function isMapping3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function rejectUnknownKeys2(raw, allowed, where, source, toError) {
@@ -9326,7 +9542,7 @@ function rejectUnknownKeys2(raw, allowed, where, source, toError) {
 }
 function parseTools(raw, source, toError) {
   if (raw === null || raw === void 0) return {};
-  if (!isMapping2(raw)) {
+  if (!isMapping3(raw)) {
     throw toError(`${source}: "tools" must be a mapping.`);
   }
   rejectUnknownKeys2(raw, TOOL_KEYS, "tools", source, toError);
@@ -9340,7 +9556,7 @@ function parseTools(raw, source, toError) {
   return tools;
 }
 function parseVale(raw, source, toError) {
-  if (!isMapping2(raw)) {
+  if (!isMapping3(raw)) {
     throw toError(`${source}: tools.vale must be a mapping.`);
   }
   rejectUnknownKeys2(raw, VALE_KEYS, "tools.vale", source, toError);
@@ -9355,7 +9571,7 @@ function parseVale(raw, source, toError) {
   return vale;
 }
 function parseDitaOt(raw, source, toError) {
-  if (!isMapping2(raw)) {
+  if (!isMapping3(raw)) {
     throw toError(`${source}: tools.dita-ot must be a mapping.`);
   }
   rejectUnknownKeys2(raw, DITA_OT_KEYS, "tools.dita-ot", source, toError);
@@ -9372,12 +9588,12 @@ function parseDitaOt(raw, source, toError) {
 function valeConfigPath(tools, configDir) {
   const config = tools.vale?.config;
   if (config === void 0) return void 0;
-  return isAbsolute3(config) ? config : resolve5(configDir, config);
+  return isAbsolute3(config) ? config : resolve6(configDir, config);
 }
 function ditaOtHome(tools, configDir) {
   const home = tools["dita-ot"]?.home;
   if (home === void 0) return void 0;
-  return isAbsolute3(home) ? home : resolve5(configDir, home);
+  return isAbsolute3(home) ? home : resolve6(configDir, home);
 }
 
 // src/shared/warn.ts
@@ -9392,22 +9608,24 @@ function notice(message) {
   process.stderr.write(`${programName()}: ${message}
 `);
 }
+var noticed = /* @__PURE__ */ new Set();
+function noticeOnce(message) {
+  if (noticed.has(message)) return;
+  noticed.add(message);
+  notice(message);
+}
 
 // src/shared/config-file.ts
 var FAMILY_CONFIG_NAMES = [
   "manni.config.yaml",
   "manni.config.yml"
 ];
-var MOOSE_CONFIG_NAMES = [
-  "moose.config.yaml",
-  "moose.config.yml"
-];
 var ENCRYPTION_KEY_FIELD = "encryptionKey";
 var ENCRYPTION_KEY_PREVIOUS_FIELD = "encryptionKeyPrevious";
-async function readDocument(path, source, toError) {
+function readDocument(path, source, toError) {
   let text2;
   try {
-    text2 = await readFile3(path, "utf8");
+    text2 = readFileSync2(path, "utf8");
   } catch {
     return null;
   }
@@ -9428,7 +9646,12 @@ function parseMapping(text2, source, toError) {
 }
 var COLLECTIONS_KEY = "collections";
 var TOOLS_KEY = "tools";
-var FAMILY_KEYS = [COLLECTIONS_KEY, TOOLS_KEY, ENCRYPTION_KEY_FIELD];
+var FAMILY_KEYS = [
+  COLLECTIONS_KEY,
+  TOOLS_KEY,
+  ENCRYPTION_KEY_FIELD,
+  PROVIDERS_KEY
+];
 function slice(document, opts) {
   const { doc } = document;
   if (doc !== null && Object.hasOwn(doc, opts.section)) {
@@ -9473,6 +9696,11 @@ function encryptionKeyOf(document, source, toError) {
   }
   return keys;
 }
+function providersOf(document, source, dir, toError) {
+  const { doc } = document;
+  if (doc === null || !Object.hasOwn(doc, PROVIDERS_KEY)) return {};
+  return { providers: parseProviders(doc[PROVIDERS_KEY], source, dir, toError) };
+}
 function tolerantKeysOf(document) {
   const key = document.doc?.[ENCRYPTION_KEY_FIELD];
   const previous = document.doc?.[ENCRYPTION_KEY_PREVIOUS_FIELD];
@@ -9484,42 +9712,33 @@ function tolerantKeysOf(document) {
 function relativeSource(cwd, path) {
   return relative3(cwd, path).replace(/\\/g, "/");
 }
-function mooseWarning(name2) {
-  return `"${name2}" is the pre-rename name of the family config file. Rename it to "${FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml"}".`;
-}
-var FAMILY_FILES = [
-  { names: FAMILY_CONFIG_NAMES, kind: "manni" },
-  { names: MOOSE_CONFIG_NAMES, kind: "moose" }
-];
-async function findConfigFile(cwd, opts) {
-  const start = resolve6(cwd);
+function findConfigFileSync(cwd, opts) {
+  const start = resolve7(cwd);
   for (const dir of searchPath(start)) {
-    for (const { names, kind } of FAMILY_FILES) {
-      for (const name2 of names) {
-        const path = join4(dir, name2);
-        const source = relativeSource(start, path);
-        const document = await readDocument(path, source, opts.toError);
-        if (document === null) continue;
-        const found = slice(document, opts);
-        if (found === null) continue;
-        if (kind === "moose") warn(mooseWarning(name2));
-        return {
-          path,
-          dir,
-          source,
-          text: document.text,
-          kind,
-          collections: collectionsOf(document, source, opts.toError),
-          tools: toolsOf(document, source, opts.toError),
-          ...encryptionKeyOf(document, source, opts.toError),
-          ...found
-        };
-      }
+    for (const name2 of FAMILY_CONFIG_NAMES) {
+      const path = join4(dir, name2);
+      const source = relativeSource(start, path);
+      const document = readDocument(path, source, opts.toError);
+      if (document === null) continue;
+      const found = slice(document, opts);
+      if (found === null) continue;
+      return {
+        path,
+        dir,
+        source,
+        text: document.text,
+        kind: "manni",
+        collections: collectionsOf(document, source, opts.toError),
+        tools: toolsOf(document, source, opts.toError),
+        ...encryptionKeyOf(document, source, opts.toError),
+        ...providersOf(document, source, dir, opts.toError),
+        ...found
+      };
     }
     for (const name2 of opts.legacyNames) {
       const path = join4(dir, name2);
       const source = relativeSource(start, path);
-      const document = await readDocument(path, source, opts.toError);
+      const document = readDocument(path, source, opts.toError);
       if (document === null) continue;
       warn(
         `"${name2}" is a deprecated config file name. Move its keys under \`${opts.section}:\` in "${FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml"}", and its paths, exclude and sidecars keys to a top-level collections: list, where sidecars becomes externalMetadata.`
@@ -9539,9 +9758,9 @@ async function findConfigFile(cwd, opts) {
   }
   return null;
 }
-async function readConfigFile(explicitPath, cwd, opts) {
-  const path = resolve6(cwd, explicitPath);
-  const document = await readDocument(path, explicitPath, opts.toError);
+function readConfigFileSync(explicitPath, cwd, opts) {
+  const path = resolve7(cwd, explicitPath);
+  const document = readDocument(path, explicitPath, opts.toError);
   if (document === null) {
     throw opts.toError(`Config file not found: "${explicitPath}".`);
   }
@@ -9560,44 +9779,58 @@ async function readConfigFile(explicitPath, cwd, opts) {
     // An unwrapped document carries no family key (else it would be wrapped),
     // so this only ever reads a family file's key.
     ...encryptionKeyOf(document, explicitPath, opts.toError),
+    ...providersOf(document, explicitPath, dirname3(path), opts.toError),
     ...found
   };
 }
-async function findFamilyConfigFile(cwd, toError) {
-  const start = resolve6(cwd);
+function findConfigFile(cwd, opts) {
+  return Promise.resolve().then(() => findConfigFileSync(cwd, opts));
+}
+function readConfigFile(explicitPath, cwd, opts) {
+  return Promise.resolve().then(
+    () => readConfigFileSync(explicitPath, cwd, opts)
+  );
+}
+function findFamilyConfigFile(cwd, toError) {
+  return Promise.resolve().then(() => findFamilyConfigFileSync(cwd, toError));
+}
+function findFamilyConfigFileSync(cwd, toError) {
+  const start = resolve7(cwd);
   for (const dir of searchPath(start)) {
-    for (const { names, kind } of FAMILY_FILES) {
-      for (const name2 of names) {
-        const path = join4(dir, name2);
-        const source = relativeSource(start, path);
-        const document = await readDocument(path, source, toError);
-        if (document === null) continue;
-        if (kind === "moose") warn(mooseWarning(name2));
-        return {
-          path,
-          dir,
-          source,
-          text: document.text,
-          value: null,
-          wrapped: true,
-          kind,
-          collections: collectionsOf(document, source, toError),
-          tools: toolsOf(document, source, toError),
-          ...tolerantKeysOf(document)
-        };
-      }
+    for (const name2 of FAMILY_CONFIG_NAMES) {
+      const path = join4(dir, name2);
+      const source = relativeSource(start, path);
+      const document = readDocument(path, source, toError);
+      if (document === null) continue;
+      return {
+        path,
+        dir,
+        source,
+        text: document.text,
+        value: null,
+        wrapped: true,
+        kind: "manni",
+        collections: collectionsOf(document, source, toError),
+        tools: toolsOf(document, source, toError),
+        ...tolerantKeysOf(document)
+      };
     }
   }
   return null;
 }
-async function readFamilyConfigFile(explicitPath, cwd, toError) {
-  const path = resolve6(cwd, explicitPath);
-  const document = await readDocument(path, explicitPath, toError);
+function readFamilyConfigFile(explicitPath, cwd, toError) {
+  return Promise.resolve().then(
+    () => readFamilyConfigFileSync(explicitPath, cwd, toError)
+  );
+}
+function readFamilyConfigFileSync(explicitPath, cwd, toError) {
+  const path = resolve7(cwd, explicitPath);
+  const document = readDocument(path, explicitPath, toError);
   if (document === null) {
     throw toError(`Config file not found: "${explicitPath}".`);
   }
   const { doc } = document;
-  const named = [...FAMILY_CONFIG_NAMES, ...MOOSE_CONFIG_NAMES].includes(basename2(path));
+  const named = FAMILY_CONFIG_NAMES.includes(basename2(path));
   const family = doc === null || named || FAMILY_KEYS.some((key) => Object.hasOwn(doc, key));
   return {
     path,
@@ -9614,8 +9847,8 @@ async function readFamilyConfigFile(explicitPath, cwd, toError) {
 }
 
 // src/meta/core/register.ts
-import { readFile as readFile4, readdir, stat as stat4 } from "node:fs/promises";
-import { join as join5, relative as relative4, resolve as resolve7, sep as sep2 } from "node:path";
+import { readFile as readFile3, readdir, stat as stat4 } from "node:fs/promises";
+import { join as join5, relative as relative4, resolve as resolve8, sep as sep2 } from "node:path";
 var RESERVED_VENDORS = [
   "manni",
   "check",
@@ -9671,7 +9904,7 @@ function shown(configDir, path) {
 async function loadRegisteredSchemas(register2, configDir) {
   const files = [];
   for (const [i, entry] of register2.entries()) {
-    const path = resolve7(configDir, entry);
+    const path = resolve8(configDir, entry);
     let entryStats;
     try {
       entryStats = await stat4(path);
@@ -9701,7 +9934,7 @@ async function loadRegisteredSchemas(register2, configDir) {
     const file = shown(configDir, path);
     let parsed2;
     try {
-      parsed2 = JSON.parse(stripBom2(await readFile4(path, "utf8")));
+      parsed2 = JSON.parse(stripBom2(await readFile3(path, "utf8")));
     } catch {
       throw new DocmetaError(`register: ${file} is not valid JSON.`);
     }
@@ -10470,8 +10703,8 @@ function parseFill(value, source) {
 function schemaTrustRoot(cwd, configDir) {
   const git2 = findGitRoot(cwd);
   if (git2 !== null) return { dir: git2, source: "git" };
-  if (configDir !== void 0) return { dir: resolve8(configDir), source: "config" };
-  return { dir: resolve8(cwd), source: "cwd" };
+  if (configDir !== void 0) return { dir: resolve9(configDir), source: "config" };
+  return { dir: resolve9(cwd), source: "cwd" };
 }
 async function loadConfig(explicitPath, cwd = process.cwd()) {
   const file = explicitPath ? await readConfigFile(explicitPath, cwd, CONFIG_FILE) : await findConfigFile(cwd, CONFIG_FILE);
@@ -10550,18 +10783,18 @@ import { isAbsolute as isAbsolute4 } from "node:path";
 // src/meta/core/baseline.ts
 import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
-import { readFile as readFile5 } from "node:fs/promises";
-import { relative as relative7, resolve as resolve11 } from "node:path";
+import { readFile as readFile4 } from "node:fs/promises";
+import { relative as relative7, resolve as resolve12 } from "node:path";
 
 // src/meta/core/load-files.ts
 import { stat as stat5 } from "node:fs/promises";
-import { extname, relative as relative6, resolve as resolve10 } from "node:path";
+import { extname, relative as relative6, resolve as resolve11 } from "node:path";
 import fg2 from "fast-glob";
 import picomatch3 from "picomatch";
 
 // src/meta/core/gitignore.ts
 import { spawn } from "node:child_process";
-import { dirname as dirname4, relative as relative5, resolve as resolve9, sep as sep3 } from "node:path";
+import { dirname as dirname4, relative as relative5, resolve as resolve10, sep as sep3 } from "node:path";
 var GITIGNORE_UNAVAILABLE = ".gitignore filtering was requested but git could not answer here (no repository, or no git on PATH); no files were skipped.";
 var unavailable = () => ({
   ignored: /* @__PURE__ */ new Set(),
@@ -10575,7 +10808,7 @@ async function gitIgnored(paths, cwd) {
   const byRoot = /* @__PURE__ */ new Map();
   let inSomeRepo = false;
   for (const spelled of paths) {
-    const abs = resolve9(cwd, spelled);
+    const abs = resolve10(cwd, spelled);
     const dir = dirname4(abs);
     let root = rootOf.get(dir);
     if (root === void 0) {
@@ -10693,7 +10926,7 @@ async function walkDirectory(cwd, abs, ignore, framed) {
   });
   const files = [];
   for (const file of found) {
-    const rel = toPosix(relative6(cwd, resolve10(root, file)));
+    const rel = toPosix(relative6(cwd, resolve11(root, file)));
     if (!ignoredByGlobs(rel, framed)) files.push(rel);
   }
   return files;
@@ -10724,7 +10957,7 @@ async function resolveTargetSet(opts) {
   for (const input of opts.inputs) {
     if (input === STDIN_TOKEN) continue;
     const posixInput = toPosix(input);
-    const abs = resolve10(cwd, posixInput);
+    const abs = resolve11(cwd, posixInput);
     const st = await statOrNull(abs);
     if (st?.isFile()) {
       named.add(toPosix(relative6(cwd, abs)));
@@ -10808,12 +11041,12 @@ var FINGERPRINT_RE = /^[0-9a-f]{16}$/;
 function canonicalFilePath(file, ctx) {
   if (!ctx) return file;
   const from = ctx.runBase ?? ctx.base;
-  return relative7(ctx.base, resolve11(from, file)).replace(/\\/g, "/");
+  return relative7(ctx.base, resolve12(from, file)).replace(/\\/g, "/");
 }
 function canonicalSchemaRef(ref, ctx) {
   if (!ctx) return ref;
   if (classifyRef(ref).kind !== "file") return ref;
-  const abs = resolve11(ctx.cwd, ref);
+  const abs = resolve12(ctx.cwd, ref);
   return relative7(ctx.base, abs).replace(/\\/g, "/");
 }
 function fingerprint(e, ctx) {
@@ -10887,7 +11120,7 @@ function parseBaseline(text2, source) {
 async function readBaseline(absPath, source) {
   let text2;
   try {
-    text2 = await readFile5(absPath, "utf8");
+    text2 = await readFile4(absPath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw new DocmetaError(
@@ -10971,17 +11204,17 @@ function countFingerprints(baseline) {
 }
 function resolveBaselineRequest(opts, configured, configDir, cwd, defaults) {
   const named = (label) => ({
-    absPath: resolve11(cwd, label),
+    absPath: resolve12(cwd, label),
     label
   });
   const implied = () => {
     const base = configDir ?? cwd;
     if (configured !== void 0) {
-      return { absPath: resolve11(base, configured), label: configured };
+      return { absPath: resolve12(base, configured), label: configured };
     }
-    const current = resolve11(base, defaults.current);
+    const current = resolve12(base, defaults.current);
     if (defaults.legacy !== void 0) {
-      const legacy = resolve11(base, defaults.legacy);
+      const legacy = resolve12(base, defaults.legacy);
       if (!existsSync2(current) && existsSync2(legacy)) {
         warn(
           `"${defaults.legacy}" is the pre-rename baseline file name. Rename it to "${defaults.current}".`
@@ -11487,8 +11720,8 @@ async function readCapped(url, res, maxBytes) {
 }
 
 // src/meta/core/external-metadata.ts
-import { readFile as readFile7 } from "node:fs/promises";
-import { isAbsolute as isAbsolute5, relative as relative9, resolve as resolve13, sep as sep4 } from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import { isAbsolute as isAbsolute5, relative as relative9, resolve as resolve14, sep as sep4 } from "node:path";
 import {
   LineCounter as LineCounter3,
   isMap as isMap6,
@@ -11570,8 +11803,8 @@ function isMissing(error) {
 
 // src/shared/encryption-key.ts
 import { spawnSync } from "node:child_process";
-import { readFile as readFile6 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname6, join as join7, relative as relative8, resolve as resolve12 } from "node:path";
+import { readFile as readFile5 } from "node:fs/promises";
+import { basename as basename4, dirname as dirname6, join as join7, relative as relative8, resolve as resolve13 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { isMap as isMap5, parseDocument as parseDocument4, parse as parseYaml3, stringify as stringify2 } from "yaml";
 
@@ -11583,8 +11816,8 @@ var RENAME_ATTEMPTS2 = 3;
 function errorCode2(err) {
   return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
 }
-var wait3 = (ms) => new Promise((resolve25) => {
-  setTimeout(resolve25, ms);
+var wait3 = (ms) => new Promise((resolve26) => {
+  setTimeout(resolve26, ms);
 });
 async function writeTextAtomic(path, text2) {
   const tmp = join6(
@@ -11633,14 +11866,14 @@ function resolveEncryptionKey(opts) {
   return { key: void 0, source: "none" };
 }
 function relativeSource2(cwd, path) {
-  return relative8(resolve12(cwd), path).replace(/\\/g, "/");
+  return relative8(resolve13(cwd), path).replace(/\\/g, "/");
 }
 function errorCode3(err) {
   return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
 }
 async function readIfPresent(path) {
   try {
-    return await readFile6(path, "utf8");
+    return await readFile5(path, "utf8");
   } catch (err) {
     if (errorCode3(err) === "ENOENT") return null;
     throw err;
@@ -11656,8 +11889,8 @@ async function fileTarget(file, toError) {
   return { path: file.path, source: file.source, text: text2 ?? file.text };
 }
 async function defaultTarget(cwd) {
-  const root = findGitRoot(cwd) ?? resolve12(cwd);
-  for (const name2 of [...FAMILY_CONFIG_NAMES, ...MOOSE_CONFIG_NAMES]) {
+  const root = findGitRoot(cwd) ?? resolve13(cwd);
+  for (const name2 of FAMILY_CONFIG_NAMES) {
     const path2 = join7(root, name2);
     const text2 = await readIfPresent(path2);
     if (text2 !== null) return { path: path2, source: relativeSource2(cwd, path2), text: text2 };
@@ -11679,20 +11912,20 @@ function withKey(text2, key, previous, source, toError) {
   if (previous === null) doc.delete(ENCRYPTION_KEY_PREVIOUS_FIELD);
   return doc.toString();
 }
-function isMapping3(value) {
+function isMapping4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function verify4(before, after, key, previous, source, toError) {
   const old = before === null ? null : parseYaml3(before);
   const expected = Object.fromEntries(
     Object.entries({
-      ...isMapping3(old) ? old : {},
+      ...isMapping4(old) ? old : {},
       [ENCRYPTION_KEY_FIELD]: key,
       ...typeof previous === "string" ? { [ENCRYPTION_KEY_PREVIOUS_FIELD]: previous } : {}
     }).filter(([name2]) => previous !== null || name2 !== ENCRYPTION_KEY_PREVIOUS_FIELD)
   );
   const reread = parseYaml3(after);
-  if (!isMapping3(reread) || !isDeepStrictEqual(reread, expected)) {
+  if (!isMapping4(reread) || !isDeepStrictEqual(reread, expected)) {
     throw toError(
       `Could not write ${ENCRYPTION_KEY_FIELD} to ${source}; add the key by hand.`
     );
@@ -11992,7 +12225,7 @@ async function loadExternalMetadata(collections, opts) {
       });
       parsed2 = parseManifest(manifest, collection, text2, file, opts.configDir, join12, ownership(declared, manifest));
     } else {
-      const abs = isAbsolute5(manifest.file) ? manifest.file : resolve13(opts.configDir, manifest.file);
+      const abs = isAbsolute5(manifest.file) ? manifest.file : resolve14(opts.configDir, manifest.file);
       const label = reportedPath(abs, opts.base);
       file = label;
       parsed2 = await parsedManifests.parse(
@@ -12154,7 +12387,7 @@ function outsideRefusal(manifest, collection, pageRel) {
 }
 async function readPageManifest(abs, file) {
   try {
-    return await readFile7(abs, "utf8");
+    return await readFile6(abs, "utf8");
   } catch (err) {
     if (isMissing(err)) return "";
     throw unreadable(file, err);
@@ -12162,7 +12395,7 @@ async function readPageManifest(abs, file) {
 }
 async function readManifest(abs, file) {
   try {
-    return await readFile7(abs, "utf8");
+    return await readFile6(abs, "utf8");
   } catch (err) {
     throw unreadable(file, err);
   }
@@ -12211,7 +12444,7 @@ function parseManifest(manifest, collection, text2, file, configDir, join12, own
         `Manifest ${where}: "${spelled}" must be a mapping of owned keys to values.`
       );
     }
-    const indexKey = join12 === PATH_JOIN2 ? resolve13(configDir, spelled) : spelled;
+    const indexKey = join12 === PATH_JOIN2 ? resolve14(configDir, spelled) : spelled;
     const values = target.get(indexKey) ?? /* @__PURE__ */ new Map();
     for (const kv of pair.value.items) {
       const key = isScalar5(kv.key) ? String(kv.key.value) : String(kv.key);
@@ -12299,10 +12532,10 @@ function mergeWith(label, extracted, index, memberOf2, base, encryptionKey, mark
   const entryOf = /* @__PURE__ */ new Map();
   const joins = [];
   if (label !== STDIN_LABEL) {
-    const byPath = index.byPath.get(resolve13(base, label));
+    const byPath = index.byPath.get(resolve14(base, label));
     if (byPath) {
       sources.push(byPath);
-      const abs = resolve13(base, label);
+      const abs = resolve14(base, label);
       entryOf.set(byPath, (sv) => index.entries.find((e) => e.file === sv.file && e.abs === abs));
     }
   }
@@ -12427,7 +12660,7 @@ function externalMetadataPointer(key) {
 }
 function orphanEntries(index, loaded, base, collections) {
   if (!index) return [];
-  const have = new Set(loaded.map((l) => resolve13(base, l)));
+  const have = new Set(loaded.map((l) => resolve14(base, l)));
   const orphans = index.entries.filter(
     (e) => inCollections(e, collections) && e.join === PATH_JOIN2 && e.abs !== void 0 && !have.has(e.abs)
   );
@@ -12491,721 +12724,721 @@ function pageOwners(index, key, memberOf2, marked) {
   ];
 }
 
-// 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/collections.ts
+import { isAbsolute as isAbsolute6, relative as relative10, resolve as resolvePath2, sep as sep5 } from "node:path";
 
-// 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";
+// src/meta/core/projection.ts
+var SYSTEM_COLUMNS = ["_path", "_format", "_present", "_data"];
+var RESERVED = new Set(SYSTEM_COLUMNS);
+function quoteIdent(name2) {
+  return `"${name2.replaceAll('"', '""')}"`;
 }
-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);
-  registerBuiltins(ajv, dialect);
-  return ajv;
+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);
+  }
 }
-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 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);
     }
-  });
-}
-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, "~");
+  for (const key of extraKeys) {
+    if (key !== "" && !RESERVED.has(key)) keys.add(key);
+  }
+  return [...keys].sort();
 }
-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 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 isLocationShapeError(err) {
-  return err instanceof Error && err.message.includes(`"${LOCATION_KEYWORD}"`);
+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 marksSchemaExternal(schema) {
-  const properties = schema["properties"];
-  if (typeof properties !== "object" || properties === null) return false;
-  const own2 = properties[FILE_SCHEMA_KEY];
-  if (typeof own2 !== "object" || own2 === null) return false;
-  return own2[LOCATION_KEYWORD] === "external";
+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 isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function startsStringOrIdent(sql, i) {
+  const ch = sql[i];
+  return ch === "'" || ch === '"' || ch === "`" || ch === "[";
 }
-function definiteLocationConflict(root) {
-  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;
+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;
       }
-      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[LOCATION_KEYWORD];
-    if (isFieldLocation(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());
+      return j + 1;
     }
-    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;
+    j++;
+  }
+  return j;
 }
-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 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 registerRegistered(ajv, dialect, registered2) {
-  for (const { id, schema } of registered2?.values() ?? []) {
-    ajv.addSchema(schema, dialect === "draft4" ? id : void 0, void 0, false);
+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;
 }
-function compileWithFormats(schema, registered2, options = {}) {
-  const ajv = buildAjv("2020", options.coerce === true ? "array" : false);
-  registerRegistered(ajv, "2020", registered2);
-  return ajv.compile(schema);
+var PARAM_NAME_HEAD = /^[A-Za-z_][A-Za-z0-9_]*/;
+function isParamName(name2) {
+  return PARAM_NAME_HEAD.exec(name2)?.[0] === name2;
 }
-var formatRegistry;
-function formatsAjv() {
-  if (!formatRegistry) {
-    formatRegistry = new Ajv2020({ strict: false });
-    addFormats(formatRegistry);
+function collectNamedParameters(sql) {
+  const tokens2 = [];
+  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);
+        tokens2.push(token);
+      }
+      i += 1 + m[0].length;
+    } else {
+      i++;
+    }
   }
-  return formatRegistry;
+  return tokens2;
 }
-var stringFormatsMemo;
-function stringFormatNames() {
-  if (!stringFormatsMemo) {
-    const names = /* @__PURE__ */ new Set();
-    const registered2 = formatsAjv().formats;
-    for (const [name2, def] of Object.entries(registered2)) {
-      const enforcesStrings = def instanceof RegExp || typeof def === "function" || typeof def === "object" && def !== null && (def.type === void 0 || def.type === "string");
-      if (enforcesStrings) names.add(name2);
+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;
     }
-    stringFormatsMemo = names;
+    return sql.slice(i);
   }
-  return stringFormatsMemo;
 }
-var formatCheckers = /* @__PURE__ */ new Map();
-function validatesFormat(name2, value) {
-  let fn = formatCheckers.get(name2);
-  if (!fn) {
-    fn = formatsAjv().compile({ type: "string", format: name2 });
-    formatCheckers.set(name2, fn);
+function isTrivia(text2) {
+  let i = 0;
+  while (i < text2.length) {
+    const ch = text2[i];
+    if (ch === void 0 || /\s/.test(ch) || ch === ";") {
+      i++;
+      continue;
+    }
+    if (startsComment(text2, i)) {
+      i = skipComment(text2, i);
+      continue;
+    }
+    return false;
   }
-  return fn(value);
+  return true;
 }
-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);
+var sqliteModule;
+function loadSqlite() {
+  sqliteModule ??= (async () => {
+    const original = process.emitWarning.bind(process);
+    const filtered = (warning, ...rest) => {
+      const text2 = typeof warning === "string" ? warning : warning.message;
+      if (text2.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 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 = definiteLocationConflict(schema);
-    if (contradicted !== void 0) {
-      throw new DocmetaError(
-        `${ref}: "${LOCATION_KEYWORD}" says both "page" and "external" for "${contradicted}".`
-      );
-    }
-    try {
-      const ajv = this.ajvFor(dialectOf(schema));
-      const id = typeof schema["$id"] === "string" ? schema["$id"] : void 0;
-      const registered2 = id != null ? ajv.getSchema(id) : void 0;
-      if (registered2) {
-        if (registered2.schema === schema) return registered2;
-        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".`
-        );
-      }
-      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;
-  }
-  /**
-   * 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 sqliteModule;
+}
+
+// src/meta/core/collections.ts
+function memberOf(collections, configDir, base, label) {
+  if (collections.length === 0) return [];
+  if (label === STDIN_LABEL) return [];
+  const rel = relative10(configDir, resolvePath2(base, label)).split(sep5).join("/");
+  if (isAbsolute6(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 name2 of memberOf(declared, configDir, base, entry.label)) {
+      const list2 = members.get(name2);
+      if (list2) list2.push(entry.label);
+      else members.set(name2, [entry.label]);
     }
-    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;
   }
+  return declared.map((c) => ({ name: c.name, members: members.get(c.name) ?? [] }));
 }
-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 } : {}
-    };
+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}`
+    );
   }
-  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/collections.ts
-import { isAbsolute as isAbsolute6, relative as relative10, resolve as resolvePath2, sep as sep5 } from "node:path";
-
-// src/meta/core/projection.ts
-var SYSTEM_COLUMNS = ["_path", "_format", "_present", "_data"];
-var RESERVED = new Set(SYSTEM_COLUMNS);
-function quoteIdent(name2) {
-  return `"${name2.replaceAll('"', '""')}"`;
+// 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";
 }
-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);
+
+// 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 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 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);
+  registerBuiltins(ajv, dialect);
+  return ajv;
 }
-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]))
-      );
+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;
     }
-    db.exec("COMMIT");
-    committed = true;
-  } finally {
-    if (!committed) db.exec("ROLLBACK");
+  });
+}
+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 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 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 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 isLocationShapeError(err) {
+  return err instanceof Error && err.message.includes(`"${LOCATION_KEYWORD}"`);
+}
+function marksSchemaExternal(schema) {
+  const properties = schema["properties"];
+  if (typeof properties !== "object" || properties === null) return false;
+  const own2 = properties[FILE_SCHEMA_KEY];
+  if (typeof own2 !== "object" || own2 === null) return false;
+  return own2[LOCATION_KEYWORD] === "external";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function definiteLocationConflict(root) {
+  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[LOCATION_KEYWORD];
+    if (isFieldLocation(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 startsStringOrIdent(sql, i) {
-  const ch = sql[i];
-  return ch === "'" || ch === '"' || ch === "`" || ch === "[";
+function registerRegistered(ajv, dialect, registered2) {
+  for (const { id, schema } of registered2?.values() ?? []) {
+    ajv.addSchema(schema, dialect === "draft4" ? id : void 0, void 0, false);
+  }
 }
-function startsComment(sql, i) {
-  const ch = sql[i];
-  return ch === "-" && sql[i + 1] === "-" || ch === "/" && sql[i + 1] === "*";
+function compileWithFormats(schema, registered2, options = {}) {
+  const ajv = buildAjv("2020", options.coerce === true ? "array" : false);
+  registerRegistered(ajv, "2020", registered2);
+  return ajv.compile(schema);
 }
-function skipStringOrIdent(sql, i) {
-  const quote = sql[i];
-  if (quote === "[") {
-    let j2 = i + 1;
-    while (j2 < sql.length && sql[j2] !== "]") j2++;
-    return j2 + 1;
+var formatRegistry;
+function formatsAjv() {
+  if (!formatRegistry) {
+    formatRegistry = new Ajv2020({ strict: false });
+    addFormats(formatRegistry);
   }
-  let j = i + 1;
-  while (j < sql.length) {
-    if (sql[j] === quote) {
-      if (sql[j + 1] === quote) {
-        j += 2;
-        continue;
-      }
-      return j + 1;
+  return formatRegistry;
+}
+var stringFormatsMemo;
+function stringFormatNames() {
+  if (!stringFormatsMemo) {
+    const names = /* @__PURE__ */ new Set();
+    const registered2 = formatsAjv().formats;
+    for (const [name2, def] of Object.entries(registered2)) {
+      const enforcesStrings = def instanceof RegExp || typeof def === "function" || typeof def === "object" && def !== null && (def.type === void 0 || def.type === "string");
+      if (enforcesStrings) names.add(name2);
     }
-    j++;
+    stringFormatsMemo = names;
   }
-  return j;
+  return stringFormatsMemo;
 }
-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;
+var formatCheckers = /* @__PURE__ */ new Map();
+function validatesFormat(name2, value) {
+  let fn = formatCheckers.get(name2);
+  if (!fn) {
+    fn = formatsAjv().compile({ type: "string", format: name2 });
+    formatCheckers.set(name2, fn);
   }
-  const end = sql.indexOf("*/", i + 2);
-  return end === -1 ? sql.length : end + 2;
+  return fn(value);
 }
-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++;
+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;
   }
-  return -1;
-}
-var PARAM_NAME_HEAD = /^[A-Za-z_][A-Za-z0-9_]*/;
-function isParamName(name2) {
-  return PARAM_NAME_HEAD.exec(name2)?.[0] === name2;
-}
-function collectNamedParameters(sql) {
-  const tokens2 = [];
-  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;
+  /**
+   * 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 = definiteLocationConflict(schema);
+    if (contradicted !== void 0) {
+      throw new DocmetaError(
+        `${ref}: "${LOCATION_KEYWORD}" says both "page" and "external" for "${contradicted}".`
+      );
+    }
+    try {
+      const ajv = this.ajvFor(dialectOf(schema));
+      const id = typeof schema["$id"] === "string" ? schema["$id"] : void 0;
+      const registered2 = id != null ? ajv.getSchema(id) : void 0;
+      if (registered2) {
+        if (registered2.schema === schema) return registered2;
+        const { $id: _taken, ...anonymous } = schema;
+        return ajv.compile(anonymous);
       }
-      const m = PARAM_NAME_HEAD.exec(sql.slice(i + 1));
-      if (!m) {
-        i++;
-        continue;
+      return ajv.compile(schema);
+    } catch (err) {
+      if (isMarkShapeError(err)) {
+        throw new DocmetaError(
+          `${ref}: "${ENCRYPT_KEYWORD}" must be true or false.`
+        );
       }
-      const token = ch + m[0];
-      const priorPrefix = prefixOf.get(m[0]);
-      if (priorPrefix !== void 0 && priorPrefix !== ch) {
+      if (isLocationShapeError(err)) {
         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.`
+          `${ref}: "${LOCATION_KEYWORD}" must be "page" or "external".`
         );
       }
-      prefixOf.set(m[0], ch);
-      if (!seen.has(token)) {
-        seen.add(token);
-        tokens2.push(token);
+      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;
       }
-      i += 1 + m[0].length;
-    } else {
-      i++;
     }
+    return marks;
   }
-  return tokens2;
-}
-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;
+  /**
+   * 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 sql.slice(i);
+    return preferences;
   }
-}
-function isTrivia(text2) {
-  let i = 0;
-  while (i < text2.length) {
-    const ch = text2[i];
-    if (ch === void 0 || /\s/.test(ch) || ch === ";") {
-      i++;
-      continue;
-    }
-    if (startsComment(text2, i)) {
-      i = skipComment(text2, i);
-      continue;
+  /**
+   * 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 false;
+    return claimed;
   }
-  return true;
-}
-var sqliteModule;
-function loadSqlite() {
-  sqliteModule ??= (async () => {
-    const original = process.emitWarning.bind(process);
-    const filtered = (warning, ...rest) => {
-      const text2 = typeof warning === "string" ? warning : warning.message;
-      if (text2.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
-function memberOf(collections, configDir, base, label) {
-  if (collections.length === 0) return [];
-  if (label === STDIN_LABEL) return [];
-  const rel = relative10(configDir, resolvePath2(base, label)).split(sep5).join("/");
-  if (isAbsolute6(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 name2 of memberOf(declared, configDir, base, entry.label)) {
-      const list2 = members.get(name2);
-      if (list2) list2.push(entry.label);
-      else members.set(name2, [entry.label]);
+  /**
+   * 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;
   }
-  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}`
-    );
+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/derive/cache.ts
 import { createHash as createHash4 } from "node:crypto";
-import { mkdirSync, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync as readFileSync3, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join as join8 } from "node:path";
 var REVIEW_CACHE_DIR = ".manni/meta/review-cache";
 var REVIEW_CACHE_VERSION = 1;
@@ -13225,7 +13458,7 @@ var ReviewCache = class {
     if (!this.enabled) return void 0;
     let raw;
     try {
-      raw = JSON.parse(readFileSync2(this.entryPath(key), "utf8"));
+      raw = JSON.parse(readFileSync3(this.entryPath(key), "utf8"));
     } catch {
       return void 0;
     }
@@ -13789,12 +14022,12 @@ function utcDate(iso) {
 }
 
 // src/meta/core/derive/index.ts
-import { dirname as dirname9, resolve as resolve15 } from "node:path";
+import { dirname as dirname9, resolve as resolve16 } from "node:path";
 
 // src/meta/core/derive/codeowners.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { readFile as readFile8 } from "node:fs/promises";
-import { dirname as dirname7, relative as relative11, resolve as resolve14, sep as sep6 } from "node:path";
+import { readFile as readFile7 } from "node:fs/promises";
+import { dirname as dirname7, relative as relative11, resolve as resolve15, sep as sep6 } from "node:path";
 import picomatch4 from "picomatch";
 var CODEOWNERS_LOCATIONS = [
   ".github/CODEOWNERS",
@@ -13804,11 +14037,11 @@ var CODEOWNERS_LOCATIONS = [
 ];
 function findCodeowners(root, explicit) {
   if (explicit !== void 0) {
-    const path = resolve14(root, explicit);
+    const path = resolve15(root, explicit);
     return existsSync3(path) ? path : null;
   }
   for (const loc of CODEOWNERS_LOCATIONS) {
-    const path = resolve14(root, ...loc.split("/"));
+    const path = resolve15(root, ...loc.split("/"));
     if (existsSync3(path)) return path;
   }
   return null;
@@ -13923,7 +14156,7 @@ function toGlobs(pattern) {
 var NOT_FOUND_REASON = `no CODEOWNERS file found (looked for ${CODEOWNERS_LOCATIONS.join(", ")})`;
 async function deriveFromCodeowners(inputs, opts) {
   const records = /* @__PURE__ */ new Map();
-  const explicitPath = opts.explicit === void 0 ? void 0 : resolve14(opts.configDir ?? process.cwd(), opts.explicit);
+  const explicitPath = opts.explicit === void 0 ? void 0 : resolve15(opts.configDir ?? process.cwd(), opts.explicit);
   if (explicitPath !== void 0 && !existsSync3(explicitPath)) {
     return {
       status: { available: false, reason: `CODEOWNERS not found at ${explicitPath}` },
@@ -13957,7 +14190,7 @@ async function deriveFromCodeowners(inputs, opts) {
     const key = `${path}\0${label}`;
     let file = parsed2.get(key);
     if (!file) {
-      file = readFile8(path, "utf8").then(
+      file = readFile7(path, "utf8").then(
         (text2) => parseCodeowners(text2, path, label)
       );
       parsed2.set(key, file);
@@ -15667,7 +15900,7 @@ async function deriveReviewsByRoot(inputs, git2, rootFor, ctx, requested) {
   if (byRoot.size === 0) {
     return unavailable3(requested, "no git repository contains the documents");
   }
-  const cacheDir = resolve15(ctx.configDir ?? ctx.cwd, REVIEW_CACHE_DIR);
+  const cacheDir = resolve16(ctx.configDir ?? ctx.cwd, REVIEW_CACHE_DIR);
   for (const [root, bucket] of byRoot) {
     const client = ctx.reviews ?? await createReviewClient(root, { cwd: ctx.cwd, cache: ctx.cache, cacheDir, requested });
     const identity = await client.detect();
@@ -15845,7 +16078,7 @@ async function deriveForTable(inputs, ctx, hint, fields) {
 }
 
 // src/meta/commands/validate.ts
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 
 // src/meta/core/page-marks.ts
 function pageMarks(opts) {
@@ -15922,8 +16155,8 @@ async function configMarks(configPath, cwd) {
 }
 
 // src/meta/core/relocation.ts
-import { access, readFile as readFile9, stat as stat7, unlink } from "node:fs/promises";
-import { basename as basename5, extname as extname3, isAbsolute as isAbsolute8, join as join9, relative as relative13, resolve as resolve16, sep as sep8 } from "node:path";
+import { access, readFile as readFile8, stat as stat7, unlink } from "node:fs/promises";
+import { basename as basename5, extname as extname3, isAbsolute as isAbsolute8, join as join9, relative as relative13, resolve as resolve17, sep as sep8 } from "node:path";
 import picomatch6 from "picomatch";
 import {
   LineCounter as LineCounter5,
@@ -16327,7 +16560,7 @@ var Model = class {
       c.externalMetadata.forEach((m, index) => {
         const url = classifyRef(m.file).kind === "url";
         const perPage = !url && hasPagePlaceholder(m.file);
-        const absPath = url || perPage ? void 0 : isAbsolute8(m.file) ? m.file : resolve16(configDir, m.file);
+        const absPath = url || perPage ? void 0 : isAbsolute8(m.file) ? m.file : resolve17(configDir, m.file);
         this.manifests.push({
           collection: c.name,
           index,
@@ -16519,7 +16752,7 @@ var Model = class {
   /** A label relative to the config directory, posix; undefined outside it. */
   relative(label) {
     if (label === "<stdin>") return void 0;
-    const rel = toPosix3(relative13(this.configDir, resolve16(this.ctx.base, label)));
+    const rel = toPosix3(relative13(this.configDir, resolve17(this.ctx.base, label)));
     return isAbsolute8(rel) || rel.startsWith("../") ? void 0 : rel;
   }
 };
@@ -16534,11 +16767,11 @@ async function collectionPath(target, cwd, configDir) {
   const posix7 = target.replace(/\\/g, "/");
   const scanned = picomatch6.scan(posix7);
   if (scanned.isGlob) {
-    const rel2 = toPosix3(relative13(configDir, resolve16(cwd, scanned.base === "" ? "." : scanned.base)));
+    const rel2 = toPosix3(relative13(configDir, resolve17(cwd, scanned.base === "" ? "." : scanned.base)));
     if (isAbsolute8(rel2) || rel2 === ".." || rel2.startsWith("../")) return void 0;
     return rel2 === "" ? scanned.glob : `${rel2}/${scanned.glob}`;
   }
-  const abs = resolve16(cwd, posix7);
+  const abs = resolve17(cwd, posix7);
   const rel = toPosix3(relative13(configDir, abs));
   if (isAbsolute8(rel) || rel.startsWith("..")) return void 0;
   let directory = posix7.endsWith("/");
@@ -16562,7 +16795,7 @@ async function exists(absPath, file) {
   }
 }
 function plannedConfigDir(ctx) {
-  return ctx.configDir ?? findGitRoot(ctx.cwd) ?? resolve16(ctx.cwd);
+  return ctx.configDir ?? findGitRoot(ctx.cwd) ?? resolve17(ctx.cwd);
 }
 async function keyHome(ctx, label, data, key) {
   const model = new Model(ctx, plannedConfigDir(ctx));
@@ -16574,7 +16807,7 @@ async function keyHome(ctx, label, data, key) {
   ) : void 0;
   const owner = model.ownerOf(key, members, marked);
   if (owner !== void 0) {
-    const at2 = model.fileFor(owner, resolve16(ctx.base, label));
+    const at2 = model.fileFor(owner, resolve17(ctx.base, label));
     if (owner.url || at2.abs === void 0) {
       return { kind: "url", collection: owner.collection, file: owner.file };
     }
@@ -16600,7 +16833,7 @@ function marksOf(ctx) {
   });
 }
 function entryFor(m, label, data, configDir, base, key) {
-  if (m.join === PATH_JOIN2) return toPosix3(relative13(configDir, resolve16(base, label)));
+  if (m.join === PATH_JOIN2) return toPosix3(relative13(configDir, resolve17(base, label)));
   let raw = data[m.join];
   if (isEncryptedValue(raw)) {
     const k = key();
@@ -16618,7 +16851,7 @@ function entryFor(m, label, data, configDir, base, key) {
   return void 0;
 }
 async function relocationPages(ctx, request) {
-  const pages2 = new Set(request.files.map((label) => resolve16(ctx.base, label)));
+  const pages2 = new Set(request.files.map((label) => resolve17(ctx.base, label)));
   const root = ctx.configDir ?? ctx.cwd;
   for (const collection of ctx.declaredCollections) {
     const perPage = collection.externalMetadata.some(
@@ -16634,7 +16867,7 @@ async function relocationPages(ctx, request) {
         ...ctx.config?.respectGitignore !== void 0 ? { configured: ctx.config.respectGitignore } : {}
       })
     });
-    for (const file of walked.files) pages2.add(resolve16(root, file));
+    for (const file of walked.files) pages2.add(resolve17(root, file));
   }
   return [...pages2];
 }
@@ -16664,20 +16897,20 @@ async function planRelocation(ctx, request) {
       if (beyond) return void 0;
       throw new DocmetaError(`Unsupported file type "${extname3(label)}" for "${label}". Use --as to override.`);
     }
-    const absPath = resolve16(ctx.base, label);
+    const absPath = resolve17(ctx.base, label);
     const elements = resolveElements(label, ctx.config, currentMembers(label));
     let content = "";
     let own2 = {};
     let unreadable2;
     if (beyond) {
       try {
-        content = await readFile9(absPath, "utf8");
+        content = await readFile8(absPath, "utf8");
         own2 = extractor.extract(content, label, { elements }).data;
       } catch (err) {
         unreadable2 = (errorMessage(err).split("\n")[0] ?? "").replace(/:\s*$/, "");
       }
     } else {
-      content = await readFile9(absPath, "utf8");
+      content = await readFile8(absPath, "utf8");
       try {
         own2 = extractor.extract(content, label, { elements }).data;
       } catch (err) {
@@ -16883,7 +17116,7 @@ async function planRelocation(ctx, request) {
     });
     const labels = dedupe2([
       ...request.files,
-      ...walked.files.map((f) => reported2(resolve16(configDir, f), ctx.base))
+      ...walked.files.map((f) => reported2(resolve17(configDir, f), ctx.base))
     ]).filter((label) => model.members(label).includes(name2));
     for (const label of labels) {
       const page = await load(label, !runSet.has(label));
@@ -17118,7 +17351,7 @@ function assertNoStrandedEntries(m, index, pages2, configDir, fileOf) {
 }
 async function readManifestText(path, file, perPage) {
   try {
-    return await readFile9(path, "utf8");
+    return await readFile8(path, "utf8");
   } catch (err) {
     if (perPage && isMissing(err)) return null;
     throw new DocmetaError(`Manifest ${file} could not be read: ${errorMessage(err)}`);
@@ -17148,7 +17381,7 @@ function keyLines2(text2, join12) {
 async function configTarget(ctx, configDir) {
   if (ctx.configPath !== void 0) {
     try {
-      const text2 = await readFile9(ctx.configPath, "utf8");
+      const text2 = await readFile8(ctx.configPath, "utf8");
       return { path: ctx.configPath, text: text2, disk: text2 };
     } catch (err) {
       if (err.code !== "ENOENT") {
@@ -17159,10 +17392,10 @@ async function configTarget(ctx, configDir) {
       return { path: ctx.configPath, text: ctx.configFile?.text ?? null, disk: null };
     }
   }
-  for (const name2 of [...FAMILY_CONFIG_NAMES, ...MOOSE_CONFIG_NAMES]) {
+  for (const name2 of FAMILY_CONFIG_NAMES) {
     const path = join9(configDir, name2);
     try {
-      const text2 = await readFile9(path, "utf8");
+      const text2 = await readFile8(path, "utf8");
       return { path, text: text2, disk: text2 };
     } catch {
     }
@@ -17348,7 +17581,7 @@ async function applyRelocation(ctx, plan, io = {}) {
   for (const w of plan.writes) {
     let now;
     try {
-      now = await readFile9(w.path, "utf8");
+      now = await readFile8(w.path, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         throw new DocmetaError(`${label(w)} could not be read: ${errorMessage(err)}`);
@@ -17515,7 +17748,7 @@ function relocationOffers(plan) {
 }
 
 // src/meta/commands/validate.ts
-import { resolve as resolve18, extname as extname4 } from "node:path";
+import { resolve as resolve19, extname as extname4 } from "node:path";
 
 // src/meta/core/checks.ts
 var CHECK_KEYWORD = "check";
@@ -17653,7 +17886,7 @@ async function runChecks(checks, entries, ctx = {}) {
 }
 
 // src/meta/core/derive/provenance-place.ts
-import { isAbsolute as isAbsolute9, relative as relative14, resolve as resolve17, sep as sep9 } from "node:path";
+import { isAbsolute as isAbsolute9, relative as relative14, resolve as resolve18, sep as sep9 } from "node:path";
 var toPosix4 = (p) => p.split(sep9).join("/");
 function provenanceManifests(collections, configDir, base, field = PROVENANCE_FIELD) {
   const out = [];
@@ -17675,7 +17908,7 @@ function provenanceManifests(collections, configDir, base, field = PROVENANCE_FI
         });
         continue;
       }
-      const absPath = isAbsolute9(manifest.file) ? manifest.file : resolve17(configDir, manifest.file);
+      const absPath = isAbsolute9(manifest.file) ? manifest.file : resolve18(configDir, manifest.file);
       const perPage = hasPagePlaceholder(manifest.file);
       out.push({
         collection: collection.name,
@@ -17709,7 +17942,7 @@ function provenancePlace(label, data, manifests, collections, configDir, base, m
   if (declared.implied?.url === true) throw new DocmetaError(urlRefusal(declared.collection, field));
   const manifest = declared.perPage ? ownManifest(declared, label, collections, configDir, base) : declared;
   if (manifest.join === PATH_JOIN2) {
-    const entry = toPosix4(relative14(configDir, resolve17(base, label)));
+    const entry = toPosix4(relative14(configDir, resolve18(base, label)));
     return { manifest, absPath: manifest.absPath, entry, join: manifest.join };
   }
   const value = data[manifest.join];
@@ -17721,7 +17954,7 @@ function provenancePlace(label, data, manifests, collections, configDir, base, m
   return { manifest, absPath: manifest.absPath, entry: String(value), join: manifest.join };
 }
 function ownManifest(manifest, label, collections, configDir, base) {
-  const resolved = pageManifestPath(manifest.written, configDir, resolve17(base, label));
+  const resolved = pageManifestPath(manifest.written, configDir, resolve18(base, label));
   if ("outside" in resolved) {
     const declared = collections.find((c) => c.name === manifest.collection)?.externalMetadata.find((m) => m.file === manifest.written);
     throw new DocmetaError(
@@ -17840,7 +18073,7 @@ async function runValidate(opts) {
     base,
     offline: opts.offline ?? config?.offline ?? false,
     // A `{page}` manifest (0058) is read for exactly the pages this run reads.
-    pages: files.map((file) => resolve18(base, file))
+    pages: files.map((file) => resolve19(base, file))
   });
   const validator = new Validator(
     schemaLoadOptions({
@@ -18011,7 +18244,7 @@ async function runValidate(opts) {
       const owned = declaredCollections.length === 0 ? {} : stampManifests(label, extracted.data, declaredCollections, configDir ?? cwd, base, merged.marked, STAMPED_DATE_FIELDS);
       deriveInputs.push({
         label,
-        absPath: resolve18(base, label),
+        absPath: resolve19(base, label),
         content,
         extracted,
         ...place !== void 0 ? { provenanceManifest: place } : {},
@@ -18151,7 +18384,7 @@ async function runValidate(opts) {
     await processOne(STDIN_LABEL, content, forcedExtractor.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile10(resolve18(base, file), "utf8");
+    const content = await readFile9(resolve19(base, file), "utf8");
     await processOne(file, content, extname4(file));
   }
   if (unverified > 0) opts.onNotice?.(unverifiedWarning(unverified));
@@ -18297,8 +18530,8 @@ async function runValidate(opts) {
 }
 
 // src/meta/commands/get.ts
-import { readFile as readFile11 } from "node:fs/promises";
-import { resolve as resolve19, extname as extname5 } from "node:path";
+import { readFile as readFile10 } from "node:fs/promises";
+import { resolve as resolve20, extname as extname5 } from "node:path";
 async function runGet(opts) {
   const cwd = opts.cwd ?? process.cwd();
   if (opts.fields.length === 0) {
@@ -18359,7 +18592,7 @@ async function runGet(opts) {
     base,
     offline: opts.offline ?? config?.offline ?? false,
     // A `{page}` manifest (0058) is read for exactly the pages this run reads.
-    pages: files.map((file) => resolve19(base, file))
+    pages: files.map((file) => resolve20(base, file))
   });
   const commands = commandsOf(config?.derive) ?? {};
   const deriving = opts.derived !== false;
@@ -18402,7 +18635,7 @@ async function runGet(opts) {
         const owned = declaredCollections.length === 0 ? {} : stampManifests(label, own2.data, declaredCollections, configDir ?? cwd, base, merged.marked, STAMPED_DATE_FIELDS);
         deriveInputs.push({
           label,
-          absPath: resolve19(base, label),
+          absPath: resolve20(base, label),
           content,
           extracted: own2,
           ...place !== void 0 ? { provenanceManifest: place } : {},
@@ -18443,7 +18676,7 @@ async function runGet(opts) {
     await readOne(STDIN_LABEL, opts.stdinContent ?? "", forced.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile11(resolve19(base, file), "utf8");
+    const content = await readFile10(resolve20(base, file), "utf8");
     await readOne(file, content, extname5(file));
   }
   if (deriving) {
@@ -18569,8 +18802,8 @@ function parseJsonPointer(pointer) {
 
 // src/meta/commands/schemas.ts
 import { existsSync as existsSync4 } from "node:fs";
-import { mkdir as mkdir3, readFile as readFile12 } from "node:fs/promises";
-import { dirname as dirname10, extname as extname6, isAbsolute as isAbsolute10, join as join10, relative as relative15, resolve as resolve20, sep as sep10 } from "node:path";
+import { mkdir as mkdir3, readFile as readFile11 } from "node:fs/promises";
+import { dirname as dirname10, extname as extname6, isAbsolute as isAbsolute10, join as join10, relative as relative15, resolve as resolve21, sep as sep10 } from "node:path";
 import { parseDocument as parseDocument8, parse as parseYaml6, stringify as stringify4 } from "yaml";
 function getSchemasInfo(registered2) {
   return {
@@ -18668,9 +18901,9 @@ async function runVendorSchema(opts) {
     );
   }
   const loaded = await loadConfig(opts.configPath, cwd);
-  const configPath = loaded?.path ?? resolve20(cwd, DEFAULT_CONFIG_NAME);
+  const configPath = loaded?.path ?? resolve21(cwd, DEFAULT_CONFIG_NAME);
   const configDir = loaded?.dir ?? cwd;
-  const absDir = resolve20(cwd, opts.dir ?? DEFAULT_VENDOR_DIR);
+  const absDir = resolve21(cwd, opts.dir ?? DEFAULT_VENDOR_DIR);
   const absFile = join10(absDir, vendorFileName(url));
   await assertNotIgnored(absFile, absDir, cwd, opts.onNotice);
   const fromConfig = posixRelative(configDir, absFile);
@@ -18689,7 +18922,7 @@ async function runVendorSchema(opts) {
   }
   let unchanged = false;
   if (existsSync4(absFile)) {
-    const current = await readFile12(absFile);
+    const current = await readFile11(absFile);
     unchanged = bytes.equals(current);
     if (!unchanged && !folded.replaced) {
       throw new DocmetaError(
@@ -18699,7 +18932,7 @@ async function runVendorSchema(opts) {
   }
   await mkdir3(absDir, { recursive: true });
   await writeFileAtomic(absFile, bytes);
-  const existing = loaded ? await readFile12(configPath, "utf8") : null;
+  const existing = loaded ? await readFile11(configPath, "utf8") : null;
   const section = loaded ? loaded.section : META_SECTION;
   const text2 = renderConfig(existing, folded.entries, section);
   reparseConfig(text2, posixRelative(cwd, configPath) || DEFAULT_CONFIG_NAME, section);
@@ -18846,7 +19079,7 @@ async function runInferSchema(opts) {
   }
   let absOut;
   if (opts.out !== void 0) {
-    absOut = resolve20(cwd, opts.out);
+    absOut = resolve21(cwd, opts.out);
     await assertNotIgnored(
       absOut,
       dirname10(absOut),
@@ -18892,7 +19125,7 @@ async function runInferSchema(opts) {
     configDir: configDir ?? cwd,
     base,
     offline: opts.offline ?? config?.offline ?? false,
-    pages: files.map((file) => resolve20(base, file))
+    pages: files.map((file) => resolve21(base, file))
   });
   const stats = /* @__PURE__ */ new Map();
   const unreadable2 = [];
@@ -18951,7 +19184,7 @@ async function runInferSchema(opts) {
     await scanOne(STDIN_LABEL, opts.stdinContent ?? "", forced.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile12(resolve20(base, file), "utf8");
+    const content = await readFile11(resolve21(base, file), "utf8");
     await scanOne(file, content, extname6(file));
   }
   for (const u of unreadable2) {
@@ -19012,8 +19245,8 @@ async function runInferSchema(opts) {
 // src/meta/commands/query.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
-import { mkdir as mkdir4, open as open2, readFile as readFile13, rename as rename3, rm as rm3 } from "node:fs/promises";
-import { dirname as dirname11, isAbsolute as isAbsolute11, resolve as resolve21, extname as extname7, sep as sep11 } from "node:path";
+import { mkdir as mkdir4, open as open2, readFile as readFile12, rename as rename3, rm as rm3 } from "node:fs/promises";
+import { dirname as dirname11, isAbsolute as isAbsolute11, resolve as resolve22, extname as extname7, sep as sep11 } from "node:path";
 
 // src/shared/prompt.ts
 import { createInterface } from "node:readline";
@@ -19272,7 +19505,7 @@ async function runQuery(opts) {
     base,
     offline: opts.offline ?? config?.offline ?? false,
     // A `{page}` manifest (0058) is read for exactly the pages this run reads.
-    pages: files.map((file) => resolve21(base, file))
+    pages: files.map((file) => resolve22(base, file))
   });
   const configuredKey = lazyKey(configFile, opts.env);
   let ensuredKey;
@@ -19370,10 +19603,10 @@ async function runQuery(opts) {
     await readOne(STDIN_LABEL, opts.stdinContent ?? "", ext);
   }
   for (const file of files) {
-    const content = await readFile13(resolve21(base, file), "utf8");
+    const content = await readFile12(resolve22(base, file), "utf8");
     await readOne(file, content, extname7(file));
   }
-  const db = opts.db === void 0 ? void 0 : { resolved: resolve21(cwd, opts.db), display: opts.db };
+  const db = opts.db === void 0 ? void 0 : { resolved: resolve22(cwd, opts.db), display: opts.db };
   const run2 = await runSql(sql, entries, {
     target: db,
     params: boundParams,
@@ -19516,7 +19749,7 @@ async function runSql(sql, entries, ctx) {
         const owned = ctx.declaredCollections.length === 0 ? {} : stampManifests(e.label, e.own.data, ctx.declaredCollections, manifestRoot, ctx.base, e.marked, STAMPED_DATE_FIELDS);
         return {
           label: e.label,
-          absPath: resolve21(ctx.base, e.label),
+          absPath: resolve22(ctx.base, e.label),
           content: e.content,
           extracted: e.own,
           ...place !== void 0 ? { provenanceManifest: place } : {},
@@ -19988,14 +20221,14 @@ function assertSchemaWriteWithin(ctx, abs) {
   );
 }
 function foldPath(p) {
-  const abs = resolve21(p);
+  const abs = resolve22(p);
   return process.platform === "win32" ? abs.toLowerCase() : abs;
 }
 function filePinsByPath(ctx) {
   const byPath = /* @__PURE__ */ new Map();
   for (const [ref, pin] of collectSchemaPins(ctx.config)) {
     if (classifyRef(ref).kind !== "file") continue;
-    byPath.set(foldPath(resolve21(ctx.cwd, ref)), pin);
+    byPath.set(foldPath(resolve22(ctx.cwd, ref)), pin);
   }
   return byPath;
 }
@@ -20024,13 +20257,13 @@ async function loadSetMembers(refs, ctx) {
       });
       continue;
     }
-    const abs = registered2?.path ?? resolve21(ctx.cwd, ref);
+    const abs = registered2?.path ?? resolve22(ctx.cwd, ref);
     const canon = foldPath(abs);
     if (seenFiles.has(canon)) continue;
     seenFiles.add(canon);
     let text2;
     try {
-      text2 = await readFile13(abs, "utf8");
+      text2 = await readFile12(abs, "utf8");
     } catch {
       throw new DocmetaError(
         `Schema file not found: "${ref}" (looked at ${abs}).`
@@ -20231,7 +20464,7 @@ async function planSchemaMutation(ops, entries, ctx) {
     const [, name2, ver] = target.builtinId.split(":");
     const safe = (s) => s.replace(/[^A-Za-z0-9._-]/g, "-");
     const forkName = `${safe(name2 ?? "schema")}-${safe(ver ?? "0")}.local.json`;
-    schemaAbs = resolve21(ctx.configDir ?? ctx.cwd, "schemas", forkName);
+    schemaAbs = resolve22(ctx.configDir ?? ctx.cwd, "schemas", forkName);
     assertSchemaWriteWithin(ctx, schemaAbs);
     if (existsSync5(schemaAbs)) {
       throw new DocmetaError(
@@ -20387,7 +20620,7 @@ async function planConfigEdit(ctx, edit, runRefs) {
   if (configPath === void 0 || configDir === void 0) {
     return { changes: [], repointed: false };
   }
-  const text2 = await readFile13(configPath, "utf8");
+  const text2 = await readFile12(configPath, "utf8");
   const doc = parseDocument10(stripBom2(text2));
   const display = displayPath(ctx, configPath);
   const rawRefOf = (item) => {
@@ -20398,7 +20631,7 @@ async function planConfigEdit(ctx, edit, runRefs) {
     }
     return void 0;
   };
-  const rebaseRaw = (raw) => classifyRef(raw).kind === "file" && !isAbsolute11(raw) ? resolve21(configDir, raw) : raw;
+  const rebaseRaw = (raw) => classifyRef(raw).kind === "file" && !isAbsolute11(raw) ? resolve22(configDir, raw) : raw;
   const wantSet = runRefs.map(rebaseRaw).sort().join("\n");
   const seqResolvesToRunSet = (node) => {
     if (!isSeq5(node)) return false;
@@ -20443,7 +20676,7 @@ async function planConfigEdit(ctx, edit, runRefs) {
       if (!isMap10(item)) continue;
       const raw = rawRefOf(item);
       if (raw === void 0 || classifyRef(raw).kind !== "file") continue;
-      const abs = isAbsolute11(raw) ? raw : resolve21(configDir, raw);
+      const abs = isAbsolute11(raw) ? raw : resolve22(configDir, raw);
       if (foldPath(abs) !== wantPath) continue;
       pinFrom = item.get("integrity");
       item.set("integrity", edit.integrity.value);
@@ -20672,7 +20905,7 @@ function buildChanges(diff, entries, sentinel, ctx, renameHints = [], booleanAdd
         `"${file}": no writable format for that extension.`
       );
     }
-    if (existsSync5(resolve21(ctx.base, file))) {
+    if (existsSync5(resolve22(ctx.base, file))) {
       throw new DocmetaError(
         `"${file}" already exists; INSERT creates new files only.`
       );
@@ -20691,7 +20924,7 @@ function buildChanges(diff, entries, sentinel, ctx, renameHints = [], booleanAdd
         `"${from}" -> "${to}": a rename may not change the extension.`
       );
     }
-    if (existsSync5(resolve21(ctx.base, to))) {
+    if (existsSync5(resolve22(ctx.base, to))) {
       throw new DocmetaError(
         `"${to}" already exists; the rename would overwrite it.`
       );
@@ -20725,9 +20958,9 @@ function validateNewPath(p, base) {
   if (p.split(/[\\/]/).some((segment) => segment === "..")) {
     refuse("it traverses upward");
   }
-  const abs = resolve21(base, p);
-  if (abs === resolve21(base)) refuse("it points at the corpus root, not a file");
-  if (!abs.startsWith(resolve21(base) + sep11)) refuse("it escapes the corpus");
+  const abs = resolve22(base, p);
+  if (abs === resolve22(base)) refuse("it points at the corpus root, not a file");
+  if (!abs.startsWith(resolve22(base) + sep11)) refuse("it escapes the corpus");
 }
 function refuseJoinFieldChanges(changes, entries, ctx) {
   const index = ctx.externalMetadata;
@@ -20802,7 +21035,7 @@ function runPages(changes, entries, base) {
   const labels = new Set(entries.map((e) => e.label));
   for (const c of changes) if (!("schema" in c) && !("config" in c)) labels.add(c.file);
   labels.delete(STDIN_LABEL);
-  return [...labels].map((label) => resolve21(base, label));
+  return [...labels].map((label) => resolve22(base, label));
 }
 async function planManifestEdits(changes, entries, ctx, renameHints) {
   for (const c of changes) {
@@ -20854,7 +21087,7 @@ async function planManifestEdits(changes, entries, ctx, renameHints) {
       let text2;
       let expected;
       try {
-        text2 = await readFile13(home.absPath, "utf8");
+        text2 = await readFile12(home.absPath, "utf8");
         expected = text2;
       } catch (err) {
         if (!home.perPage || !isMissing(err)) {
@@ -20890,7 +21123,7 @@ async function planManifestEdits(changes, entries, ctx, renameHints) {
     );
     const index = await leftOut;
     if (index === null) return void 0;
-    const abs = resolve21(ctx.base, file);
+    const abs = resolve22(ctx.base, file);
     const named = index.entries.find(
       (e) => e.join === PATH_JOIN2 && e.abs === abs && excluded.includes(e.collection)
     );
@@ -20937,7 +21170,7 @@ async function planManifestEdits(changes, entries, ctx, renameHints) {
       continue;
     }
     if ("renamed" in c) {
-      const supplied = ctx.externalMetadata?.byPath.get(resolve21(ctx.base, c.file));
+      const supplied = ctx.externalMetadata?.byPath.get(resolve22(ctx.base, c.file));
       const seen = /* @__PURE__ */ new Set();
       for (const [key, sv] of supplied ?? []) {
         if (seen.has(sv.file) || !ctx.memberships(c.file).includes(sv.collection)) continue;
@@ -21245,14 +21478,14 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
   const pendingWrites = [];
   const pendingRenames = [];
   for (const [label, ops] of grouped) {
-    const path = resolve21(ctx.base, label);
+    const path = resolve22(ctx.base, label);
     if (ops.renamedTo !== void 0) {
       if (!existsSync5(path)) {
         throw new DocmetaError(
           `"${label}" is gone from disk since it was read; re-run the query.`
         );
       }
-      const toDisk = resolve21(ctx.base, ops.renamedTo);
+      const toDisk = resolve22(ctx.base, ops.renamedTo);
       if (existsSync5(toDisk)) {
         throw new DocmetaError(
           `"${ops.renamedTo}" appeared on disk since the plan; re-run the query.`
@@ -21290,7 +21523,7 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
     }
     const entry = byLabel.get(label);
     if (!entry) throw new DocmetaError(`No loaded entry for "${label}".`);
-    const content = await readFile13(path, "utf8");
+    const content = await readFile12(path, "utf8");
     const members = ctx.memberships(label);
     const current = (await mergeWithMarks(
       label,
@@ -21362,7 +21595,7 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
     }
     let now;
     try {
-      now = await readFile13(w.path, "utf8");
+      now = await readFile12(w.path, "utf8");
     } catch {
       now = void 0;
     }
@@ -21375,7 +21608,7 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
   for (const m of manifestWrites) {
     let now;
     try {
-      now = await readFile13(m.path, "utf8");
+      now = await readFile12(m.path, "utf8");
     } catch {
       now = null;
     }
@@ -21508,19 +21741,17 @@ function skipExpression(sql, from) {
 }
 
 // src/meta/commands/fill.ts
-import { readFile as readFile16 } from "node:fs/promises";
-import { resolve as resolve23, extname as extname9, join as join11 } from "node:path";
+import { readFile as readFile15 } from "node:fs/promises";
+import { resolve as resolve24, extname as extname9, join as join11 } from "node:path";
 import {
   completeValidatedJSON,
   makeProvider,
-  resolveProviderIdentityAsync,
-  DEFAULT_MODELS,
   JsonCache,
   buildCacheKey,
   sha256,
   pricingFor,
   costOfUsage,
-  InferenceError
+  InferenceError as InferenceError2
 } from "@hawkeyexl/inference";
 
 // src/meta/commands/fill-projection.ts
@@ -21930,8 +22161,8 @@ function single(alternatives2) {
 }
 
 // src/meta/commands/fill-hints.ts
-import { readFile as readFile14 } from "node:fs/promises";
-import { extname as extname8, resolve as resolve22 } from "node:path";
+import { readFile as readFile13 } from "node:fs/promises";
+import { extname as extname8, resolve as resolve23 } from "node:path";
 
 // src/shared/reference-fields.ts
 var CONCEPT_FIELDS = [["concepts"], ["graph", "concepts"]];
@@ -22017,7 +22248,7 @@ function pageIdReader(opts) {
     return held;
   };
   return async (file, names) => {
-    const self = resolve22(file);
+    const self = resolve23(file);
     const ids = /* @__PURE__ */ new Set();
     for (const name2 of names) {
       const collection = opts.collections.find((c) => c.name === name2);
@@ -22041,10 +22272,10 @@ async function readIds(collection, opts) {
     if (!isMember(collection, file)) continue;
     const extractor = extractorForExtension(extname8(file));
     if (extractor === void 0) continue;
-    const path = resolve22(opts.configDir, file);
+    const path = resolve23(opts.configDir, file);
     let id;
     try {
-      id = extractor.extract(await readFile14(path, "utf8"), file).data.id;
+      id = extractor.extract(await readFile13(path, "utf8"), file).data.id;
     } catch {
       continue;
     }
@@ -22063,7 +22294,7 @@ function termLabelSource() {
 }
 
 // src/meta/core/manifest-writes.ts
-import { readFile as readFile15 } from "node:fs/promises";
+import { readFile as readFile14 } from "node:fs/promises";
 var manifestCodec = {
   apply(text2, op) {
     const where = { entry: op.entry, key: op.key, join: op.join, file: op.file };
@@ -22079,7 +22310,7 @@ function applyManifestOp(text2, op) {
 async function holdManifestFile(path, file, perPage = false) {
   let before;
   try {
-    before = await readFile15(path, "utf8");
+    before = await readFile14(path, "utf8");
   } catch (err) {
     if (perPage && isMissing(err)) return heldManifest(path, file, "", true);
     throw new DocmetaError(`Manifest ${file} could not be read: ${errorMessage(err)}`);
@@ -22096,7 +22327,7 @@ async function settleManifest(held, io = {}) {
     codec: manifestCodec,
     // A per-page manifest (proposal 0058) may be the first file in its directory.
     write: io.write ?? ((at2, text2) => writeFileAtomic(at2, text2, { createParents: true })),
-    read: io.read ?? ((at2) => readFile15(at2, "utf8")),
+    read: io.read ?? ((at2) => readFile14(at2, "utf8")),
     toError: (message) => new DocmetaError(message)
   });
   rebaseline(held);
@@ -22253,12 +22484,56 @@ function buildUserPrompt(params, before = []) {
   ].join("\n");
 }
 
+// src/meta/core/meta-provenance.ts
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeMetaProvenance(held, model, key, proposed) {
+  if (held !== void 0 && !Array.isArray(held)) return void 0;
+  const list2 = held === void 0 ? [] : [...held];
+  const at2 = list2.findIndex((e) => isPlainRecord(e) && e["generated-by"] === model);
+  const prior = list2[at2];
+  const kept = isPlainRecord(prior) ? prior : {};
+  const priorNames = kept[key];
+  const names = Array.isArray(priorNames) ? priorNames.filter((p) => typeof p === "string") : [];
+  const confidence = {};
+  if (isPlainRecord(kept.confidence)) {
+    for (const [k, v] of Object.entries(kept.confidence)) {
+      if (typeof v === "number") confidence[k] = v;
+    }
+  }
+  for (const p of proposed) {
+    if (!names.includes(p.name)) names.push(p.name);
+    confidence[p.name] = p.confidence;
+  }
+  const entry = {
+    ...kept,
+    "generated-by": model,
+    [key]: names,
+    confidence
+  };
+  if (at2 === -1) list2.push(entry);
+  else list2[at2] = entry;
+  return { list: list2, entry, names };
+}
+function metaProvenanceEntries(value) {
+  if (!Array.isArray(value)) return [];
+  const strings = (list2) => Array.isArray(list2) ? list2.filter((s) => typeof s === "string") : [];
+  const out = [];
+  for (const item of value) {
+    if (!isPlainRecord(item)) continue;
+    const machine = item["generated-by"];
+    if (typeof machine !== "string" || machine === "") continue;
+    out.push({ "generated-by": machine, fields: strings(item.fields), evals: strings(item.evals) });
+  }
+  return out;
+}
+
 // src/meta/commands/fill.ts
 var META_PROVENANCE_KEY = "meta-provenance";
 var PROVENANCE_KEYS = /* @__PURE__ */ new Set(["provenance", META_PROVENANCE_KEY]);
 var DEFAULT_THRESHOLD = 0.7;
 var DEFAULT_CONCURRENCY = 4;
-var DEFAULT_PROVIDER = "auto";
 var CACHE_DIR = ".manni/meta/cache";
 function looksLikeOverflow(message) {
   return /context|too long|too large|token limit|maximum.*tokens|exceeds/i.test(
@@ -22339,13 +22614,19 @@ async function runFill(opts) {
   const dryRun = Boolean(opts.dryRun);
   const only = opts.fields != null ? new Set(opts.fields) : void 0;
   const managed = new Set(managedFields(config?.derive));
-  const requestedProvider = opts.provider ?? config?.fill?.provider ?? DEFAULT_PROVIDER;
-  const providerName = opts.local === true && requestedProvider === "auto" ? "llama-cpp" : requestedProvider;
-  const model = opts.model ?? config?.fill?.model;
-  const spec = { provider: providerName, model: model ?? null };
-  assertKnownProvider(providerName);
-  assertModelHasProvider(providerName, model);
-  if (opts.local === true) assertLocalProvider(providerName);
+  const flags = { provider: opts.provider, model: opts.model, local: opts.local };
+  assertLocalFlag(flags, toDocmetaError);
+  const family = configFile?.providers ?? {};
+  const selection = selectProvider(flags, [
+    { provider: config?.fill?.provider, model: config?.fill?.model, origin: "fill.provider" },
+    { provider: family.provider, model: family.model, origin: "providers.provider" }
+  ]);
+  const { provider: providerName, model } = selection;
+  assertKnownProvider2(providerName);
+  assertModelHasProvider2(providerName, model);
+  const replaced = localNotice(selection);
+  if (replaced !== void 0) opts.onNotice?.(replaced);
+  const spec = providerSpecFor(family, { provider: providerName, model: model ?? null });
   const fileInputs = inputs.filter((i) => i !== STDIN_TOKEN);
   const allowEmpty = opts.allowEmpty ?? config?.allowEmpty;
   const fillExts = opts.exts ?? forcedExtractor?.extensions;
@@ -22381,14 +22662,9 @@ async function runFill(opts) {
     identity = { provider: injected.provider(), model: injected.modelName() };
     construct = () => injected;
   } else {
-    const resolved = await resolveIdentity(spec);
-    if (opts.local === true) assertLocalProvider(resolved.provider);
+    const resolved = await resolveIdentity2(spec);
     identity = resolved;
-    const concrete = {
-      ...spec,
-      provider: resolved.provider,
-      model: resolved.model
-    };
+    const concrete = providerSpecFor(family, resolved);
     construct = () => makeProvider(concrete);
   }
   let provider;
@@ -22398,7 +22674,7 @@ async function runFill(opts) {
         provider = construct();
       } catch (err) {
         throw new DocmetaError(
-          err instanceof InferenceError ? err.message : `Could not construct the "${providerName}" provider: ${errorMessage(err)}`
+          err instanceof InferenceError2 ? err.message : `Could not construct the "${providerName}" provider: ${errorMessage(err)}`
         );
       }
     }
@@ -22432,7 +22708,7 @@ async function runFill(opts) {
     base,
     offline: opts.offline ?? config?.offline ?? false,
     // A `{page}` manifest (0058) is read for exactly the pages this run fills.
-    pages: files.map((file) => resolve23(base, file))
+    pages: files.map((file) => resolve24(base, file))
   });
   const mergeMembersFor = (label) => memberOf(runConfig.declaredCollections, configDir ?? cwd, base, label);
   let externalMetadata = await loadManifests();
@@ -22465,17 +22741,17 @@ async function runFill(opts) {
     const keys = new Set(candidates.map((c) => c.key));
     const wants = (fields) => fields.some(([key]) => key !== void 0 && keys.has(key));
     const termIndex = wants(TERM_FIELDS) ? await (termbase ??= readTermbase()) : void 0;
-    const pages2 = wants(PAGE_FIELDS) ? await pageIds(resolve23(base, label), mergeMembersFor(label)) : [];
+    const pages2 = wants(PAGE_FIELDS) ? await pageIds(resolve24(base, label), mergeMembersFor(label)) : [];
     const hints = fieldHints(candidates, {
       terms: termIndex === void 0 ? void 0 : offered(termIndex.labels),
       pages: offered(pages2)
     });
     return { hints, termIndex };
   };
-  const noticed = /* @__PURE__ */ new Set();
-  const noticeOnce = opts.onNotice === void 0 ? void 0 : (message) => {
-    if (noticed.has(message)) return;
-    noticed.add(message);
+  const noticed2 = /* @__PURE__ */ new Set();
+  const noticeOnce2 = opts.onNotice === void 0 ? void 0 : (message) => {
+    if (noticed2.has(message)) return;
+    noticed2.add(message);
     opts.onNotice?.(message);
   };
   const ctx = relocationContext(runConfig, {
@@ -22487,7 +22763,7 @@ async function runFill(opts) {
     ...opts.as !== void 0 ? { as: opts.as } : {},
     ...opts.respectGitignore !== void 0 ? { respectGitignore: opts.respectGitignore } : {},
     ...opts.env !== void 0 ? { env: opts.env } : {},
-    ...noticeOnce !== void 0 ? { onNotice: noticeOnce } : {}
+    ...noticeOnce2 !== void 0 ? { onNotice: noticeOnce2 } : {}
   });
   const heldManifests = /* @__PURE__ */ new Map();
   const holding = /* @__PURE__ */ new Map();
@@ -22505,7 +22781,7 @@ async function runFill(opts) {
   };
   const restorePage = async (label, before) => {
     try {
-      await writeFileAtomic(resolve23(base, label), before);
+      await writeFileAtomic(resolve24(base, label), before);
       return `${label} was restored.`;
     } catch (err) {
       return `${label} could not be restored: ${errorMessage(err)}. Restore it from version control.`;
@@ -22599,7 +22875,7 @@ async function runFill(opts) {
         // gets written — if anything, a stronger reason to guard it.
         fileBase: cwd,
         trustRoot,
-        onNotice: noticeOnce
+        onNotice: noticeOnce2
       });
     } catch (err) {
       return errorResult(label, extractor.name, errorMessage(err));
@@ -22655,7 +22931,7 @@ async function runFill(opts) {
     }));
     const candidates = proposed.filter((c) => !managedHere.has(c.key));
     const destinations = /* @__PURE__ */ new Map();
-    const flags = [];
+    const flags2 = [];
     let metaHome;
     if (label !== "<stdin>" && candidates.length > 0) {
       const located = { ...view.data };
@@ -22685,7 +22961,7 @@ async function runFill(opts) {
           if (!meta) destinations.set(key, { ...home, entry: home.entry });
           continue;
         }
-        if (prefs.get(key)?.location === "external") flags.push({ label, key, home: home.home });
+        if (prefs.get(key)?.location === "external") flags2.push({ label, key, home: home.home });
       }
     }
     const inPlace = view.plain.flatMap((pointer) => {
@@ -22739,7 +23015,7 @@ async function runFill(opts) {
       sealedCandidates,
       destinations,
       metaHome,
-      flags
+      flags: flags2
     };
   };
   const finishOne = async (ready) => {
@@ -23039,7 +23315,12 @@ async function runFill(opts) {
     if (writable.length > 0) {
       const metaManifest = metaHome?.kind === "manifest" ? metaHome : void 0;
       const metaEntry = metaManifest?.entry;
-      const mergedProvenance = metaHome?.kind === "url" || metaManifest !== void 0 && metaEntry === void 0 ? void 0 : mergeMetaProvenance(extracted.data[META_PROVENANCE_KEY], identity.model, writable);
+      const mergedProvenance = metaHome?.kind === "url" || metaManifest !== void 0 && metaEntry === void 0 ? void 0 : mergeMetaProvenance(
+        extracted.data[META_PROVENANCE_KEY],
+        identity.model,
+        "fields",
+        writable.map((f) => ({ name: f.field, confidence: f.confidence }))
+      );
       if (metaHome?.kind === "url") {
         metaProvenance = { written: false, skipReason: "manifest-owned", manifest: metaHome.file };
       } else if (metaManifest !== void 0 && metaEntry === void 0) {
@@ -23054,12 +23335,12 @@ async function runFill(opts) {
         metaWrite = { value: mergedProvenance.list, home: { ...metaManifest, entry: metaEntry } };
         metaProvenance = {
           written: true,
-          entry: mergedProvenance.entry,
+          entry: { ...mergedProvenance.entry, fields: mergedProvenance.names },
           destination: metaManifest.file
         };
       } else {
         patch[META_PROVENANCE_KEY] = mergedProvenance.list;
-        metaProvenance = { written: true, entry: mergedProvenance.entry };
+        metaProvenance = { written: true, entry: { ...mergedProvenance.entry, fields: mergedProvenance.names } };
       }
     }
     const entryWrites = [];
@@ -23128,7 +23409,7 @@ async function runFill(opts) {
     const changed = next !== content || manifestChanged;
     const pageWritten = next !== content && !dryRun && label !== "<stdin>";
     if (pageWritten) {
-      await writeFileAtomic(resolve23(base, label), next);
+      await writeFileAtomic(resolve24(base, label), next);
     }
     if (manifestChanged) {
       const perManifest = /* @__PURE__ */ new Map();
@@ -23160,7 +23441,7 @@ async function runFill(opts) {
   const prepareAll = async () => ({
     stdin: usingStdin ? await prepareOne("<stdin>", opts.stdinContent ?? "", forcedExtractor?.extensions[0] ?? "") : void 0,
     files: await mapConcurrent(files, concurrency, async (file) => {
-      const content = await readFile16(resolve23(base, file), "utf8");
+      const content = await readFile15(resolve24(base, file), "utf8");
       return prepareOne(file, content, extname9(file));
     })
   });
@@ -23213,31 +23494,6 @@ function topKey(instancePath) {
   return seg.replace(/~1/g, "/").replace(/~0/g, "~");
 }
 var keyOf = (f) => topKey(f.field);
-function isPlainRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function mergeMetaProvenance(held, model, written) {
-  if (held !== void 0 && !Array.isArray(held)) return void 0;
-  const list2 = held === void 0 ? [] : [...held];
-  const at2 = list2.findIndex((e) => isPlainRecord(e) && e["generated-by"] === model);
-  const prior = list2[at2];
-  const kept = isPlainRecord(prior) ? prior : {};
-  const fields = Array.isArray(kept.fields) ? kept.fields.filter((p) => typeof p === "string") : [];
-  const confidence = {};
-  if (isPlainRecord(kept.confidence)) {
-    for (const [k, v] of Object.entries(kept.confidence)) {
-      if (typeof v === "number") confidence[k] = v;
-    }
-  }
-  for (const f of written) {
-    if (!fields.includes(f.field)) fields.push(f.field);
-    confidence[f.field] = f.confidence;
-  }
-  const entry = { ...kept, "generated-by": model, fields, confidence };
-  if (at2 === -1) list2.push(entry);
-  else list2[at2] = entry;
-  return { list: list2, entry };
-}
 async function addsFindings(validate, without, list2) {
   const identity = (e) => JSON.stringify([e.schema, e.instancePath, e.keyword, e.subject ?? null, e.message]);
   const before = /* @__PURE__ */ new Map();
@@ -23550,34 +23806,15 @@ function requireNumber(value, name2, bounds) {
   }
   return value;
 }
-var PROVIDERS = /* @__PURE__ */ new Set([...Object.keys(DEFAULT_MODELS), "auto"]);
-function assertLocalProvider(name2) {
-  if (name2 === "llama-cpp" || name2 === "mock") return;
-  if (name2 === "auto") return;
-  throw new DocmetaError(
-    name2 === "claude-cli" ? `--local cannot use "claude-cli": the CLI runs on this machine but its inference does not. Use --provider llama-cpp.` : `--local cannot use "${name2}", which sends document content to a hosted API. Use --provider llama-cpp, or drop --local.`
-  );
-}
-function assertKnownProvider(name2) {
-  if (PROVIDERS.has(name2)) return;
-  throw new DocmetaError(
-    `Unknown provider "${name2}". Available: ${[...PROVIDERS].join(", ")}.`
-  );
+var toDocmetaError = (message) => new DocmetaError(message);
+function assertKnownProvider2(name2) {
+  assertKnownProvider(name2, toDocmetaError);
 }
-function assertModelHasProvider(name2, model) {
-  if (name2 !== "auto" || model == null) return;
-  throw new DocmetaError(
-    `Model "${model}" was given without a provider: a model name does not say which provider owns it. Set --provider or fill.provider to one of ${Object.keys(DEFAULT_MODELS).join(", ")}, or drop the model to take the detected provider's default.`
-  );
+function assertModelHasProvider2(name2, model) {
+  assertModelHasProvider(name2, model, "fill.provider", toDocmetaError);
 }
-async function resolveIdentity(spec) {
-  try {
-    return await resolveProviderIdentityAsync(spec);
-  } catch (err) {
-    throw new DocmetaError(
-      err instanceof InferenceError ? err.message : `Could not resolve provider "${spec.provider}": ${errorMessage(err)}`
-    );
-  }
+function resolveIdentity2(spec) {
+  return resolveIdentity(spec, toDocmetaError);
 }
 function summarize(results, costUsd, cached) {
   let written = 0;
@@ -23622,8 +23859,8 @@ async function mapConcurrent(items2, limit, fn) {
 }
 
 // src/meta/commands/derive.ts
-import { readFile as readFile17 } from "node:fs/promises";
-import { extname as extname10, relative as relative16, resolve as resolve24, sep as sep12 } from "node:path";
+import { readFile as readFile16 } from "node:fs/promises";
+import { extname as extname10, relative as relative16, resolve as resolve25, sep as sep12 } from "node:path";
 var GENERATED_BY_ENV = "MANNI_GENERATED_BY";
 var SOURCE_HINT = "narrow --sources or --fields";
 async function runDerive(opts) {
@@ -23741,7 +23978,7 @@ async function runDerive(opts) {
   const files = fromCollections ? retainMembers(walked, membersFor) : walked;
   const rangesByPage = /* @__PURE__ */ new Map();
   for (const t of targets) {
-    const label = relative16(base, resolve24(base, t.page)).split(sep12).join("/");
+    const label = relative16(base, resolve25(base, t.page)).split(sep12).join("/");
     if (!files.includes(label)) {
       throw new DocmetaError(
         `${t.target} does not name one file that derive reads; a range names lines of one file.`
@@ -23766,7 +24003,7 @@ async function runDerive(opts) {
     const loaded2 = /* @__PURE__ */ new Map();
     const errors2 = /* @__PURE__ */ new Map();
     for (const label of files) {
-      const absPath = resolve24(base, label);
+      const absPath = resolve25(base, label);
       const extractor = forcedExtractor ?? extractorForExtension(extname10(label));
       if (!extractor) {
         errors2.set(label, {
@@ -23775,7 +24012,7 @@ async function runDerive(opts) {
         });
         continue;
       }
-      const content = await readFile17(absPath, "utf8");
+      const content = await readFile16(absPath, "utf8");
       const elements = resolveElements(label, config, membersFor(label));
       try {
         loaded2.set(label, {
@@ -23818,7 +24055,7 @@ async function runDerive(opts) {
       runFields = union2;
     }
     const provenanceRoot = configDir ?? cwd;
-    const pages2 = files.map((label) => resolve24(base, label));
+    const pages2 = files.map((label) => resolve25(base, label));
     const manifests = runFields.includes(PROVENANCE_FIELD) ? provenanceManifests(declaredCollections, provenanceRoot, base) : [];
     const provenanceCollections = declaredCollections.map((c) => ({
       ...c,
@@ -23910,10 +24147,10 @@ async function runDerive(opts) {
     const members = memberOf(prepared.provenanceCollections, root, base, doc.label);
     return (await mergeWithMarks(doc.label, doc.extracted, prepared.provenanceIndex, members, base, { marks })).extracted.data[PROVENANCE_FIELD];
   };
-  const noticed = /* @__PURE__ */ new Set();
-  const noticeOnce = opts.onNotice === void 0 ? void 0 : (message) => {
-    if (noticed.has(message)) return;
-    noticed.add(message);
+  const noticed2 = /* @__PURE__ */ new Set();
+  const noticeOnce2 = opts.onNotice === void 0 ? void 0 : (message) => {
+    if (noticed2.has(message)) return;
+    noticed2.add(message);
     opts.onNotice?.(message);
   };
   const markFields = async (doc, record) => {
@@ -23944,7 +24181,7 @@ async function runDerive(opts) {
         // `$schema`, since that schema decides what gets encrypted.
         fileBase: cwd,
         trustRoot,
-        onNotice: noticeOnce
+        onNotice: noticeOnce2
       });
     } catch (err) {
       return { error: errorMessage(err) };
@@ -24005,7 +24242,7 @@ async function runDerive(opts) {
     validator,
     ...opts.noConfig === true ? { noConfig: true } : {},
     ...opts.env !== void 0 ? { env: opts.env } : {},
-    ...noticeOnce !== void 0 ? { onNotice: noticeOnce } : {}
+    ...noticeOnce2 !== void 0 ? { onNotice: noticeOnce2 } : {}
   });
   const externalWrites = async () => {
     const out = [];
@@ -24988,15 +25225,28 @@ export {
   generateEncryptionKey,
   encryptValue,
   decryptValue,
+  ToolError,
+  errorMessage,
+  assertKnownProvider,
+  assertModelHasProvider,
+  PROVIDERS_KEY,
+  parseProviders,
+  LOCAL_FLAG_HELP,
+  assertLocalFlag,
+  selectProvider,
+  localNotice,
+  providerSpecFor,
+  resolveIdentity,
   findGitRoot,
   valeConfigPath,
   ditaOtHome,
   programName,
   warn,
   notice,
-  ToolError,
-  errorMessage,
+  noticeOnce,
   FAMILY_CONFIG_NAMES,
+  findConfigFileSync,
+  readConfigFileSync,
   findConfigFile,
   readConfigFile,
   findFamilyConfigFile,
@@ -25058,7 +25308,8 @@ export {
   DEFAULT_TTL_HOURS,
   schemaCacheDir,
   SchemaCache,
-  __default34 as __default,
+  __default31 as __default,
+  __default34 as __default2,
   listBuiltins,
   classifyRef,
   fetchSchemaBytes,
@@ -25082,6 +25333,7 @@ export {
   staleFindings,
   LEGACY_CONFIG_NAMES,
   parseConfig,
+  schemaTrustRoot,
   loadConfig,
   resolveRunConfig,
   renderSarif,
@@ -25124,19 +25376,26 @@ export {
   spliceManifestValue,
   readManifestValue,
   removeManifestKey,
+  isParamName,
+  memberOf,
   LOCATION_KEYWORD,
   LOCATION_EXTERNAL_SCHEMA,
   LOCATION_PAGE_SCHEMA,
   Validator,
+  pageMarks,
+  marksValidator,
   configMarks,
-  isParamName,
-  memberOf,
   relocateFailed,
   relocationContext,
   keyHome,
   planRelocation,
   applyRelocation,
   offerPrompt,
+  offerExternalHomes,
+  externalWriteWarnings,
+  mergeMetaProvenance,
+  metaProvenanceEntries,
+  provenanceEntries,
   REVIEW_CACHE_DIR,
   REVIEW_CACHE_VERSION,
   ReviewCache,
@@ -25195,4 +25454,4 @@ export {
   renderQuery,
   renderQueryCsv
 };
-//# sourceMappingURL=chunk-TQG3WCJY.js.map
+//# sourceMappingURL=chunk-I57KBF45.js.map