@hawkeyexl/manni 0.2.0 → 1.0.0

package/dist/{chunk-2OALUJV2.js → chunk-L7HN3AWA.js}

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@hawkeyexl/manni",
-  version: "0.2.0",
+  version: "1.0.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: {
@@ -117,6 +117,276 @@ var package_default = {
   }
 };
 
+// src/shared/collections.ts
+import picomatch2 from "picomatch";
+
+// src/shared/globs.ts
+import picomatch from "picomatch";
+var matcherCache = /* @__PURE__ */ new Map();
+function matchesFileGlob(relPath, glob) {
+  const key = JSON.stringify(glob);
+  let m = matcherCache.get(key);
+  if (!m) {
+    m = picomatch(glob, { dot: true });
+    matcherCache.set(key, m);
+  }
+  return m(relPath.replace(/\\/g, "/"));
+}
+
+// src/shared/collections.ts
+var COLLECTION_KEYS = [
+  "name",
+  "paths",
+  "exclude",
+  "url",
+  "externalMetadata"
+];
+var EXTERNAL_METADATA_KEYS = ["file", "keys", "tokenEnv", "join"];
+var SCHEMA_KEY = "$schema";
+var STDIN = "<stdin>";
+function isUrlRef(ref) {
+  return /^https?:\/\//i.test(ref);
+}
+function externalMetadataUrlProblem(url) {
+  let parsed2;
+  try {
+    parsed2 = new URL(url);
+  } catch {
+    return "is not a valid URL";
+  }
+  if (parsed2.username !== "" || parsed2.password !== "") {
+    return 'carries a credential in the URL; put the token in an environment variable and name it with "tokenEnv"';
+  }
+  if (parsed2.protocol === "https:") return null;
+  if (parsed2.protocol === "http:" && isLoopback(parsed2.hostname)) return null;
+  if (parsed2.protocol === "http:") {
+    return "is plain http://; a bearer token over plaintext is a leak, and a public manifest is served over https too";
+  }
+  return `has the unsupported scheme "${parsed2.protocol}"`;
+}
+function isLoopback(host) {
+  return host === "localhost" || host === "127.0.0.1" || host === "[::1]" || host === "::1" || host.startsWith("127.");
+}
+function rejectUnknownKeys(raw, allowed, where, source, toError) {
+  for (const key of Object.keys(raw)) {
+    if (!allowed.includes(key)) {
+      throw toError(
+        `${source}: ${where} has unknown key "${key}". Supported keys: ${allowed.join(", ")}.`
+      );
+    }
+  }
+}
+function isMapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function parseCollections(raw, source, toError) {
+  if (!Array.isArray(raw)) {
+    throw toError(`${source}: "collections" must be a list.`);
+  }
+  if (raw.length === 0) {
+    throw toError(
+      `${source}: "collections" must name at least one collection; remove the key if there are none.`
+    );
+  }
+  const taken = /* @__PURE__ */ new Map();
+  return raw.map((entry, i) => {
+    const where = `collections[${i}]`;
+    if (!isMapping(entry)) {
+      throw toError(`${source}: ${where} must be a mapping.`);
+    }
+    rejectUnknownKeys(entry, COLLECTION_KEYS, where, source, toError);
+    if (!isNonEmptyString(entry.name)) {
+      throw toError(`${source}: ${where}.name must be a non-empty string.`);
+    }
+    const name2 = entry.name;
+    const folded = name2.toLowerCase();
+    if (folded === "docs") {
+      throw toError(
+        `${source}: ${where}.name "${name2}" collides with the docs table every query reads. Pick another name, such as "site" or "pages".`
+      );
+    }
+    if (folded.startsWith("sqlite_")) {
+      throw toError(
+        `${source}: ${where}.name "${name2}" starts with "sqlite_", which SQLite reserves for its own objects. Pick another name.`
+      );
+    }
+    const owner = taken.get(folded);
+    if (owner !== void 0) {
+      throw toError(
+        `${source}: ${where}.name "${name2}" is already taken by collections[${owner}]; names are compared case-insensitively because they become SQL views.`
+      );
+    }
+    taken.set(folded, i);
+    if (!Array.isArray(entry.paths) || entry.paths.length === 0 || entry.paths.some((p) => !isNonEmptyString(p))) {
+      throw toError(
+        `${source}: ${where}.paths must be a non-empty list of files, directories or globs.`
+      );
+    }
+    const paths = entry.paths;
+    let exclude = [];
+    if (entry.exclude !== void 0) {
+      if (!Array.isArray(entry.exclude) || entry.exclude.some((g) => !isNonEmptyString(g))) {
+        throw toError(`${source}: ${where}.exclude must be a list of globs.`);
+      }
+      exclude = entry.exclude;
+    }
+    let url;
+    if (entry.url !== void 0) {
+      if (typeof entry.url !== "string" || !isHttpUrl(entry.url)) {
+        throw toError(`${source}: ${where}.url must be an http(s) URL.`);
+      }
+      url = entry.url;
+    }
+    let externalMetadata = [];
+    if (entry.externalMetadata !== void 0) {
+      if (!Array.isArray(entry.externalMetadata)) {
+        throw toError(`${source}: ${where}.externalMetadata must be a list.`);
+      }
+      externalMetadata = parseExternalMetadata(
+        entry.externalMetadata,
+        where,
+        source,
+        toError
+      );
+    }
+    return {
+      name: name2,
+      paths,
+      exclude,
+      externalMetadata,
+      ...url === void 0 ? {} : { url }
+    };
+  });
+}
+function isHttpUrl(value) {
+  let parsed2;
+  try {
+    parsed2 = new URL(value);
+  } catch {
+    return false;
+  }
+  return parsed2.protocol === "http:" || parsed2.protocol === "https:";
+}
+function parseExternalMetadata(raw, collectionWhere, source, toError) {
+  const owners = /* @__PURE__ */ new Map();
+  return raw.map((entry, i) => {
+    const where = `${collectionWhere}.externalMetadata[${i}]`;
+    if (!isMapping(entry)) {
+      throw toError(`${source}: ${where} must be a mapping.`);
+    }
+    rejectUnknownKeys(entry, EXTERNAL_METADATA_KEYS, where, source, toError);
+    if (!isNonEmptyString(entry.file)) {
+      throw toError(
+        `${source}: ${where}.file must be a non-empty string naming the manifest, relative to the config file.`
+      );
+    }
+    if (!Array.isArray(entry.keys) || entry.keys.length === 0 || entry.keys.some((k) => !isNonEmptyString(k))) {
+      throw toError(
+        `${source}: ${where}.keys must be a non-empty list of key names.`
+      );
+    }
+    const isUrl = isUrlRef(entry.file);
+    if (isUrl) {
+      const problem = externalMetadataUrlProblem(entry.file);
+      if (problem !== null) {
+        throw toError(`${source}: ${where}.file ${problem}.`);
+      }
+    }
+    if (entry.tokenEnv !== void 0) {
+      if (!isNonEmptyString(entry.tokenEnv)) {
+        throw toError(
+          `${source}: ${where}.tokenEnv must be the name of an environment variable.`
+        );
+      }
+      if (!isUrl) {
+        throw toError(
+          `${source}: ${where}.tokenEnv is set, but "file" is a path, so no request is made and the token would go nowhere. Remove it, or make "file" a URL.`
+        );
+      }
+    }
+    const keys = entry.keys;
+    if (entry.join !== void 0) {
+      if (!isNonEmptyString(entry.join)) {
+        throw toError(
+          `${source}: ${where}.join must be "path" or the name of a top-level frontmatter field.`
+        );
+      }
+      if (entry.join === SCHEMA_KEY) {
+        throw toError(`${source}: ${where}.join may not be "${SCHEMA_KEY}".`);
+      }
+      if (keys.includes(entry.join)) {
+        throw toError(
+          `${source}: ${where}.join names "${entry.join}", which the same entry owns \u2014 the value that selects an entry cannot come from the entry.`
+        );
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const key of keys) {
+      if (key === SCHEMA_KEY) {
+        throw toError(
+          `${source}: ${where}.keys may not include "${SCHEMA_KEY}" \u2014 a manifest never chooses the schema a document is judged by; use "overrides".`
+        );
+      }
+      if (seen.has(key)) {
+        throw toError(`${source}: ${where}.keys lists "${key}" twice.`);
+      }
+      seen.add(key);
+      const owner = owners.get(key);
+      if (owner !== void 0) {
+        throw toError(
+          `${source}: ${where}.keys claims "${key}", which externalMetadata[${owner}] already owns \u2014 a key has exactly one manifest in a collection.`
+        );
+      }
+      owners.set(key, i);
+    }
+    return {
+      file: entry.file,
+      keys,
+      ...typeof entry.tokenEnv === "string" ? { tokenEnv: entry.tokenEnv } : {},
+      ...typeof entry.join === "string" ? { join: entry.join } : {}
+    };
+  });
+}
+function selectCollections(collections, names, source, toError) {
+  if (names === void 0 || names.length === 0) return [...collections];
+  const wanted = new Set(names);
+  for (const name2 of wanted) {
+    if (!collections.some((c) => c.name === name2)) {
+      const configured = collections.length === 0 ? "(none)" : collections.map((c) => c.name).join(", ");
+      const nearMiss = collections.find(
+        (c) => c.name.toLowerCase() === name2.toLowerCase()
+      );
+      const hint = nearMiss === void 0 ? "" : ` Names are case-sensitive; did you mean "${nearMiss.name}"?`;
+      throw toError(
+        `no collection named "${name2}" in ${source}. Configured: ${configured}.${hint}`
+      );
+    }
+  }
+  return collections.filter((c) => wanted.has(c.name));
+}
+function isMember(collection, relPath) {
+  if (relPath === STDIN) return false;
+  if (relPath.startsWith("../")) return false;
+  const matched = collection.paths.some((entry) => {
+    const normalized = normalizeEntry(entry);
+    if (normalized === "") return false;
+    if (isGlob(normalized)) return matchesFileGlob(relPath, normalized);
+    return relPath === normalized || relPath.startsWith(`${normalized}/`);
+  });
+  if (!matched) return false;
+  return !collection.exclude.some((glob) => matchesFileGlob(relPath, glob));
+}
+function normalizeEntry(entry) {
+  const posix2 = entry.replace(/\\/g, "/").replace(/^\.\//, "");
+  return posix2.endsWith("/") ? posix2.slice(0, -1) : posix2;
+}
+function isGlob(entry) {
+  return picomatch2.scan(entry).isGlob;
+}
+
 // src/shared/errors.ts
 var ToolError = class extends Error {
   /** clig.dev: 2 is operational/usage; 1 is reserved for findings. */
@@ -154,8 +424,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((resolve12) => {
-  setTimeout(resolve12, ms);
+var wait = (ms) => new Promise((resolve14) => {
+  setTimeout(resolve14, ms);
 });
 async function writeFileAtomic(path, contents) {
   const tmp = join(
@@ -2611,11 +2881,17 @@ var BUILTINS = /* @__PURE__ */ new Map([
   ["anthropic:claude-subagent:2.1", __default23]
 ]);
 function assertPublishableBuiltinId(id) {
-  if (id.split(":")[0] === "check") {
+  const first = id.split(":")[0];
+  if (first === "check") {
     throw new Error(
       `Built-in id "${id}" is not publishable: the "check" first segment is reserved for corpus check identities (check:<name>, proposal 0026).`
     );
   }
+  if (first === "external") {
+    throw new Error(
+      `Built-in id "${id}" is not publishable: the "external" first segment is reserved for external-metadata finding identities (external:owned, external:duplicate, proposal 0037).`
+    );
+  }
 }
 for (const id of BUILTINS.keys()) assertPublishableBuiltinId(id);
 function listBuiltins() {
@@ -2743,8 +3019,8 @@ var SCHEMA_KEYS = [
   "multipleOf"
 ];
 var RETRY_DELAY_MS = 500;
-var wait2 = (ms) => new Promise((resolve12) => {
-  setTimeout(resolve12, ms);
+var wait2 = (ms) => new Promise((resolve14) => {
+  setTimeout(resolve14, ms);
 });
 var RetryableFetchError = class extends DocmetaError {
 };
@@ -2996,114 +3272,361 @@ async function loadSchema(ref, options = {}) {
   }
 }
 
-// src/meta/extractors/frontmatter.ts
-import { parseDocument, LineCounter, isMap, isSeq, isScalar } from "yaml";
-import { parse as parseToml } from "smol-toml";
-
-// src/meta/extractors/date-value.ts
-function isoDateValue(value) {
-  if (!(value instanceof Date)) return value;
-  return Number.isNaN(value.getTime()) ? String(value) : value.toISOString();
+// src/meta/core/resolve-schema.ts
+import { isAbsolute, relative, resolve } from "node:path";
+var DEFAULT_SCHEMAS = Object.freeze([
+  "google:okf:0.1",
+  "passo-uno:seven-action:1.0"
+]);
+var FILE_SCHEMA_KEY = "$schema";
+function schemaEntryRef(entry) {
+  return typeof entry === "string" ? entry : entry.ref;
 }
-
-// src/meta/extractors/pointer.ts
-function escapePointerSegment(key) {
-  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+function collectSchemaPins(config) {
+  const pins = /* @__PURE__ */ new Map();
+  for (const entry of config?.schemas ?? []) {
+    if (typeof entry === "string") continue;
+    if (entry.source === void 0 && entry.integrity === void 0) continue;
+    pins.set(entry.ref, {
+      ...entry.source !== void 0 ? { source: entry.source } : {},
+      ...entry.integrity !== void 0 ? { integrity: entry.integrity } : {}
+    });
+  }
+  return pins;
 }
-function positionForFactory(map) {
-  return (pointer) => {
-    const start = pointer !== "" && !pointer.startsWith("/") ? `/${escapePointerSegment(pointer)}` : pointer;
-    if (map.has(start)) return map.get(start);
-    let p = start;
-    while (p.length > 0) {
-      const idx = p.lastIndexOf("/");
-      if (idx < 0) break;
-      p = p.slice(0, idx);
-      if (map.has(p)) return map.get(p);
-    }
-    return map.get("");
+function rebaseConfigSchemaRefs(config, configDir, cwd) {
+  if (resolve(configDir) === resolve(cwd)) return config;
+  const rebase = (ref) => classifyRef(ref).kind === "file" && !isAbsolute(ref) ? resolve(configDir, ref) : ref;
+  const rebaseEntry = (entry) => typeof entry === "string" ? rebase(entry) : {
+    ...entry,
+    ref: rebase(entry.ref),
+    ...entry.source !== void 0 ? { source: rebase(entry.source) } : {}
+  };
+  return {
+    ...config,
+    ...config.schemas ? { schemas: config.schemas.map(rebaseEntry) } : {},
+    ...config.overrides ? {
+      overrides: config.overrides.map((o) => ({
+        ...o,
+        schemas: o.schemas.map(rebase)
+      }))
+    } : {}
   };
 }
-
-// src/meta/extractors/frontmatter.ts
-var OPEN_FENCE = /^(?:---|\+\+\+|;;;)\r?\n/;
-var FENCES = [
-  { open: /^---\r?\n/, flavor: "yaml", isClose: (l) => l === "---" || l === "..." },
-  { open: /^\+\+\+\r?\n/, flavor: "toml", isClose: (l) => l === "+++" },
-  { open: /^;;;\r?\n/, flavor: "json", isClose: (l) => l === ";;;" }
-];
-function stripBom2(content) {
-  return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
-}
-function hasFrontmatterFence(content) {
-  return OPEN_FENCE.test(stripBom2(content));
+function overrideGlobs(files) {
+  if (files === void 0) return [];
+  return typeof files === "string" ? [files] : files;
 }
-function locateFrontmatter(content) {
-  const bom = content.charCodeAt(0) === 65279 ? 1 : 0;
-  const body = bom === 1 ? content.slice(1) : content;
-  const fence = FENCES.find((f) => f.open.test(body));
-  if (!fence) return null;
-  const openNl = body.indexOf("\n");
-  const eol = openNl > 0 && body.charCodeAt(openNl - 1) === 13 ? "\r\n" : "\n";
-  const innerStart = openNl + 1;
-  let cursor = innerStart;
-  while (cursor <= body.length) {
-    const nl = body.indexOf("\n", cursor);
-    const hasNl = nl !== -1;
-    const lineEnd = hasNl ? nl : body.length;
-    const hadCr = lineEnd > cursor && body.charCodeAt(lineEnd - 1) === 13;
-    const line = body.slice(cursor, hadCr ? lineEnd - 1 : lineEnd);
-    if (fence.isClose(line)) {
-      return {
-        flavor: fence.flavor,
-        openStart: bom,
-        innerStart: innerStart + bom,
-        innerEnd: cursor + bom,
-        closeEnd: (hasNl ? lineEnd + 1 : lineEnd) + bom,
-        eol,
-        firstContentLine: 2
-      };
-    }
-    if (!hasNl) break;
-    cursor = lineEnd + 1;
+function overrideMatches(override, filePath, memberOf2) {
+  if (override.collection !== void 0) {
+    return memberOf2.includes(override.collection);
   }
-  return null;
+  return override.files !== void 0 && matchesFileGlob(filePath, override.files);
 }
-function frontmatterInnerText(content, loc) {
-  return content.slice(loc.innerStart, loc.innerEnd).replace(/\r\n/g, "\n").replace(/\n$/, "");
+function coerceFileSchema(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value) && value.every((v) => typeof v === "string")) {
+    return value;
+  }
+  throw new Error(
+    `Invalid "${FILE_SCHEMA_KEY}": must be a string or a list of strings.`
+  );
 }
-function buildLineMap(doc, lc, prefixLines) {
-  const map = /* @__PURE__ */ new Map();
-  map.set("", 1);
-  const lineAt = (offset) => offset == null ? void 0 : lc.linePos(offset).line + prefixLines;
-  const walk = (node, pointer) => {
-    if (isMap(node)) {
-      for (const pair of node.items) {
-        const key = isScalar(pair.key) ? String(pair.key.value) : String(pair.key);
-        const ptr = `${pointer}/${escapePointerSegment(key)}`;
-        const line = lineAt(
-          pair.key?.range?.[0]
-        );
-        if (line != null) map.set(ptr, line);
-        if (pair.value) walk(pair.value, ptr);
-      }
-    } else if (isSeq(node)) {
-      node.items.forEach((item, i) => {
-        const ptr = `${pointer}/${i}`;
-        const line = lineAt(
-          item?.range?.[0]
-        );
-        if (line != null) map.set(ptr, line);
-        walk(item, ptr);
-      });
-    }
-  };
-  if (doc.contents) walk(doc.contents, "");
-  return map;
+function dedupe(refs) {
+  return [...new Set(refs)];
 }
-var TOML_KEY = /^\s*(?:([A-Za-z0-9_-]+)|"([^"\\]*)"|'([^']*)')\s*=/;
-var TOML_TABLE = /^\s*\[\[?\s*([A-Za-z0-9_-]+)/;
-function buildTomlLineMap(raw, prefixLines) {
+function hostAllowed(url, hosts) {
+  const hostname = url.hostname.toLowerCase();
+  const host = url.host.toLowerCase();
+  return hosts.some((h) => {
+    const want = h.trim().toLowerCase();
+    return want === hostname || want === host;
+  });
+}
+function assertDocumentRefAllowed(ref, mode, params) {
+  const { kind } = classifyRef(ref);
+  if (kind === "builtin" || isPublishedBuiltinUrl(ref)) return;
+  if (kind === "url") {
+    if (mode === "local") {
+      throw new DocmetaError(
+        `Refusing the "${FILE_SCHEMA_KEY}" URL "${ref}": schemaTrust.documentRefs is "local", so a document may name a built-in id or a schema file inside the repository, but not a URL. Vendor it with \`manni meta schemas vendor ${ref}\` and reference the local copy, or put the URL in \`schemas:\` where an operator controls it.`
+      );
+    }
+    const hosts = params.config?.schemaTrust?.hosts;
+    if (!hosts || hosts.length === 0) return;
+    let url;
+    try {
+      url = new URL(ref);
+    } catch {
+      throw new DocmetaError(
+        `Refusing the "${FILE_SCHEMA_KEY}" URL "${ref}": it cannot be parsed as a URL, so it cannot be checked against schemaTrust.hosts.`
+      );
+    }
+    if (!hostAllowed(url, hosts)) {
+      throw new DocmetaError(
+        `Refusing the "${FILE_SCHEMA_KEY}" URL "${ref}": host "${url.host}" is not in schemaTrust.hosts (${hosts.join(", ")}). Add the host there, or reference a schema the config already names.`
+      );
+    }
+    return;
+  }
+  const root = params.trustRoot;
+  if (!root) return;
+  const abs = resolve(params.fileBase ?? process.cwd(), ref);
+  const within = relative(root.dir, abs);
+  if (within !== "" && !within.startsWith("..") && !isAbsolute(within)) return;
+  const boundary = root.source === "git" ? `the repository root (${root.dir})` : root.source === "config" ? `${root.dir} \u2014 no git repository was found, so the config file's own directory is the boundary` : `${root.dir} \u2014 no git repository and no config file were found, so the directory the command was run from is the boundary`;
+  const scope = root.source === "git" ? "the repository" : "the project";
+  throw new DocmetaError(
+    `Refusing the "${FILE_SCHEMA_KEY}" path "${ref}": it resolves outside ${boundary}. A document may only name a schema inside ${scope}; a path in \`schemas:\` or on \`--schema\` is not restricted this way.`
+  );
+}
+function resolveSchemaSetWithSource(params) {
+  const { filePath, fileSchema, cliSchemas, config } = params;
+  if (cliSchemas && cliSchemas.length > 0) {
+    return { schemas: dedupe(cliSchemas), source: "cli" };
+  }
+  const fromFile = coerceFileSchema(fileSchema);
+  if (fromFile && fromFile.length > 0) {
+    const mode = config?.schemaTrust?.documentRefs ?? "any";
+    if (mode === "none") {
+      params.onNotice?.(
+        `${filePath}: "${FILE_SCHEMA_KEY}" is ignored (${fromFile.join(", ")}) \u2014 schemaTrust.documentRefs is "none", so the schema set comes from the config instead. Remove the key from the document, or set schemaTrust.documentRefs to "local" or "any" to honor it.`
+      );
+    } else {
+      for (const ref of fromFile) assertDocumentRefAllowed(ref, mode, params);
+      return { schemas: dedupe(fromFile), source: "document" };
+    }
+  }
+  if (config?.overrides) {
+    const memberOf2 = params.memberOf ?? [];
+    for (const [i, ov] of config.overrides.entries()) {
+      if (overrideMatches(ov, filePath, memberOf2) && ov.schemas.length > 0) {
+        return { schemas: dedupe(ov.schemas), source: "override", overrideIndex: i };
+      }
+    }
+  }
+  if (config?.schemas && config.schemas.length > 0) {
+    return {
+      schemas: dedupe(config.schemas.map(schemaEntryRef)),
+      source: "config"
+    };
+  }
+  return { schemas: [...DEFAULT_SCHEMAS], source: "default" };
+}
+function resolveSchemaSet(params) {
+  return resolveSchemaSetWithSource(params).schemas;
+}
+function resolveElements(filePath, config, memberOf2 = []) {
+  const out = [];
+  if (config?.elements) out.push(...config.elements);
+  for (const ov of config?.overrides ?? []) {
+    if (ov.elements && overrideMatches(ov, filePath, memberOf2)) {
+      out.push(...ov.elements);
+    }
+  }
+  return dedupe(out);
+}
+
+// src/meta/core/external-metadata-fetch.ts
+var EXTERNAL_METADATA_FETCH_TIMEOUT_MS = 1e4;
+var EXTERNAL_METADATA_FETCH_MAX_BYTES = 5 * 1024 * 1024;
+var MAX_REDIRECTS = 5;
+var RETRY_DELAY_MS2 = 500;
+async function fetchExternalMetadata(url, opts = {}) {
+  if (opts.offline) {
+    throw new DocmetaError(
+      `Manifest ${url} is remote and the run is offline. Vendor it to a path, or drop --offline.`
+    );
+  }
+  const timeoutMs = opts.timeoutMs ?? EXTERNAL_METADATA_FETCH_TIMEOUT_MS;
+  const maxBytes = opts.maxBytes ?? EXTERNAL_METADATA_FETCH_MAX_BYTES;
+  const env = opts.env ?? process.env;
+  let token;
+  if (opts.tokenEnv !== void 0) {
+    token = env[opts.tokenEnv];
+    if (token === void 0 || token === "") {
+      throw new DocmetaError(
+        `Manifest ${url}: the environment variable ${opts.tokenEnv} named by "tokenEnv" is not set.`
+      );
+    }
+  }
+  let res = await requestWithRedirects(url, token, timeoutMs);
+  if (res instanceof Error || res.status >= 500) {
+    await new Promise((r) => setTimeout(r, RETRY_DELAY_MS2));
+    res = await requestWithRedirects(url, token, timeoutMs);
+  }
+  if (res instanceof Error) {
+    throw new DocmetaError(
+      `Manifest ${url} could not be fetched: ${res.message}`
+    );
+  }
+  if (!res.ok) {
+    const hint = res.status === 404 && token === void 0 ? ' (a private file answers 404 without a token; set "tokenEnv")' : res.status === 404 ? " (a private file answers 404 without a valid token)" : "";
+    throw new DocmetaError(
+      `Manifest ${url} could not be fetched: HTTP ${res.status}${hint}.`
+    );
+  }
+  return readCapped(url, res, maxBytes);
+}
+async function requestWithRedirects(url, token, timeoutMs) {
+  const origin = new URL(url).origin;
+  let current = url;
+  for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+    const sameOrigin = new URL(current).origin === origin;
+    const headers = { accept: "text/plain, application/x-yaml, */*" };
+    if (token !== void 0 && sameOrigin) headers.authorization = `Bearer ${token}`;
+    let res;
+    try {
+      res = await fetch(current, {
+        headers,
+        redirect: "manual",
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (err) {
+      const isAbort2 = err instanceof Error && err.name === "TimeoutError";
+      return isAbort2 ? new Error(`timed out after ${timeoutMs}ms`) : new Error(err instanceof Error ? err.message : String(err));
+    }
+    if (res.status >= 300 && res.status < 400) {
+      const location = res.headers.get("location");
+      if (location === null) return res;
+      await res.body?.cancel();
+      current = new URL(location, current).toString();
+      continue;
+    }
+    return res;
+  }
+  return new Error(`more than ${MAX_REDIRECTS} redirects`);
+}
+async function readCapped(url, res, maxBytes) {
+  const body = res.body;
+  if (!body) return "";
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done || value === void 0) break;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      await reader.cancel();
+      throw new DocmetaError(
+        `Manifest ${url} is too large: the response exceeds the ${maxBytes}-byte limit.`
+      );
+    }
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+// src/meta/extractors/frontmatter.ts
+import { parseDocument, LineCounter, isMap, isSeq, isScalar } from "yaml";
+import { parse as parseToml } from "smol-toml";
+
+// src/meta/extractors/date-value.ts
+function isoDateValue(value) {
+  if (!(value instanceof Date)) return value;
+  return Number.isNaN(value.getTime()) ? String(value) : value.toISOString();
+}
+
+// src/meta/extractors/pointer.ts
+function escapePointerSegment(key) {
+  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function positionForFactory(map) {
+  return (pointer) => {
+    const start = pointer !== "" && !pointer.startsWith("/") ? `/${escapePointerSegment(pointer)}` : pointer;
+    if (map.has(start)) return map.get(start);
+    let p = start;
+    while (p.length > 0) {
+      const idx = p.lastIndexOf("/");
+      if (idx < 0) break;
+      p = p.slice(0, idx);
+      if (map.has(p)) return map.get(p);
+    }
+    return map.get("");
+  };
+}
+
+// src/meta/extractors/frontmatter.ts
+var OPEN_FENCE = /^(?:---|\+\+\+|;;;)\r?\n/;
+var FENCES = [
+  { open: /^---\r?\n/, flavor: "yaml", isClose: (l) => l === "---" || l === "..." },
+  { open: /^\+\+\+\r?\n/, flavor: "toml", isClose: (l) => l === "+++" },
+  { open: /^;;;\r?\n/, flavor: "json", isClose: (l) => l === ";;;" }
+];
+function stripBom2(content) {
+  return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+}
+function hasFrontmatterFence(content) {
+  return OPEN_FENCE.test(stripBom2(content));
+}
+function locateFrontmatter(content) {
+  const bom = content.charCodeAt(0) === 65279 ? 1 : 0;
+  const body = bom === 1 ? content.slice(1) : content;
+  const fence = FENCES.find((f) => f.open.test(body));
+  if (!fence) return null;
+  const openNl = body.indexOf("\n");
+  const eol = openNl > 0 && body.charCodeAt(openNl - 1) === 13 ? "\r\n" : "\n";
+  const innerStart = openNl + 1;
+  let cursor = innerStart;
+  while (cursor <= body.length) {
+    const nl = body.indexOf("\n", cursor);
+    const hasNl = nl !== -1;
+    const lineEnd = hasNl ? nl : body.length;
+    const hadCr = lineEnd > cursor && body.charCodeAt(lineEnd - 1) === 13;
+    const line = body.slice(cursor, hadCr ? lineEnd - 1 : lineEnd);
+    if (fence.isClose(line)) {
+      return {
+        flavor: fence.flavor,
+        openStart: bom,
+        innerStart: innerStart + bom,
+        innerEnd: cursor + bom,
+        closeEnd: (hasNl ? lineEnd + 1 : lineEnd) + bom,
+        eol,
+        firstContentLine: 2
+      };
+    }
+    if (!hasNl) break;
+    cursor = lineEnd + 1;
+  }
+  return null;
+}
+function frontmatterInnerText(content, loc) {
+  return content.slice(loc.innerStart, loc.innerEnd).replace(/\r\n/g, "\n").replace(/\n$/, "");
+}
+function buildLineMap(doc, lc, prefixLines) {
+  const map = /* @__PURE__ */ new Map();
+  map.set("", 1);
+  const lineAt = (offset) => offset == null ? void 0 : lc.linePos(offset).line + prefixLines;
+  const walk = (node, pointer) => {
+    if (isMap(node)) {
+      for (const pair of node.items) {
+        const key = isScalar(pair.key) ? String(pair.key.value) : String(pair.key);
+        const ptr = `${pointer}/${escapePointerSegment(key)}`;
+        const line = lineAt(
+          pair.key?.range?.[0]
+        );
+        if (line != null) map.set(ptr, line);
+        if (pair.value) walk(pair.value, ptr);
+      }
+    } else if (isSeq(node)) {
+      node.items.forEach((item, i) => {
+        const ptr = `${pointer}/${i}`;
+        const line = lineAt(
+          item?.range?.[0]
+        );
+        if (line != null) map.set(ptr, line);
+        walk(item, ptr);
+      });
+    }
+  };
+  if (doc.contents) walk(doc.contents, "");
+  return map;
+}
+var TOML_KEY = /^\s*(?:([A-Za-z0-9_-]+)|"([^"\\]*)"|'([^']*)')\s*=/;
+var TOML_TABLE = /^\s*\[\[?\s*([A-Za-z0-9_-]+)/;
+function buildTomlLineMap(raw, prefixLines) {
   const map = /* @__PURE__ */ new Map();
   map.set("", 1);
   const record = (key, i) => {
@@ -3755,8 +4278,8 @@ function ditaShape(content, root, filePath) {
   const lower = filePath?.toLowerCase() ?? "";
   const byExtension2 = (lower.endsWith(".dita") || lower.endsWith(".ditamap")) && DITA_ROOTS.has(name2);
   if (!byDoctype && !byClass && !byArch && !byExtension2) return void 0;
-  const isMap4 = /^\s*[-+]\s+map\//.test(cls) || MAP_ROOTS.has(name2) || lower.endsWith(".ditamap");
-  return isMap4 ? { kind: "map", container: "topicmeta", preamble: /* @__PURE__ */ new Set(["title"]) } : {
+  const isMap5 = /^\s*[-+]\s+map\//.test(cls) || MAP_ROOTS.has(name2) || lower.endsWith(".ditamap");
+  return isMap5 ? { kind: "map", container: "topicmeta", preamble: /* @__PURE__ */ new Set(["title"]) } : {
     kind: "topic",
     container: "metadata",
     preamble: /* @__PURE__ */ new Set([
@@ -5181,174 +5704,26 @@ function listFormats() {
   }));
 }
 
-// src/meta/core/resolve-schema.ts
-import { isAbsolute, relative, resolve } from "node:path";
-import picomatch from "picomatch";
-var DEFAULT_SCHEMAS = Object.freeze([
-  "google:okf:0.1",
-  "passo-uno:seven-action:1.0"
-]);
-var FILE_SCHEMA_KEY = "$schema";
-function schemaEntryRef(entry) {
-  return typeof entry === "string" ? entry : entry.ref;
-}
-function collectSchemaPins(config) {
-  const pins = /* @__PURE__ */ new Map();
-  for (const entry of config?.schemas ?? []) {
-    if (typeof entry === "string") continue;
-    if (entry.source === void 0 && entry.integrity === void 0) continue;
-    pins.set(entry.ref, {
-      ...entry.source !== void 0 ? { source: entry.source } : {},
-      ...entry.integrity !== void 0 ? { integrity: entry.integrity } : {}
-    });
-  }
-  return pins;
-}
-function rebaseConfigSchemaRefs(config, configDir, cwd) {
-  if (resolve(configDir) === resolve(cwd)) return config;
-  const rebase = (ref) => classifyRef(ref).kind === "file" && !isAbsolute(ref) ? resolve(configDir, ref) : ref;
-  const rebaseEntry = (entry) => typeof entry === "string" ? rebase(entry) : {
-    ...entry,
-    ref: rebase(entry.ref),
-    ...entry.source !== void 0 ? { source: rebase(entry.source) } : {}
-  };
-  return {
-    ...config,
-    ...config.schemas ? { schemas: config.schemas.map(rebaseEntry) } : {},
-    ...config.overrides ? {
-      overrides: config.overrides.map((o) => ({
-        ...o,
-        schemas: o.schemas.map(rebase)
-      }))
-    } : {}
-  };
-}
-var matcherCache = /* @__PURE__ */ new Map();
-function overrideGlobs(files) {
-  return typeof files === "string" ? [files] : files;
-}
-function matchesFileGlob(glob, filePath) {
-  return matches(glob, filePath);
-}
-function matches(glob, filePath) {
-  const key = JSON.stringify(glob);
-  let m = matcherCache.get(key);
-  if (!m) {
-    m = picomatch(glob, { dot: true });
-    matcherCache.set(key, m);
-  }
-  return m(filePath.replace(/\\/g, "/"));
-}
-function coerceFileSchema(value) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value === "string") return [value];
-  if (Array.isArray(value) && value.every((v) => typeof v === "string")) {
-    return value;
-  }
-  throw new Error(
-    `Invalid "${FILE_SCHEMA_KEY}": must be a string or a list of strings.`
-  );
-}
-function dedupe(refs) {
-  return [...new Set(refs)];
-}
-function hostAllowed(url, hosts) {
-  const hostname = url.hostname.toLowerCase();
-  const host = url.host.toLowerCase();
-  return hosts.some((h) => {
-    const want = h.trim().toLowerCase();
-    return want === hostname || want === host;
-  });
-}
-function assertDocumentRefAllowed(ref, mode, params) {
-  const { kind } = classifyRef(ref);
-  if (kind === "builtin" || isPublishedBuiltinUrl(ref)) return;
-  if (kind === "url") {
-    if (mode === "local") {
-      throw new DocmetaError(
-        `Refusing the "${FILE_SCHEMA_KEY}" URL "${ref}": schemaTrust.documentRefs is "local", so a document may name a built-in id or a schema file inside the repository, but not a URL. Vendor it with \`manni meta schemas vendor ${ref}\` and reference the local copy, or put the URL in \`schemas:\` where an operator controls it.`
-      );
-    }
-    const hosts = params.config?.schemaTrust?.hosts;
-    if (!hosts || hosts.length === 0) return;
-    let url;
-    try {
-      url = new URL(ref);
-    } catch {
-      throw new DocmetaError(
-        `Refusing the "${FILE_SCHEMA_KEY}" URL "${ref}": it cannot be parsed as a URL, so it cannot be checked against schemaTrust.hosts.`
-      );
-    }
-    if (!hostAllowed(url, hosts)) {
-      throw new DocmetaError(
-        `Refusing the "${FILE_SCHEMA_KEY}" URL "${ref}": host "${url.host}" is not in schemaTrust.hosts (${hosts.join(", ")}). Add the host there, or reference a schema the config already names.`
-      );
-    }
-    return;
-  }
-  const root = params.trustRoot;
-  if (!root) return;
-  const abs = resolve(params.fileBase ?? process.cwd(), ref);
-  const within = relative(root.dir, abs);
-  if (within !== "" && !within.startsWith("..") && !isAbsolute(within)) return;
-  const boundary = root.source === "git" ? `the repository root (${root.dir})` : root.source === "config" ? `${root.dir} \u2014 no git repository was found, so the config file's own directory is the boundary` : `${root.dir} \u2014 no git repository and no config file were found, so the directory the command was run from is the boundary`;
-  const scope = root.source === "git" ? "the repository" : "the project";
-  throw new DocmetaError(
-    `Refusing the "${FILE_SCHEMA_KEY}" path "${ref}": it resolves outside ${boundary}. A document may only name a schema inside ${scope}; a path in \`schemas:\` or on \`--schema\` is not restricted this way.`
-  );
-}
-function resolveSchemaSetWithSource(params) {
-  const { filePath, fileSchema, cliSchemas, config } = params;
-  if (cliSchemas && cliSchemas.length > 0) {
-    return { schemas: dedupe(cliSchemas), source: "cli" };
-  }
-  const fromFile = coerceFileSchema(fileSchema);
-  if (fromFile && fromFile.length > 0) {
-    const mode = config?.schemaTrust?.documentRefs ?? "any";
-    if (mode === "none") {
-      params.onNotice?.(
-        `${filePath}: "${FILE_SCHEMA_KEY}" is ignored (${fromFile.join(", ")}) \u2014 schemaTrust.documentRefs is "none", so the schema set comes from the config instead. Remove the key from the document, or set schemaTrust.documentRefs to "local" or "any" to honor it.`
-      );
-    } else {
-      for (const ref of fromFile) assertDocumentRefAllowed(ref, mode, params);
-      return { schemas: dedupe(fromFile), source: "document" };
-    }
-  }
-  if (config?.overrides) {
-    for (const [i, ov] of config.overrides.entries()) {
-      if (matches(ov.files, filePath) && ov.schemas.length > 0) {
-        return { schemas: dedupe(ov.schemas), source: "override", overrideIndex: i };
-      }
-    }
-  }
-  if (config?.schemas && config.schemas.length > 0) {
-    return {
-      schemas: dedupe(config.schemas.map(schemaEntryRef)),
-      source: "config"
-    };
-  }
-  return { schemas: [...DEFAULT_SCHEMAS], source: "default" };
-}
-function resolveSchemaSet(params) {
-  return resolveSchemaSetWithSource(params).schemas;
-}
-function resolveElements(filePath, config) {
-  const out = [];
-  if (config?.elements) out.push(...config.elements);
-  for (const ov of config?.overrides ?? []) {
-    if (ov.elements && matches(ov.files, filePath)) out.push(...ov.elements);
-  }
-  return dedupe(out);
-}
+// src/meta/core/external-metadata.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, relative as relative4, resolve as resolve5, sep as sep2 } from "node:path";
+import {
+  LineCounter as LineCounter2,
+  isMap as isMap3,
+  isNode,
+  isScalar as isScalar2,
+  parseDocument as parseDocument3
+} from "yaml";
 
-// src/meta/core/config.ts
-import { resolve as resolve4 } from "node:path";
-import { parse as parseYaml2 } from "yaml";
+// src/meta/core/load-files.ts
+import { stat as stat3 } from "node:fs/promises";
+import { extname, relative as relative3, resolve as resolve4 } from "node:path";
+import fg from "fast-glob";
+import picomatch3 from "picomatch";
 
-// src/shared/config-file.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { dirname as dirname3, join as join4, relative as relative2, resolve as resolve3 } from "node:path";
-import { parse as parseYaml } from "yaml";
+// src/meta/core/gitignore.ts
+import { spawn } from "node:child_process";
+import { dirname as dirname3, relative as relative2, resolve as resolve3, sep } from "node:path";
 
 // src/shared/git-root.ts
 import { existsSync } from "node:fs";
@@ -5377,64 +5752,542 @@ function searchPath(cwd) {
   }
 }
 
-// src/shared/warn.ts
-var said = /* @__PURE__ */ new Set();
-function warn(message) {
-  if (said.has(message)) return;
-  said.add(message);
-  process.stderr.write(`${programName()}: ${message}
-`);
+// src/meta/core/gitignore.ts
+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(),
+  available: false
+});
+async function gitIgnored(paths, cwd) {
+  if (paths.length === 0) {
+    return { ignored: /* @__PURE__ */ new Set(), available: true };
+  }
+  const rootOf = /* @__PURE__ */ new Map();
+  const byRoot = /* @__PURE__ */ new Map();
+  let inSomeRepo = false;
+  for (const spelled of paths) {
+    const abs = resolve3(cwd, spelled);
+    const dir = dirname3(abs);
+    let root = rootOf.get(dir);
+    if (root === void 0) {
+      root = findGitRoot(dir);
+      rootOf.set(dir, root);
+    }
+    if (root === null) continue;
+    inSomeRepo = true;
+    const rel = relative2(root, abs).split(sep).join("/");
+    const bucket = byRoot.get(root);
+    if (bucket) bucket.push({ rel, spelled });
+    else byRoot.set(root, [{ rel, spelled }]);
+  }
+  if (!inSomeRepo) return unavailable();
+  const ignored = /* @__PURE__ */ new Set();
+  let answered = 0;
+  for (const [root, bucket] of byRoot) {
+    const answer = await checkIgnore(
+      bucket.map((b) => b.rel),
+      root
+    );
+    if (!answer.available) continue;
+    answered += 1;
+    for (const b of bucket) {
+      if (answer.ignored.has(b.rel)) ignored.add(b.spelled);
+    }
+  }
+  return answered > 0 ? { ignored, available: true } : unavailable();
+}
+function checkIgnore(paths, cwd) {
+  return new Promise((settle) => {
+    let done = false;
+    const finish = (answer) => {
+      if (done) return;
+      done = true;
+      settle(answer);
+    };
+    let child;
+    try {
+      child = spawn("git", ["check-ignore", "--stdin", "-z"], {
+        cwd,
+        windowsHide: true
+      });
+    } catch {
+      finish(unavailable());
+      return;
+    }
+    let out = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      out += chunk;
+    });
+    child.stderr.resume();
+    child.on("error", () => {
+      finish(unavailable());
+    });
+    child.stdin.on("error", () => {
+    });
+    child.on("close", (code) => {
+      if (code !== 0 && code !== 1) {
+        finish(unavailable());
+        return;
+      }
+      finish({
+        ignored: new Set(out.split("\0").filter((p) => p !== "")),
+        available: true
+      });
+    });
+    child.stdin.end(paths.join("\0"));
+  });
 }
 
-// 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"
-];
-async function readDocument(path, source, opts) {
-  let text;
+// src/meta/core/load-files.ts
+var DEFAULT_IGNORE = ["**/node_modules/**", "**/.git/**"];
+var STDIN_TOKEN = "-";
+var STDIN_LABEL = "<stdin>";
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+async function statOrNull(p) {
   try {
-    text = await readFile3(path, "utf8");
+    return await stat3(p);
   } catch {
     return null;
   }
-  return { text, doc: parseMapping(text, source, opts) };
-}
-function parseMapping(text, source, opts) {
-  let raw;
-  try {
-    raw = parseYaml(text);
-  } catch (err) {
-    throw opts.toError(`${source}: invalid YAML: ${err.message}`);
-  }
-  if (raw == null) return null;
-  if (typeof raw !== "object" || Array.isArray(raw)) {
-    throw opts.toError(`${source}: top level must be a mapping.`);
-  }
-  return raw;
-}
-function slice(document, opts) {
-  const { doc } = document;
-  if (doc !== null && Object.hasOwn(doc, opts.section)) {
-    return { value: doc[opts.section] ?? null, wrapped: true };
-  }
-  return null;
 }
-function relativeSource(cwd, path) {
-  return relative2(cwd, path).replace(/\\/g, "/");
+function gitignoreOptions(opts) {
+  const asked = opts.flag === true || opts.flag === void 0 && opts.configured === true;
+  const notice = opts.onNotice;
+  return {
+    respectGitignore: opts.flag ?? opts.configured ?? true,
+    ...asked && notice ? {
+      onGitignoreUnavailable: () => {
+        notice(GITIGNORE_UNAVAILABLE);
+      }
+    } : {}
+  };
 }
-async function findConfigFile(cwd, opts) {
-  const start = resolve3(cwd);
-  for (const dir of searchPath(start)) {
-    const family = [
-      { names: FAMILY_CONFIG_NAMES, kind: "manni" },
-      { names: MOOSE_CONFIG_NAMES, kind: "moose" }
-    ];
-    for (const { names, kind } of family) {
+async function resolveTargetSet(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const exts = (opts.exts ?? supportedExtensions()).map(
+    (e) => e.toLowerCase().startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`
+  );
+  const ignore = [...DEFAULT_IGNORE, ...opts.exclude ?? []];
+  const named = /* @__PURE__ */ new Set();
+  const walked = /* @__PURE__ */ new Set();
+  const keepByExt = (file) => exts.includes(extname(file).toLowerCase());
+  const missing = [];
+  for (const input of opts.inputs) {
+    if (input === STDIN_TOKEN) continue;
+    const posixInput = toPosix(input);
+    const abs = resolve4(cwd, posixInput);
+    const st = await statOrNull(abs);
+    if (st?.isFile()) {
+      named.add(toPosix(relative3(cwd, abs)));
+      continue;
+    }
+    if (st?.isDirectory()) {
+      const found2 = await fg(`${posixInput}/**/*`, {
+        cwd,
+        ignore,
+        onlyFiles: true,
+        dot: false
+      });
+      for (const f of found2) if (keepByExt(f)) walked.add(f);
+      continue;
+    }
+    if (!picomatch3.scan(posixInput).isGlob) {
+      missing.push(posixInput);
+      continue;
+    }
+    const found = await fg(posixInput, {
+      cwd,
+      ignore,
+      onlyFiles: true,
+      dot: false
+    });
+    for (const f of found) if (keepByExt(f)) walked.add(f);
+  }
+  if (missing.length > 0 && !opts.allowEmpty) {
+    const names = missing.map((m) => `"${m}"`).join(", ");
+    throw new DocmetaError(
+      missing.length === 1 ? `File not found: ${names}.` : `Files not found: ${names}.`
+    );
+  }
+  let gitignoreSkipped = 0;
+  if (opts.respectGitignore !== false && walked.size > 0) {
+    const candidates = [...walked].filter((f) => !named.has(f));
+    const { ignored, available } = await gitIgnored(candidates, cwd);
+    if (available) {
+      for (const f of ignored) {
+        if (walked.delete(f)) gitignoreSkipped += 1;
+      }
+    } else {
+      opts.onGitignoreUnavailable?.();
+    }
+  }
+  return {
+    files: [.../* @__PURE__ */ new Set([...named, ...walked])].sort(),
+    gitignoreSkipped
+  };
+}
+function assertNonEmpty(p) {
+  if (p.allowEmpty || p.usingStdin || p.files.length > 0) return;
+  const tried = p.inputs.map((i) => `"${i}"`).join(", ");
+  const notes = [];
+  if (p.exts && p.exts.length > 0) {
+    notes.push(`extensions: ${p.exts.join(", ")}`);
+  }
+  if (p.exclude && p.exclude.length > 0) {
+    notes.push(`excludes: ${p.exclude.map((e) => `"${e}"`).join(", ")}`);
+  }
+  if (p.gitignoreSkipped && p.gitignoreSkipped > 0) {
+    notes.push(
+      `.gitignore skipped ${p.gitignoreSkipped} (pass --no-gitignore to check them)`
+    );
+  }
+  throw new DocmetaError(
+    [
+      `No files matched. Patterns tried: ${tried}.`,
+      ...notes.length > 0 ? [`Filters applied \u2014 ${notes.join("; ")}.`] : [],
+      `Nothing was ${p.action}, so this is an error rather than a pass.`,
+      `Pass --allow-empty (or set allowEmpty: true) if matching nothing is expected.`
+    ].join("\n")
+  );
+}
+
+// src/meta/core/external-metadata.ts
+var EXTERNAL_OWNED_SCHEMA = "external:owned";
+var EXTERNAL_DUPLICATE_SCHEMA = "external:duplicate";
+var EXTERNAL_KEYWORD = "external";
+var PATH_JOIN = "path";
+var posix = (p) => p.split(sep2).join("/");
+function reportedPath(abs, base) {
+  const rel = relative4(base, abs);
+  return rel === "" ? "." : posix(rel);
+}
+function externalMetadataJoin(manifest) {
+  return manifest.join ?? PATH_JOIN;
+}
+async function loadExternalMetadata(collections, opts) {
+  const configured = collections.flatMap(
+    (c) => c.externalMetadata.map((m) => ({ collection: c.name, manifest: m }))
+  );
+  if (configured.length === 0) return null;
+  const owners = /* @__PURE__ */ new Map();
+  const byPath = /* @__PURE__ */ new Map();
+  const byField = /* @__PURE__ */ new Map();
+  const entries = [];
+  for (const { collection, manifest } of configured) {
+    let text;
+    let file;
+    if (classifyRef(manifest.file).kind === "url") {
+      file = manifest.file;
+      text = await fetchExternalMetadata(manifest.file, {
+        ...manifest.tokenEnv !== void 0 ? { tokenEnv: manifest.tokenEnv } : {},
+        ...opts.offline !== void 0 ? { offline: opts.offline } : {},
+        ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
+        ...opts.env !== void 0 ? { env: opts.env } : {}
+      });
+    } else {
+      const abs = isAbsolute2(manifest.file) ? manifest.file : resolve5(opts.configDir, manifest.file);
+      file = reportedPath(abs, opts.base);
+      text = await readManifest(abs, file);
+    }
+    for (const key of manifest.keys) {
+      const list = owners.get(key);
+      if (list) list.push({ collection, file });
+      else owners.set(key, [{ collection, file }]);
+    }
+    const join7 = externalMetadataJoin(manifest);
+    let target;
+    if (join7 === PATH_JOIN) {
+      target = byPath;
+    } else {
+      const existing = byField.get(join7);
+      if (existing) target = existing;
+      else {
+        target = /* @__PURE__ */ new Map();
+        byField.set(join7, target);
+      }
+    }
+    parseManifest(
+      manifest,
+      collection,
+      text,
+      file,
+      opts.configDir,
+      join7,
+      target,
+      entries
+    );
+  }
+  return { owners, byPath, byField, entries };
+}
+async function readManifest(abs, file) {
+  try {
+    return await readFile3(abs, "utf8");
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new DocmetaError(
+      `Manifest ${file} could not be read: ${reason}`
+    );
+  }
+}
+function parseManifest(manifest, collection, text, file, configDir, join7, target, entries) {
+  const lc = new LineCounter2();
+  const doc = parseDocument3(text, { lineCounter: lc, uniqueKeys: false });
+  const problem = doc.errors[0];
+  if (problem) {
+    throw new DocmetaError(
+      `Manifest ${file} is not valid YAML: ${problem.message}`
+    );
+  }
+  const root = doc.contents;
+  if (root === null || isScalar2(root) && root.value === null) return;
+  if (!isMap3(root)) {
+    throw new DocmetaError(
+      `Manifest ${file}: the manifest must be a mapping from document ${join7 === PATH_JOIN ? "path" : `"${join7}"`} to owned keys.`
+    );
+  }
+  const owned = new Set(manifest.keys);
+  const lineAt = (node) => {
+    const range = isNode(node) ? node.range : void 0;
+    return range ? lc.linePos(range[0]).line : void 0;
+  };
+  const seen = /* @__PURE__ */ new Map();
+  for (const pair of root.items) {
+    const spelled = isScalar2(pair.key) ? String(pair.key.value) : String(pair.key);
+    const entryLine = lineAt(pair.key);
+    const where = entryLine === void 0 ? file : `${file}:${entryLine}`;
+    if (seen.has(spelled)) {
+      const first = seen.get(spelled);
+      throw new DocmetaError(
+        `Manifest ${where}: "${spelled}" is named twice (first at line ${first ?? "?"}). Merge the two entries into one.`
+      );
+    }
+    seen.set(spelled, entryLine);
+    if (!isMap3(pair.value)) {
+      throw new DocmetaError(
+        `Manifest ${where}: "${spelled}" must be a mapping of owned keys to values.`
+      );
+    }
+    const indexKey = join7 === PATH_JOIN ? resolve5(configDir, spelled) : spelled;
+    const values = target.get(indexKey) ?? /* @__PURE__ */ new Map();
+    for (const kv of pair.value.items) {
+      const key = isScalar2(kv.key) ? String(kv.key.value) : String(kv.key);
+      if (key === FILE_SCHEMA_KEY) {
+        throw new DocmetaError(
+          `Manifest ${where}: "${spelled}" sets "${FILE_SCHEMA_KEY}" \u2014 a manifest never chooses the schema a document is judged by; use "overrides" in the config.`
+        );
+      }
+      if (!owned.has(key)) {
+        throw new DocmetaError(
+          `Manifest ${where}: "${spelled}" sets "${key}", which this manifest does not own. Add it to the manifest's "keys", or remove it from the entry.`
+        );
+      }
+      const value = kv.value === null ? null : kv.value.toJS(doc, { maxAliasCount: 100 });
+      const line = lineAt(kv.key);
+      values.set(key, {
+        value,
+        collection,
+        file,
+        ...line === void 0 ? {} : { line }
+      });
+    }
+    target.set(indexKey, values);
+    entries.push({
+      collection,
+      join: join7,
+      ...join7 === PATH_JOIN ? { abs: indexKey } : {},
+      spelled,
+      file,
+      ...entryLine === void 0 ? {} : { line: entryLine }
+    });
+  }
+}
+function joinValue(raw) {
+  if (typeof raw === "string") return raw;
+  if (typeof raw === "number" || typeof raw === "bigint") return String(raw);
+  if (typeof raw === "boolean") return String(raw);
+  return void 0;
+}
+function mergeExternalMetadata(label, extracted, index, memberOf2, base) {
+  const none = () => void 0;
+  if (!index || memberOf2.length === 0) {
+    return { extracted, collisions: [], joins: [], locate: none };
+  }
+  const mine = (collection) => memberOf2.includes(collection);
+  const collisions = [];
+  for (const key of Object.keys(extracted.data)) {
+    for (const owner of index.owners.get(key) ?? []) {
+      if (mine(owner.collection)) {
+        collisions.push({ key, file: owner.file, collection: owner.collection });
+      }
+    }
+  }
+  const sources = [];
+  const joins = [];
+  if (label !== STDIN_LABEL) {
+    const byPath = index.byPath.get(resolve5(base, label));
+    if (byPath) sources.push(byPath);
+  }
+  for (const [field, byValue] of index.byField) {
+    const value = joinValue(extracted.data[field]);
+    if (value === void 0) continue;
+    const hit = byValue.get(value);
+    if (!hit) continue;
+    sources.push(hit);
+    const first = [...hit.values()].find((sv) => mine(sv.collection));
+    if (first) {
+      joins.push({ field, value, file: first.file, collection: first.collection });
+    }
+  }
+  for (const supplied of sources) {
+    for (const key of supplied.keys()) {
+      const owners = (index.owners.get(key) ?? []).filter(
+        (o) => mine(o.collection)
+      );
+      const [a, b] = owners;
+      if (a && b) {
+        throw new DocmetaError(
+          `${label}: "${key}" is owned by manifests in two of its collections, ${a.collection} (${a.file}) and ${b.collection} (${b.file}); a key has one manifest per file. Narrow one collection's paths or exclude.`
+        );
+      }
+    }
+  }
+  if (sources.length === 0) {
+    return { extracted, collisions, joins, locate: none };
+  }
+  const data = { ...extracted.data };
+  const merged = /* @__PURE__ */ new Map();
+  for (const supplied of sources) {
+    for (const [key, sv] of supplied) {
+      if (!mine(sv.collection)) continue;
+      if (key in extracted.data) continue;
+      data[key] = sv.value;
+      merged.set(key, sv);
+    }
+  }
+  const locate = (pointer) => {
+    const top = topLevelKey(pointer);
+    if (top === void 0) return void 0;
+    const sv = merged.get(top);
+    if (!sv) return void 0;
+    return { file: sv.file, ...sv.line === void 0 ? {} : { line: sv.line } };
+  };
+  return { extracted: { ...extracted, data }, collisions, joins, locate };
+}
+function topLevelKey(pointer) {
+  if (pointer === "") return void 0;
+  if (!pointer.startsWith("/")) return pointer;
+  const seg = pointer.slice(1).split("/")[0] ?? "";
+  return seg.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function externalMetadataPointer(key) {
+  return `/${escapePointerSegment(key)}`;
+}
+function orphanEntries(index, loaded, base, collections) {
+  if (!index) return [];
+  const have = new Set(loaded.map((l) => resolve5(base, l)));
+  return index.entries.filter(
+    (e) => inCollections(e, collections) && e.join === PATH_JOIN && e.abs !== void 0 && !have.has(e.abs)
+  );
+}
+function inCollections(entry, collections) {
+  return collections === void 0 || collections.includes(entry.collection);
+}
+function orphanJoins(index, matched, collections) {
+  if (!index) return [];
+  return index.entries.filter(
+    (e) => inCollections(e, collections) && e.join !== PATH_JOIN && !(matched.get(e.join)?.has(e.spelled) ?? false)
+  );
+}
+function orphanError(orphans) {
+  const first = orphans[0];
+  if (!first) throw new Error("orphanError called with no orphans");
+  const where = first.line === void 0 ? first.file : `${first.file}:${first.line}`;
+  const more = orphans.length > 1 ? ` (${orphans.length - 1} more)` : "";
+  const what = first.join === PATH_JOIN ? `names "${first.spelled}", which this run did not load` : `names ${first.join} "${first.spelled}", which no loaded document carries`;
+  return new DocmetaError(
+    `Manifest ${where} ${what}${more}. Fix the entry, or remove it.`
+  );
+}
+
+// src/meta/core/config.ts
+import { resolve as resolve7 } from "node:path";
+import { parse as parseYaml2 } from "yaml";
+
+// src/shared/config-file.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { dirname as dirname4, join as join4, relative as relative5, resolve as resolve6 } from "node:path";
+import { parse as parseYaml } from "yaml";
+
+// src/shared/warn.ts
+var said = /* @__PURE__ */ new Set();
+function warn(message) {
+  if (said.has(message)) return;
+  said.add(message);
+  process.stderr.write(`${programName()}: ${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"
+];
+async function readDocument(path, source, opts) {
+  let text;
+  try {
+    text = await readFile4(path, "utf8");
+  } catch {
+    return null;
+  }
+  return { text, doc: parseMapping(text, source, opts) };
+}
+function parseMapping(text, source, opts) {
+  let raw;
+  try {
+    raw = parseYaml(text);
+  } catch (err) {
+    throw opts.toError(`${source}: invalid YAML: ${err.message}`);
+  }
+  if (raw == null) return null;
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw opts.toError(`${source}: top level must be a mapping.`);
+  }
+  return raw;
+}
+var COLLECTIONS_KEY = "collections";
+function slice(document, opts) {
+  const { doc } = document;
+  if (doc !== null && Object.hasOwn(doc, opts.section)) {
+    return { value: doc[opts.section] ?? null, wrapped: true };
+  }
+  if (doc !== null && Object.hasOwn(doc, COLLECTIONS_KEY)) {
+    return { value: null, wrapped: true };
+  }
+  return null;
+}
+function collectionsOf(document, source, opts) {
+  const { doc } = document;
+  if (doc === null || !Object.hasOwn(doc, COLLECTIONS_KEY)) return [];
+  return parseCollections(doc[COLLECTIONS_KEY], source, opts.toError);
+}
+function relativeSource(cwd, path) {
+  return relative5(cwd, path).replace(/\\/g, "/");
+}
+async function findConfigFile(cwd, opts) {
+  const start = resolve6(cwd);
+  for (const dir of searchPath(start)) {
+    const family = [
+      { names: FAMILY_CONFIG_NAMES, kind: "manni" },
+      { names: MOOSE_CONFIG_NAMES, kind: "moose" }
+    ];
+    for (const { names, kind } of family) {
       for (const name2 of names) {
         const path = join4(dir, name2);
         const source = relativeSource(start, path);
@@ -5447,7 +6300,15 @@ async function findConfigFile(cwd, opts) {
             `"${name2}" is the pre-rename name of the family config file. Rename it to "${FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml"}".`
           );
         }
-        return { path, dir, source, text: document.text, kind, ...found };
+        return {
+          path,
+          dir,
+          source,
+          text: document.text,
+          kind,
+          collections: collectionsOf(document, source, opts),
+          ...found
+        };
       }
     }
     for (const name2 of opts.legacyNames) {
@@ -5456,7 +6317,7 @@ async function findConfigFile(cwd, opts) {
       const document = await readDocument(path, source, opts);
       if (document === null) continue;
       warn(
-        `"${name2}" is a deprecated config file name and will stop being read in a future major version. Move its keys under \`${opts.section}:\` in "${FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml"}".`
+        `"${name2}" is a deprecated config file name and will stop being read in a future major version. 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.`
       );
       return {
         path,
@@ -5465,14 +6326,15 @@ async function findConfigFile(cwd, opts) {
         text: document.text,
         value: document.doc,
         wrapped: false,
-        kind: "legacy"
+        kind: "legacy",
+        collections: []
       };
     }
   }
   return null;
 }
 async function readConfigFile(explicitPath, cwd, opts) {
-  const path = resolve3(cwd, explicitPath);
+  const path = resolve6(cwd, explicitPath);
   const document = await readDocument(path, explicitPath, opts);
   if (document === null) {
     throw opts.toError(`Config file not found: "${explicitPath}".`);
@@ -5483,10 +6345,11 @@ async function readConfigFile(explicitPath, cwd, opts) {
   };
   return {
     path,
-    dir: dirname3(path),
+    dir: dirname4(path),
     source: explicitPath,
     text: document.text,
     kind: "explicit",
+    collections: collectionsOf(document, explicitPath, opts),
     ...found
   };
 }
@@ -5507,7 +6370,7 @@ function asElementPaths(value, where, source) {
   }
   return list;
 }
-var OVERRIDE_KEYS = ["name", "files", "schemas", "elements"];
+var OVERRIDE_KEYS = ["collection", "files", "schemas", "elements"];
 var CHECK_KEYS = ["name", "query"];
 var CHECK_NAME = /^[a-z0-9][a-z0-9._-]*$/;
 var RESERVED_CHECK_NAMES = /* @__PURE__ */ new Set(["query"]);
@@ -5520,8 +6383,6 @@ var FILL_KEYS = [
   "concurrency"
 ];
 var CONFIG_KEYS = [
-  "paths",
-  "exclude",
   "schemas",
   "overrides",
   "checks",
@@ -5534,7 +6395,7 @@ var CONFIG_KEYS = [
   "fill",
   "elements"
 ];
-function rejectUnknownKeys(raw, allowed, where, source) {
+function rejectUnknownKeys2(raw, allowed, where, source) {
   for (const key of Object.keys(raw)) {
     if (!allowed.includes(key)) {
       throw new DocmetaError(
@@ -5604,7 +6465,7 @@ function parseSchemaEntry(entry, where, source) {
     );
   }
   const raw = entry;
-  rejectUnknownKeys(raw, SCHEMA_ENTRY_KEYS, where, source);
+  rejectUnknownKeys2(raw, SCHEMA_ENTRY_KEYS, where, source);
   if (typeof raw.ref !== "string" || raw.ref.trim() === "") {
     throw new DocmetaError(
       `${source}: ${where}.ref must be a non-empty schema reference string.`
@@ -5647,6 +6508,7 @@ function parseConfig(text, source) {
   return parseConfigValue(raw, source);
 }
 function parseConfigValue(raw, source, section) {
+  assertNoMovedKeys(raw, source);
   if (section === void 0) return parseConfigDocument(raw, source);
   try {
     return parseConfigDocument(raw, source);
@@ -5668,73 +6530,99 @@ function withSection(message, source, section) {
   if (/^[a-zA-Z]+(\[|\.| —)/.test(rest)) return `${head}${section}.${rest}`;
   return message;
 }
+var CONFIG_REF = "https://hawkeyexl.github.io/manni/meta/reference/configuration/";
+var MOVED_KEYS = [
+  [
+    "paths",
+    `Document sets are declared once for every tool, under a top-level collections: list. See ${CONFIG_REF}#collections`
+  ],
+  [
+    "exclude",
+    `Document sets are declared once for every tool, under a top-level collections: list. See ${CONFIG_REF}#collections`
+  ],
+  [
+    "sidecars",
+    `It is externalMetadata on a collection, under the top-level collections: list. See ${CONFIG_REF}#external-metadata`
+  ]
+];
+function assertNoMovedKeys(raw, source) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return;
+  const obj = raw;
+  for (const [key, remedy] of MOVED_KEYS) {
+    if (Object.hasOwn(obj, key)) {
+      throw new DocmetaError(
+        `${source}: "${key}" is no longer a meta key. ${remedy}`
+      );
+    }
+  }
+  if (!Array.isArray(obj.overrides)) return;
+  for (const [i, entry] of obj.overrides.entries()) {
+    if (typeof entry === "object" && entry !== null && !Array.isArray(entry) && Object.hasOwn(entry, "name")) {
+      throw new DocmetaError(
+        `${source}: overrides[${i}] no longer carries "name". Define a collection with that name and point the override at it with collection:.`
+      );
+    }
+  }
+}
+function assertOverrideCollections(config, collections, source) {
+  const names = new Set(collections.map((c) => c.name));
+  for (const [i, ov] of (config.overrides ?? []).entries()) {
+    if (ov.collection === void 0 || names.has(ov.collection)) continue;
+    const defined = collections.length === 0 ? "(none)" : collections.map((c) => c.name).join(", ");
+    throw new DocmetaError(
+      `${source}: overrides[${i}].collection names "${ov.collection}", which collections: does not define. Defined: ${defined}.`
+    );
+  }
+}
 function parseConfigDocument(raw, source) {
   if (raw == null) return {};
   if (typeof raw !== "object" || Array.isArray(raw)) {
     throw new DocmetaError(`${source}: top level must be a mapping.`);
   }
   const obj = raw;
-  rejectUnknownKeys(obj, CONFIG_KEYS, "the top level", source);
+  rejectUnknownKeys2(obj, CONFIG_KEYS, "the top level", source);
   const config = {};
-  if (obj.paths !== void 0) config.paths = asStringList(obj.paths, "paths", source);
-  if (obj.exclude !== void 0)
-    config.exclude = asStringList(obj.exclude, "exclude", source);
   if (obj.schemas !== void 0)
     config.schemas = asSchemaList(obj.schemas, "schemas", source);
   if (obj.overrides !== void 0) {
     if (!Array.isArray(obj.overrides)) {
       throw new DocmetaError(`${source}: "overrides" must be a list.`);
     }
-    const seenNames = /* @__PURE__ */ new Set();
     config.overrides = obj.overrides.map((entry, i) => {
       if (typeof entry !== "object" || entry === null) {
         throw new DocmetaError(`${source}: overrides[${i}] must be a mapping.`);
       }
       const e = entry;
-      rejectUnknownKeys(e, OVERRIDE_KEYS, `overrides[${i}]`, source);
-      const files = asFileGlobs(e.files, `overrides[${i}].files`, source);
-      const schemas = e.schemas === void 0 ? [] : asStringList(e.schemas, `overrides[${i}].schemas`, source);
-      const elements = e.elements === void 0 ? void 0 : asElementPaths(e.elements, `overrides[${i}].elements`, source);
-      if (schemas.length === 0 && (elements === void 0 || elements.length === 0)) {
+      rejectUnknownKeys2(e, OVERRIDE_KEYS, `overrides[${i}]`, source);
+      const hasFiles = e.files !== void 0;
+      const hasCollection = e.collection !== void 0;
+      if (hasFiles === hasCollection) {
         throw new DocmetaError(
-          `${source}: overrides[${i}] sets neither "schemas" nor "elements", so it has no effect.`
+          `${source}: overrides[${i}] must carry exactly one of "files" or "collection".`
         );
       }
-      let name2;
-      if (e.name !== void 0) {
-        if (typeof e.name !== "string" || e.name.trim() === "") {
+      const files = hasFiles ? asFileGlobs(e.files, `overrides[${i}].files`, source) : void 0;
+      let collection;
+      if (hasCollection) {
+        if (typeof e.collection !== "string" || e.collection.trim() === "") {
           throw new DocmetaError(
-            `${source}: overrides[${i}].name must be a non-empty string \u2014 it becomes the collection's view name.`
+            `${source}: overrides[${i}].collection must be a non-empty string naming a collection.`
           );
         }
-        if (e.name.toLowerCase() === "docs") {
-          throw new DocmetaError(
-            `${source}: overrides[${i}].name "${e.name}" collides with the docs table every query reads. Pick another name.`
-          );
-        }
-        if (e.name.toLowerCase().startsWith("sqlite_")) {
-          throw new DocmetaError(
-            `${source}: overrides[${i}].name "${e.name}" starts with "sqlite_", which SQLite reserves for its own objects. Pick another name.`
-          );
-        }
-        if (schemas.length === 0) {
-          throw new DocmetaError(
-            `${source}: overrides[${i}] names a collection ("${e.name}") but sets no "schemas", so it can never win schema resolution and its view would always be empty. Add "schemas", or drop the name.`
-          );
-        }
-        if (seenNames.has(e.name.toLowerCase())) {
-          throw new DocmetaError(
-            `${source}: overrides[${i}] reuses the name "${e.name}"; collection names must be unique.`
-          );
-        }
-        seenNames.add(e.name.toLowerCase());
-        name2 = e.name;
+        collection = e.collection;
+      }
+      const schemas = e.schemas === void 0 ? [] : asStringList(e.schemas, `overrides[${i}].schemas`, source);
+      const elements = e.elements === void 0 ? void 0 : asElementPaths(e.elements, `overrides[${i}].elements`, source);
+      if (schemas.length === 0 && (elements === void 0 || elements.length === 0)) {
+        throw new DocmetaError(
+          `${source}: overrides[${i}] sets neither "schemas" nor "elements", so it has no effect.`
+        );
       }
       return {
-        files,
+        ...files !== void 0 ? { files } : {},
+        ...collection !== void 0 ? { collection } : {},
         schemas,
-        ...elements ? { elements } : {},
-        ...name2 !== void 0 ? { name: name2 } : {}
+        ...elements ? { elements } : {}
       };
     });
   }
@@ -5791,7 +6679,7 @@ function parseChecks(value, source) {
       );
     }
     const e = entry;
-    rejectUnknownKeys(e, CHECK_KEYS, `checks[${i}]`, source);
+    rejectUnknownKeys2(e, CHECK_KEYS, `checks[${i}]`, source);
     if (typeof e.name !== "string" || e.name === "") {
       throw new DocmetaError(
         `${source}: checks[${i}].name must be a non-empty string.`
@@ -5826,7 +6714,7 @@ function parseSchemaCache(value, source) {
     throw new DocmetaError(`${source}: "schemaCache" must be a mapping.`);
   }
   const raw = value;
-  rejectUnknownKeys(raw, SCHEMA_CACHE_KEYS, '"schemaCache"', source);
+  rejectUnknownKeys2(raw, SCHEMA_CACHE_KEYS, '"schemaCache"', source);
   const schemaCache = {};
   const ttl = raw.ttlHours;
   if (ttl !== void 0) {
@@ -5846,7 +6734,7 @@ function parseSchemaTrust(value, source) {
     );
   }
   const raw = value;
-  rejectUnknownKeys(raw, SCHEMA_TRUST_KEYS, '"schemaTrust"', source);
+  rejectUnknownKeys2(raw, SCHEMA_TRUST_KEYS, '"schemaTrust"', source);
   const schemaTrust = {};
   const mode = raw.documentRefs;
   if (mode !== void 0) {
@@ -5873,7 +6761,7 @@ function parseFill(value, source) {
     throw new DocmetaError(`${source}: "fill" must be a mapping.`);
   }
   const raw = value;
-  rejectUnknownKeys(raw, FILL_KEYS, '"fill"', source);
+  rejectUnknownKeys2(raw, FILL_KEYS, '"fill"', source);
   const fill = {};
   const asString = (key) => {
     const v = raw[key];
@@ -5909,865 +6797,715 @@ function parseFill(value, source) {
 function schemaTrustRoot(cwd, configDir) {
   const git = findGitRoot(cwd);
   if (git !== null) return { dir: git, source: "git" };
-  if (configDir !== void 0) return { dir: resolve4(configDir), source: "config" };
-  return { dir: resolve4(cwd), source: "cwd" };
+  if (configDir !== void 0) return { dir: resolve7(configDir), source: "config" };
+  return { dir: resolve7(cwd), source: "cwd" };
 }
 async function loadConfig(explicitPath, cwd = process.cwd()) {
   const file = explicitPath ? await readConfigFile(explicitPath, cwd, CONFIG_FILE) : await findConfigFile(cwd, CONFIG_FILE);
   if (file === null) return null;
   const section = file.wrapped ? META_SECTION : void 0;
+  const config = parseConfigValue(file.value, file.source, section);
+  assertOverrideCollections(config, file.collections, file.source);
   return {
-    config: parseConfigValue(file.value, file.source, section),
+    config,
     path: file.path,
     dir: file.dir,
+    source: file.source,
+    collections: file.collections,
     ...section !== void 0 ? { section } : {}
   };
 }
+var STDIN_TOKEN_LITERAL = "-";
 async function resolveRunConfig(opts) {
   const cwd = opts.cwd ?? process.cwd();
+  const wanted = opts.collections ?? [];
+  if (wanted.length > 0) {
+    const typed = opts.inputs.filter((i) => i !== STDIN_TOKEN_LITERAL);
+    if (typed.length > 0) {
+      throw new DocmetaError(
+        "--collection selects a configured collection; it cannot be combined with paths."
+      );
+    }
+  }
   const loaded = opts.noConfig ? null : await loadConfig(opts.configPath, cwd);
+  if (wanted.length > 0 && loaded === null) {
+    throw new DocmetaError("--collection needs a config file to select from.");
+  }
   if (loaded) opts.onConfigLoaded?.({ path: loaded.path, dir: loaded.dir });
   const config = loaded ? rebaseConfigSchemaRefs(loaded.config, loaded.dir, cwd) : null;
-  const fromConfig = opts.inputs.length === 0;
-  const inputs = fromConfig ? config?.paths ?? [] : opts.inputs;
-  const base = fromConfig && inputs.length > 0 && loaded ? loaded.dir : cwd;
+  const collections = loaded ? selectCollections(
+    loaded.collections,
+    opts.collections,
+    loaded.source,
+    (message) => new DocmetaError(message)
+  ) : [];
+  const fromCollections = opts.inputs.length === 0;
+  const inputs = fromCollections ? collections.flatMap((c) => c.paths) : opts.inputs;
+  const base = fromCollections && inputs.length > 0 && loaded ? loaded.dir : cwd;
   return {
     config,
     inputs,
     base,
-    ...loaded ? { configDir: loaded.dir, configPath: loaded.path } : {}
+    collections,
+    declaredCollections: loaded ? [...loaded.collections] : [],
+    fromCollections,
+    ...loaded ? {
+      configDir: loaded.dir,
+      configPath: loaded.path,
+      ...loaded.section === void 0 ? {} : { configSection: loaded.section }
+    } : {}
   };
 }
 
-// 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";
+// src/meta/core/collections.ts
+import { isAbsolute as isAbsolute3, relative as relative6, resolve as resolvePath2, sep as sep3 } 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('"', '""')}"`;
+}
+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);
   }
-  if (meta.includes("draft-04") || meta.includes("draft/4")) return "draft4";
-  return "2020";
 }
-function buildAjv(dialect) {
-  const opts = { allErrors: true, strict: false };
-  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);
-  registerBuiltins(ajv, dialect);
-  return ajv;
+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 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 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");
+  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");
 }
-function compileWithFormats(schema) {
-  return buildAjv("2020").compile(schema);
+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;
+  });
 }
-var formatRegistry;
-function formatsAjv() {
-  if (!formatRegistry) {
-    formatRegistry = new Ajv2020({ strict: false });
-    addFormats(formatRegistry);
+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."
+    );
   }
-  return formatRegistry;
 }
-var stringFormatsMemo;
-function stringFormatNames() {
-  if (!stringFormatsMemo) {
-    const names = /* @__PURE__ */ new Set();
-    const registered = formatsAjv().formats;
-    for (const [name2, def] of Object.entries(registered)) {
-      const enforcesStrings = def instanceof RegExp || typeof def === "function" || typeof def === "object" && def !== null && (def.type === void 0 || def.type === "string");
-      if (enforcesStrings) names.add(name2);
-    }
-    stringFormatsMemo = names;
-  }
-  return stringFormatsMemo;
+function startsStringOrIdent(sql, i) {
+  const ch = sql[i];
+  return ch === "'" || ch === '"' || ch === "`" || ch === "[";
 }
-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);
-  }
-  return fn(value);
+function startsComment(sql, i) {
+  const ch = sql[i];
+  return ch === "-" && sql[i + 1] === "-" || ch === "/" && sql[i + 1] === "*";
 }
-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;
+function skipStringOrIdent(sql, i) {
+  const quote = sql[i];
+  if (quote === "[") {
+    let j2 = i + 1;
+    while (j2 < sql.length && sql[j2] !== "]") j2++;
+    return j2 + 1;
   }
-  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);
-      this.ajvByDialect.set(dialect, ajv);
+  let j = i + 1;
+  while (j < sql.length) {
+    if (sql[j] === quote) {
+      if (sql[j + 1] === quote) {
+        j += 2;
+        continue;
+      }
+      return j + 1;
     }
-    return ajv;
+    j++;
   }
-  /**
-   * 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;
+  return j;
+}
+function skipComment(sql, i) {
+  if (sql[i] === "-") {
+    let j = i + 2;
+    while (j < sql.length && sql[j] !== "\n") j++;
+    return j < sql.length ? j + 1 : j;
   }
-  async compileUncached(ref) {
-    const schema = await loadSchema(ref, this.schemaOptions);
-    try {
-      const ajv = this.ajvFor(dialectOf(schema));
-      const id = typeof schema["$id"] === "string" ? schema["$id"] : void 0;
-      const registered = id != null ? ajv.getSchema(id) : void 0;
-      if (registered) {
-        if (registered.schema === schema) return registered;
-        const { $id: _taken, ...anonymous } = schema;
-        return ajv.compile(anonymous);
-      }
-      return ajv.compile(schema);
-    } catch (err) {
-      throw new DocmetaError(
-        `Schema "${ref}" failed to compile: ${err.message}`
-      );
+  const end = sql.indexOf("*/", i + 2);
+  return end === -1 ? sql.length : end + 2;
+}
+function topLevelSemicolon(sql) {
+  let i = 0;
+  while (i < sql.length) {
+    if (startsStringOrIdent(sql, i)) {
+      i = skipStringOrIdent(sql, i);
+    } else if (startsComment(sql, i)) {
+      i = skipComment(sql, i);
+    } else if (sql[i] === ";") {
+      return i;
+    } else {
+      i++;
     }
   }
-  /**
-   * 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) {
-    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));
+  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 tokens = [];
+  const seen = /* @__PURE__ */ new Set();
+  const prefixOf = /* @__PURE__ */ new Map();
+  let i = 0;
+  while (i < sql.length) {
+    const ch = sql[i];
+    if (startsStringOrIdent(sql, i)) {
+      i = skipStringOrIdent(sql, i);
+    } else if (startsComment(sql, i)) {
+      i = skipComment(sql, i);
+    } else if (ch === "$" || ch === ":" || ch === "@") {
+      if (ch === ":" && sql[i + 1] === ":") {
+        i += 2;
+        continue;
+      }
+      const m = PARAM_NAME_HEAD.exec(sql.slice(i + 1));
+      if (!m) {
+        i++;
+        continue;
+      }
+      const token = ch + m[0];
+      const priorPrefix = prefixOf.get(m[0]);
+      if (priorPrefix !== void 0 && priorPrefix !== ch) {
+        throw new DocmetaError(
+          `The statement references both ${priorPrefix}${m[0]} and ${token} \u2014 one name under two prefixes, which the engine rejects as conflicting. Use one spelling throughout.`
+        );
+      }
+      prefixOf.set(m[0], ch);
+      if (!seen.has(token)) {
+        seen.add(token);
+        tokens.push(token);
       }
+      i += 1 + m[0].length;
+    } else {
+      i++;
     }
-    return 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 tokens;
 }
-function toFieldError(schema, e, lineFor, colFor) {
-  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;
+function stripLeadingTrivia(sql) {
+  let i = 0;
+  for (; ; ) {
+    while (i < sql.length && /\s/.test(sql[i] ?? "")) i++;
+    if (startsComment(sql, i)) {
+      i = skipComment(sql, i);
+      continue;
+    }
+    return sql.slice(i);
   }
-  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/commands/validate.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { readFile as readFile5 } from "node:fs/promises";
-import { resolve as resolve7, extname as extname2 } from "node:path";
-
-// src/meta/core/baseline.ts
-import { createHash as createHash3 } from "node:crypto";
-import { readFile as readFile4 } from "node:fs/promises";
-import { relative as relative3, resolve as resolve5 } from "node:path";
-var DEFAULT_BASELINE_PATH = ".manni-baseline.json";
-var LEGACY_BASELINE_PATH = ".docmeta-baseline.json";
-var BASELINE_VERSION = 1;
-var FINGERPRINT_RE = /^[0-9a-f]{16}$/;
-function canonicalFilePath(file, ctx) {
-  if (!ctx) return file;
-  const from = ctx.runBase ?? ctx.base;
-  return relative3(ctx.base, resolve5(from, file)).replace(/\\/g, "/");
+function isTrivia(text) {
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === void 0 || /\s/.test(ch) || ch === ";") {
+      i++;
+      continue;
+    }
+    if (startsComment(text, i)) {
+      i = skipComment(text, i);
+      continue;
+    }
+    return false;
+  }
+  return true;
 }
-function canonicalSchemaRef(ref, ctx) {
-  if (!ctx) return ref;
-  if (classifyRef(ref).kind !== "file") return ref;
-  const abs = resolve5(ctx.cwd, ref);
-  return relative3(ctx.base, abs).replace(/\\/g, "/");
+var sqliteModule;
+function loadSqlite() {
+  sqliteModule ??= (async () => {
+    const original = process.emitWarning.bind(process);
+    const filtered = (warning, ...rest) => {
+      const text = typeof warning === "string" ? warning : warning.message;
+      if (text.includes("SQLite is an experimental feature")) return;
+      Reflect.apply(original, process, [warning, ...rest]);
+    };
+    process.emitWarning = filtered;
+    try {
+      return await import("node:sqlite");
+    } finally {
+      process.emitWarning = original;
+    }
+  })();
+  return sqliteModule;
 }
-function fingerprint(e, ctx) {
-  const parts = [
-    canonicalSchemaRef(e.schema, ctx),
-    e.instancePath,
-    e.keyword,
-    e.subject ?? ""
-  ];
-  return createHash3("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
+
+// src/meta/core/collections.ts
+function memberOf(collections, configDir, base, label) {
+  if (collections.length === 0) return [];
+  if (label === STDIN_LABEL) return [];
+  const rel = relative6(configDir, resolvePath2(base, label)).split(sep3).join("/");
+  if (isAbsolute3(rel)) return [];
+  return collections.filter((c) => isMember(c, rel)).map((c) => c.name);
 }
-function serializeBaseline(baseline) {
-  const entries = /* @__PURE__ */ Object.create(null);
-  for (const file of Object.keys(baseline.entries).sort()) {
-    entries[file] = [...baseline.entries[file] ?? []].sort();
-  }
-  return `${JSON.stringify(
-    {
-      version: baseline.version,
-      generatedWith: baseline.generatedWith,
-      entries
-    },
-    null,
-    2
-  )}
-`;
+function retainMembers(files, membersFor) {
+  return files.filter((label) => membersFor(label).length > 0);
 }
-function bad(source, detail) {
-  throw new DocmetaError(`Baseline "${source}": ${detail}`);
+function collectionNames(collections) {
+  return (collections ?? []).map((c) => c.name);
 }
-function parseBaseline(text, source) {
-  let raw;
-  try {
-    raw = JSON.parse(stripBom(text));
-  } catch (err) {
-    bad(source, `invalid JSON: ${err.message}`);
-  }
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    bad(source, "top level must be an object.");
-  }
-  const obj = raw;
-  if (obj.version !== BASELINE_VERSION) {
-    bad(
-      source,
-      `unsupported version ${JSON.stringify(obj.version)} (this manni writes version ${BASELINE_VERSION}). Re-record it with \`manni meta validate --write-baseline\`.`
-    );
-  }
-  const generatedWith = typeof obj.generatedWith === "string" ? obj.generatedWith : "";
-  const rawEntries = obj.entries;
-  if (typeof rawEntries !== "object" || rawEntries === null || Array.isArray(rawEntries)) {
-    bad(source, '"entries" must be an object mapping file paths to fingerprints.');
-  }
-  const entries = /* @__PURE__ */ Object.create(null);
-  for (const [file, value] of Object.entries(
-    rawEntries
-  )) {
-    if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) {
-      bad(source, `entries["${file}"] must be a list of fingerprint strings.`);
-    }
-    const malformed = value.find((v) => !FINGERPRINT_RE.test(v));
-    if (malformed !== void 0) {
-      bad(
-        source,
-        `entries["${file}"] contains ${JSON.stringify(malformed)}, which is not a fingerprint (16 lowercase hex characters).`
-      );
+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 list = members.get(name2);
+      if (list) list.push(entry.label);
+      else members.set(name2, [entry.label]);
     }
-    entries[file] = value;
   }
-  return { version: BASELINE_VERSION, generatedWith, entries };
+  return declared.map((c) => ({ name: c.name, members: members.get(c.name) ?? [] }));
 }
-async function readBaseline(absPath, source) {
-  let text;
-  try {
-    text = await readFile4(absPath, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT") return null;
-    throw new DocmetaError(
-      `Baseline "${source}" could not be read: ${err.message}`
-    );
-  }
-  return parseBaseline(text, source);
+function quoteSqlString(value) {
+  return `'${value.replaceAll("'", "''")}'`;
 }
-async function writeBaselineFile(absPath, baseline, source) {
-  try {
-    await writeFileAtomic(absPath, serializeBaseline(baseline));
-  } catch (err) {
-    throw new DocmetaError(
-      `Baseline "${source}" could not be written: ${err.message}`
+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 buildBaseline(results, generatedWith, ctx) {
-  const entries = /* @__PURE__ */ Object.create(null);
-  for (const r of results) {
-    if (r.errors.length === 0) continue;
-    const prints = [...new Set(r.errors.map((e) => fingerprint(e, ctx)))].sort();
-    entries[canonicalFilePath(r.file, ctx)] = prints;
-  }
-  return { version: BASELINE_VERSION, generatedWith, entries };
-}
-function applyBaseline(results, baseline, ctx) {
-  let recorded = 0;
-  let suppressed = 0;
-  let stale = 0;
-  const applied = results.map((r) => {
-    const known = baseline.entries[canonicalFilePath(r.file, ctx)];
-    if (!known) return r;
-    const recordedHere = new Set(known);
-    recorded += recordedHere.size;
-    const seen = /* @__PURE__ */ new Set();
-    const fresh = [];
-    for (const e of r.errors) {
-      const print = fingerprint(e, ctx);
-      if (recordedHere.has(print)) {
-        seen.add(print);
-        suppressed += 1;
-      } else {
-        fresh.push(e);
-      }
-    }
-    stale += recordedHere.size - seen.size;
-    const baselined = r.errors.length - fresh.length;
-    return {
-      ...r,
-      ok: fresh.length === 0,
-      errors: fresh,
-      ...baselined > 0 ? { baselined } : {}
-    };
-  });
-  return { results: applied, recorded, suppressed, stale };
-}
-function diffBaselines(previous, next) {
-  const flatten = (b) => {
-    const out = /* @__PURE__ */ new Set();
-    if (!b) return out;
-    for (const [file, prints] of Object.entries(b.entries)) {
-      for (const p of prints) out.add(`${file}\0${p}`);
-    }
-    return out;
-  };
-  const before = flatten(previous);
-  const after = flatten(next);
-  let added = 0;
-  let removed = 0;
-  for (const k of after) if (!before.has(k)) added += 1;
-  for (const k of before) if (!after.has(k)) removed += 1;
-  return { added, removed };
-}
-function countFingerprints(baseline) {
-  let n = 0;
-  for (const prints of Object.values(baseline.entries)) n += prints.length;
-  return n;
-}
 
-// src/meta/core/load-files.ts
-import { stat as stat3 } from "node:fs/promises";
-import { extname, relative as relative4, resolve as resolve6 } from "node:path";
-import fg from "fast-glob";
-import picomatch2 from "picomatch";
-
-// src/meta/core/gitignore.ts
-import { spawn } from "node:child_process";
-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(),
-  available: false
-});
-function gitIgnored(paths, cwd) {
-  if (paths.length === 0) {
-    return Promise.resolve({ ignored: /* @__PURE__ */ new Set(), available: true });
+// 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";
   }
-  return new Promise((settle) => {
-    let done = false;
-    const finish = (answer) => {
-      if (done) return;
-      done = true;
-      settle(answer);
-    };
-    let child;
-    try {
-      child = spawn("git", ["check-ignore", "--stdin", "-z"], {
-        cwd,
-        windowsHide: true
-      });
-    } catch {
-      finish(unavailable());
-      return;
-    }
-    let out = "";
-    child.stdout.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      out += chunk;
-    });
-    child.stderr.resume();
-    child.on("error", () => {
-      finish(unavailable());
-    });
-    child.stdin.on("error", () => {
-    });
-    child.on("close", (code) => {
-      if (code !== 0 && code !== 1) {
-        finish(unavailable());
-        return;
-      }
-      finish({
-        ignored: new Set(out.split("\0").filter((p) => p !== "")),
-        available: true
-      });
-    });
-    child.stdin.end(paths.join("\0"));
-  });
+  if (meta.includes("draft-04") || meta.includes("draft/4")) return "draft4";
+  return "2020";
 }
-
-// src/meta/core/load-files.ts
-var DEFAULT_IGNORE = ["**/node_modules/**", "**/.git/**"];
-var STDIN_TOKEN = "-";
-var STDIN_LABEL = "<stdin>";
-function toPosix(p) {
-  return p.replace(/\\/g, "/");
+function buildAjv(dialect) {
+  const opts = { allErrors: true, strict: false };
+  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);
+  registerBuiltins(ajv, dialect);
+  return ajv;
 }
-async function statOrNull(p) {
-  try {
-    return await stat3(p);
-  } catch {
-    return null;
+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 gitignoreOptions(opts) {
-  const asked = opts.flag === true || opts.flag === void 0 && opts.configured === true;
-  const notice = opts.onNotice;
-  return {
-    respectGitignore: opts.flag ?? opts.configured ?? true,
-    ...asked && notice ? {
-      onGitignoreUnavailable: () => {
-        notice(GITIGNORE_UNAVAILABLE);
-      }
-    } : {}
-  };
+function compileWithFormats(schema) {
+  return buildAjv("2020").compile(schema);
 }
-async function resolveTargetSet(opts) {
-  const cwd = opts.cwd ?? process.cwd();
-  const exts = (opts.exts ?? supportedExtensions()).map(
-    (e) => e.toLowerCase().startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`
-  );
-  const ignore = [...DEFAULT_IGNORE, ...opts.exclude ?? []];
-  const named = /* @__PURE__ */ new Set();
-  const walked = /* @__PURE__ */ new Set();
-  const keepByExt = (file) => exts.includes(extname(file).toLowerCase());
-  const missing = [];
-  for (const input of opts.inputs) {
-    if (input === STDIN_TOKEN) continue;
-    const posixInput = toPosix(input);
-    const abs = resolve6(cwd, posixInput);
-    const st = await statOrNull(abs);
-    if (st?.isFile()) {
-      named.add(toPosix(relative4(cwd, abs)));
-      continue;
-    }
-    if (st?.isDirectory()) {
-      const found2 = await fg(`${posixInput}/**/*`, {
-        cwd,
-        ignore,
-        onlyFiles: true,
-        dot: false
-      });
-      for (const f of found2) if (keepByExt(f)) walked.add(f);
-      continue;
-    }
-    if (!picomatch2.scan(posixInput).isGlob) {
-      missing.push(posixInput);
-      continue;
-    }
-    const found = await fg(posixInput, {
-      cwd,
-      ignore,
-      onlyFiles: true,
-      dot: false
-    });
-    for (const f of found) if (keepByExt(f)) walked.add(f);
-  }
-  if (missing.length > 0 && !opts.allowEmpty) {
-    const names = missing.map((m) => `"${m}"`).join(", ");
-    throw new DocmetaError(
-      missing.length === 1 ? `File not found: ${names}.` : `Files not found: ${names}.`
-    );
+var formatRegistry;
+function formatsAjv() {
+  if (!formatRegistry) {
+    formatRegistry = new Ajv2020({ strict: false });
+    addFormats(formatRegistry);
   }
-  let gitignoreSkipped = 0;
-  if (opts.respectGitignore !== false && walked.size > 0) {
-    const candidates = [...walked].filter((f) => !named.has(f));
-    const { ignored, available } = await gitIgnored(candidates, cwd);
-    if (available) {
-      for (const f of ignored) {
-        if (walked.delete(f)) gitignoreSkipped += 1;
-      }
-    } else {
-      opts.onGitignoreUnavailable?.();
+  return formatRegistry;
+}
+var stringFormatsMemo;
+function stringFormatNames() {
+  if (!stringFormatsMemo) {
+    const names = /* @__PURE__ */ new Set();
+    const registered = formatsAjv().formats;
+    for (const [name2, def] of Object.entries(registered)) {
+      const enforcesStrings = def instanceof RegExp || typeof def === "function" || typeof def === "object" && def !== null && (def.type === void 0 || def.type === "string");
+      if (enforcesStrings) names.add(name2);
     }
+    stringFormatsMemo = names;
   }
-  return {
-    files: [.../* @__PURE__ */ new Set([...named, ...walked])].sort(),
-    gitignoreSkipped
-  };
+  return stringFormatsMemo;
 }
-function assertNonEmpty(p) {
-  if (p.allowEmpty || p.usingStdin || p.files.length > 0) return;
-  const tried = p.inputs.map((i) => `"${i}"`).join(", ");
-  const notes = [];
-  if (p.exts && p.exts.length > 0) {
-    notes.push(`extensions: ${p.exts.join(", ")}`);
+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);
   }
-  if (p.exclude && p.exclude.length > 0) {
-    notes.push(`excludes: ${p.exclude.map((e) => `"${e}"`).join(", ")}`);
+  return fn(value);
+}
+var Validator = class {
+  /**
+   * How this validator's schemas are loaded: the disk cache location, its TTL,
+   * and `--offline`. Held per instance rather than read from module state, so
+   * two differently-configured validations in one process each get their own
+   * settings.
+   *
+   * That is not full isolation, and the difference matters to a library
+   * caller: `schema-registry` keeps a process-wide memo of fetched schemas, so
+   * one validator's successful fetch is visible to another. `offline` is
+   * excluded from that sharing on purpose — an offline validator will not be
+   * served something this process pulled over the network — but the memo is
+   * still shared, so a URL fetched once is not re-fetched per instance.
+   */
+  constructor(schemaOptions = {}) {
+    this.schemaOptions = schemaOptions;
   }
-  if (p.gitignoreSkipped && p.gitignoreSkipped > 0) {
-    notes.push(
-      `.gitignore skipped ${p.gitignoreSkipped} (pass --no-gitignore to check them)`
-    );
+  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);
+      this.ajvByDialect.set(dialect, ajv);
+    }
+    return ajv;
   }
-  throw new DocmetaError(
-    [
-      `No files matched. Patterns tried: ${tried}.`,
-      ...notes.length > 0 ? [`Filters applied \u2014 ${notes.join("; ")}.`] : [],
-      `Nothing was ${p.action}, so this is an error rather than a pass.`,
-      `Pass --allow-empty (or set allowEmpty: true) if matching nothing is expected.`
-    ].join("\n")
-  );
-}
-
-// 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 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);
+  /**
+   * 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;
   }
-}
-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);
+  async compileUncached(ref) {
+    const schema = await loadSchema(ref, this.schemaOptions);
+    try {
+      const ajv = this.ajvFor(dialectOf(schema));
+      const id = typeof schema["$id"] === "string" ? schema["$id"] : void 0;
+      const registered = id != null ? ajv.getSchema(id) : void 0;
+      if (registered) {
+        if (registered.schema === schema) return registered;
+        const { $id: _taken, ...anonymous } = schema;
+        return ajv.compile(anonymous);
+      }
+      return ajv.compile(schema);
+    } catch (err) {
+      throw new DocmetaError(
+        `Schema "${ref}" failed to compile: ${err.message}`
+      );
+    }
+  }
+  /**
+   * 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;
   }
-  for (const key of extraKeys) {
-    if (key !== "" && !RESERVED.has(key)) keys.add(key);
+};
+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 [...keys].sort();
 }
-function createDocsTable(db, entries, dataColumns) {
-  db.exec(
-    `CREATE TABLE docs ("_path" TEXT PRIMARY KEY, "_format" TEXT, "_present" INTEGER, "_data" TEXT${dataColumns.map((c) => `, ${quoteIdent(c)}`).join("")})`
-  );
-  const insert = db.prepare(
-    `INSERT INTO docs VALUES (${["?", "?", "?", "?", ...dataColumns.map(() => "?")].join(", ")})`
-  );
-  db.exec("BEGIN");
-  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]))
-    );
+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;
   }
-  db.exec("COMMIT");
-}
-function registerLineFor(db, entries) {
-  const byLabel = new Map(entries.map((e) => [e.label, e.extracted]));
-  db.function("lineFor", { deterministic: true }, (path, key) => {
-    if (typeof path !== "string" || typeof key !== "string") return null;
-    return byLabel.get(path)?.lineFor(key) ?? null;
-  });
-}
-function assertSingleStatement(sql) {
-  const cut = topLevelSemicolon(sql);
-  if (cut === -1) return;
-  if (!isTrivia(sql.slice(cut + 1))) {
-    throw new DocmetaError(
-      "Run a single SQL statement per query; text after the first `;` would be silently ignored."
-    );
+  const located = locate?.(instancePath) ?? (defined.keyword === "additionalProperties" ? locate?.(
+    `${instancePath}/${escapePointerSegment(defined.params.additionalProperty)}`
+  ) : void 0);
+  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 } : {}
+  };
 }
-function startsStringOrIdent(sql, i) {
-  const ch = sql[i];
-  return ch === "'" || ch === '"' || ch === "`" || ch === "[";
-}
-function startsComment(sql, i) {
-  const ch = sql[i];
-  return ch === "-" && sql[i + 1] === "-" || ch === "/" && sql[i + 1] === "*";
+
+// src/meta/commands/validate.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile6 } from "node:fs/promises";
+import { resolve as resolve9, extname as extname2 } from "node:path";
+
+// src/meta/core/baseline.ts
+import { createHash as createHash3 } from "node:crypto";
+import { readFile as readFile5 } from "node:fs/promises";
+import { relative as relative7, resolve as resolve8 } from "node:path";
+var DEFAULT_BASELINE_PATH = ".manni-baseline.json";
+var LEGACY_BASELINE_PATH = ".docmeta-baseline.json";
+var BASELINE_VERSION = 1;
+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, resolve8(from, file)).replace(/\\/g, "/");
 }
-function skipStringOrIdent(sql, i) {
-  const quote = sql[i];
-  if (quote === "[") {
-    let j2 = i + 1;
-    while (j2 < sql.length && sql[j2] !== "]") j2++;
-    return j2 + 1;
-  }
-  let j = i + 1;
-  while (j < sql.length) {
-    if (sql[j] === quote) {
-      if (sql[j + 1] === quote) {
-        j += 2;
-        continue;
-      }
-      return j + 1;
-    }
-    j++;
-  }
-  return j;
+function canonicalSchemaRef(ref, ctx) {
+  if (!ctx) return ref;
+  if (classifyRef(ref).kind !== "file") return ref;
+  const abs = resolve8(ctx.cwd, ref);
+  return relative7(ctx.base, abs).replace(/\\/g, "/");
 }
-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 fingerprint(e, ctx) {
+  const parts = [
+    canonicalSchemaRef(e.schema, ctx),
+    e.instancePath,
+    e.keyword,
+    e.subject ?? ""
+  ];
+  return createHash3("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
 }
-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++;
-    }
+function serializeBaseline(baseline) {
+  const entries = /* @__PURE__ */ Object.create(null);
+  for (const file of Object.keys(baseline.entries).sort()) {
+    entries[file] = [...baseline.entries[file] ?? []].sort();
   }
-  return -1;
+  return `${JSON.stringify(
+    {
+      version: baseline.version,
+      generatedWith: baseline.generatedWith,
+      entries
+    },
+    null,
+    2
+  )}
+`;
 }
-var PARAM_NAME_HEAD = /^[A-Za-z_][A-Za-z0-9_]*/;
-function isParamName(name2) {
-  return PARAM_NAME_HEAD.exec(name2)?.[0] === name2;
+function bad(source, detail) {
+  throw new DocmetaError(`Baseline "${source}": ${detail}`);
 }
-function collectNamedParameters(sql) {
-  const tokens = [];
-  const seen = /* @__PURE__ */ new Set();
-  const prefixOf = /* @__PURE__ */ new Map();
-  let i = 0;
-  while (i < sql.length) {
-    const ch = sql[i];
-    if (startsStringOrIdent(sql, i)) {
-      i = skipStringOrIdent(sql, i);
-    } else if (startsComment(sql, i)) {
-      i = skipComment(sql, i);
-    } else if (ch === "$" || ch === ":" || ch === "@") {
-      if (ch === ":" && sql[i + 1] === ":") {
-        i += 2;
-        continue;
-      }
-      const m = PARAM_NAME_HEAD.exec(sql.slice(i + 1));
-      if (!m) {
-        i++;
-        continue;
-      }
-      const token = ch + m[0];
-      const priorPrefix = prefixOf.get(m[0]);
-      if (priorPrefix !== void 0 && priorPrefix !== ch) {
-        throw new DocmetaError(
-          `The statement references both ${priorPrefix}${m[0]} and ${token} \u2014 one name under two prefixes, which the engine rejects as conflicting. Use one spelling throughout.`
-        );
-      }
-      prefixOf.set(m[0], ch);
-      if (!seen.has(token)) {
-        seen.add(token);
-        tokens.push(token);
-      }
-      i += 1 + m[0].length;
-    } else {
-      i++;
-    }
+function parseBaseline(text, source) {
+  let raw;
+  try {
+    raw = JSON.parse(stripBom(text));
+  } catch (err) {
+    bad(source, `invalid JSON: ${err.message}`);
   }
-  return tokens;
-}
-function stripLeadingTrivia(sql) {
-  let i = 0;
-  for (; ; ) {
-    while (i < sql.length && /\s/.test(sql[i] ?? "")) i++;
-    if (startsComment(sql, i)) {
-      i = skipComment(sql, i);
-      continue;
-    }
-    return sql.slice(i);
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    bad(source, "top level must be an object.");
   }
-}
-function isTrivia(text) {
-  let i = 0;
-  while (i < text.length) {
-    const ch = text[i];
-    if (ch === void 0 || /\s/.test(ch) || ch === ";") {
-      i++;
-      continue;
+  const obj = raw;
+  if (obj.version !== BASELINE_VERSION) {
+    bad(
+      source,
+      `unsupported version ${JSON.stringify(obj.version)} (this manni writes version ${BASELINE_VERSION}). Re-record it with \`manni meta validate --write-baseline\`.`
+    );
+  }
+  const generatedWith = typeof obj.generatedWith === "string" ? obj.generatedWith : "";
+  const rawEntries = obj.entries;
+  if (typeof rawEntries !== "object" || rawEntries === null || Array.isArray(rawEntries)) {
+    bad(source, '"entries" must be an object mapping file paths to fingerprints.');
+  }
+  const entries = /* @__PURE__ */ Object.create(null);
+  for (const [file, value] of Object.entries(
+    rawEntries
+  )) {
+    if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) {
+      bad(source, `entries["${file}"] must be a list of fingerprint strings.`);
     }
-    if (startsComment(text, i)) {
-      i = skipComment(text, i);
-      continue;
+    const malformed = value.find((v) => !FINGERPRINT_RE.test(v));
+    if (malformed !== void 0) {
+      bad(
+        source,
+        `entries["${file}"] contains ${JSON.stringify(malformed)}, which is not a fingerprint (16 lowercase hex characters).`
+      );
     }
-    return false;
+    entries[file] = value;
   }
-  return true;
+  return { version: BASELINE_VERSION, generatedWith, entries };
 }
-var sqliteModule;
-function loadSqlite() {
-  sqliteModule ??= (async () => {
-    const original = process.emitWarning.bind(process);
-    const filtered = (warning, ...rest) => {
-      const text = typeof warning === "string" ? warning : warning.message;
-      if (text.includes("SQLite is an experimental feature")) return;
-      Reflect.apply(original, process, [warning, ...rest]);
-    };
-    process.emitWarning = filtered;
-    try {
-      return await import("node:sqlite");
-    } finally {
-      process.emitWarning = original;
-    }
-  })();
-  return sqliteModule;
+async function readBaseline(absPath, source) {
+  let text;
+  try {
+    text = await readFile5(absPath, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw new DocmetaError(
+      `Baseline "${source}" could not be read: ${err.message}`
+    );
+  }
+  return parseBaseline(text, source);
 }
-
-// src/meta/core/collections.ts
-function namedOverrides(config) {
-  return (config?.overrides ?? []).flatMap(
-    (o, i) => o.name !== void 0 ? [{ name: o.name, files: o.files, index: i }] : []
-  );
+async function writeBaselineFile(absPath, baseline, source) {
+  try {
+    await writeFileAtomic(absPath, serializeBaseline(baseline));
+  } catch (err) {
+    throw new DocmetaError(
+      `Baseline "${source}" could not be written: ${err.message}`
+    );
+  }
 }
-function collectionNames(config) {
-  return namedOverrides(config).map((n) => n.name);
+function buildBaseline(results, generatedWith, ctx) {
+  const entries = /* @__PURE__ */ Object.create(null);
+  for (const r of results) {
+    if (r.errors.length === 0) continue;
+    const prints = [...new Set(r.errors.map((e) => fingerprint(e, ctx)))].sort();
+    entries[canonicalFilePath(r.file, ctx)] = prints;
+  }
+  return { version: BASELINE_VERSION, generatedWith, entries };
 }
-function collectCollections(entries, params) {
-  const named = namedOverrides(params.config);
-  if (named.length === 0) return [];
-  const members = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    let resolved;
-    if (params.resolved) {
-      const pre = params.resolved.get(entry.label);
-      if (!pre) continue;
-      resolved = pre;
-    } else {
-      try {
-        resolved = resolveSchemaSetWithSource({
-          filePath: entry.label,
-          fileSchema: entry.extracted.data[FILE_SCHEMA_KEY],
-          ...params.cliSchemas ? { cliSchemas: params.cliSchemas } : {},
-          config: params.config,
-          ...params.fileBase !== void 0 ? { fileBase: params.fileBase } : {},
-          ...params.trustRoot ? { trustRoot: params.trustRoot } : {}
-        });
-      } catch {
-        continue;
-      }
-    }
-    if (resolved.source === "override" && resolved.overrideIndex !== void 0) {
-      const list = members.get(resolved.overrideIndex);
-      if (list) list.push(entry.label);
-      else members.set(resolved.overrideIndex, [entry.label]);
-      continue;
-    }
-    if (resolved.source === "document") {
-      const excluded = named.find((g) => matchesFileGlob(g.files, entry.label));
-      if (excluded) {
-        params.onNotice?.(
-          `${entry.label}: not in the "${excluded.name}" collection \u2014 its own "${FILE_SCHEMA_KEY}" won schema resolution over the override (${overrideGlobs(excluded.files).join(", ")}). Membership follows the schema a file is validated as; set schemaTrust.documentRefs to "none" to let the override decide.`
-        );
+function applyBaseline(results, baseline, ctx) {
+  let recorded = 0;
+  let suppressed = 0;
+  let stale = 0;
+  const applied = results.map((r) => {
+    const known = baseline.entries[canonicalFilePath(r.file, ctx)];
+    if (!known) return r;
+    const recordedHere = new Set(known);
+    recorded += recordedHere.size;
+    const seen = /* @__PURE__ */ new Set();
+    const fresh = [];
+    for (const e of r.errors) {
+      const print = fingerprint(e, ctx);
+      if (recordedHere.has(print)) {
+        seen.add(print);
+        suppressed += 1;
+      } else {
+        fresh.push(e);
       }
     }
-  }
-  return named.map(({ name: name2, index }) => ({
-    name: name2,
-    members: members.get(index) ?? []
-  }));
+    stale += recordedHere.size - seen.size;
+    const baselined = r.errors.length - fresh.length;
+    return {
+      ...r,
+      ok: fresh.length === 0,
+      errors: fresh,
+      ...baselined > 0 ? { baselined } : {}
+    };
+  });
+  return { results: applied, recorded, suppressed, stale };
 }
-function quoteSqlString(value) {
-  return `'${value.replaceAll("'", "''")}'`;
+function diffBaselines(previous, next) {
+  const flatten = (b) => {
+    const out = /* @__PURE__ */ new Set();
+    if (!b) return out;
+    for (const [file, prints] of Object.entries(b.entries)) {
+      for (const p of prints) out.add(`${file}\0${p}`);
+    }
+    return out;
+  };
+  const before = flatten(previous);
+  const after = flatten(next);
+  let added = 0;
+  let removed = 0;
+  for (const k of after) if (!before.has(k)) added += 1;
+  for (const k of before) if (!after.has(k)) removed += 1;
+  return { added, removed };
 }
-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 countFingerprints(baseline) {
+  let n = 0;
+  for (const prints of Object.values(baseline.entries)) n += prints.length;
+  return n;
 }
 
 // src/meta/core/checks.ts
@@ -6900,16 +7638,16 @@ function parseErrorResult(file, format, message, keyword) {
 }
 function resolveBaselineRequest(opts, configured, configDir, cwd) {
   const named = (label) => ({
-    absPath: resolve7(cwd, label),
+    absPath: resolve9(cwd, label),
     label
   });
   const implied = () => {
     const base = configDir ?? cwd;
     if (configured !== void 0) {
-      return { absPath: resolve7(base, configured), label: configured };
+      return { absPath: resolve9(base, configured), label: configured };
     }
-    const current = resolve7(base, DEFAULT_BASELINE_PATH);
-    const legacy = resolve7(base, LEGACY_BASELINE_PATH);
+    const current = resolve9(base, DEFAULT_BASELINE_PATH);
+    const legacy = resolve9(base, LEGACY_BASELINE_PATH);
     if (!existsSync2(current) && existsSync2(legacy)) {
       warn(
         `"${LEGACY_BASELINE_PATH}" is the pre-rename baseline file name. Rename it to "${DEFAULT_BASELINE_PATH}".`
@@ -6931,17 +7669,27 @@ function resolveBaselineRequest(opts, configured, configDir, cwd) {
 }
 async function runValidate(opts) {
   const cwd = opts.cwd ?? process.cwd();
-  const { config, inputs, base, configDir } = await resolveRunConfig({
+  const {
+    config,
+    inputs,
+    base,
+    configDir,
+    collections,
+    declaredCollections,
+    fromCollections
+  } = await resolveRunConfig({
     cwd,
     configPath: opts.configPath,
     noConfig: opts.noConfig,
     inputs: opts.inputs,
+    ...opts.collections !== void 0 ? { collections: opts.collections } : {},
     onConfigLoaded: opts.onConfigLoaded
   });
+  const membersFor = (label) => memberOf(collections, configDir ?? cwd, base, label);
   const usingStdin = inputs.includes(STDIN_TOKEN);
   if (inputs.length === 0) {
     throw new DocmetaError(
-      "No files to validate. Pass paths/globs, or add `paths:` under `meta:` in manni.config.yaml."
+      "No files to validate. Pass paths/globs, or declare a collection under `collections:` in manni.config.yaml."
     );
   }
   const forcedExtractor = opts.as ? extractorByName(opts.as) : void 0;
@@ -6953,8 +7701,8 @@ async function runValidate(opts) {
   const exts = opts.exts ?? (forcedExtractor ? forcedExtractor.extensions : void 0);
   const fileInputs = inputs.filter((i) => i !== STDIN_TOKEN);
   const allowEmpty = opts.allowEmpty ?? config?.allowEmpty;
-  const exclude = [...config?.exclude ?? [], ...opts.exclude ?? []];
-  const { files, gitignoreSkipped } = await resolveTargetSet({
+  const exclude = opts.exclude ?? [];
+  const { files: walked, gitignoreSkipped } = await resolveTargetSet({
     inputs: fileInputs,
     exts,
     exclude,
@@ -6966,6 +7714,7 @@ async function runValidate(opts) {
       onNotice: opts.onNotice
     })
   });
+  const files = fromCollections ? retainMembers(walked, membersFor) : walked;
   assertNonEmpty({
     files,
     inputs: fileInputs,
@@ -6977,6 +7726,11 @@ async function runValidate(opts) {
     action: "validated"
   });
   const trustRoot = schemaTrustRoot(cwd, configDir);
+  const externalMetadata = await loadExternalMetadata(collections, {
+    configDir: configDir ?? cwd,
+    base,
+    offline: opts.offline ?? config?.offline ?? false
+  });
   const validator = new Validator(
     schemaLoadOptions({
       // The config's directory when a config governs the run, so one project
@@ -6992,12 +7746,19 @@ async function runValidate(opts) {
     })
   );
   const results = [];
-  const scoped = opts.inputs.length > 0 || // redundant with inputs.length (stdin is an input) — kept as belt-and-suspenders
+  const joinHits = /* @__PURE__ */ new Map();
+  const scopedToCollections = (opts.collections?.length ?? 0) > 0;
+  const scopedByFlags = opts.inputs.length > 0 || // redundant with inputs.length (stdin is an input) — kept as belt-and-suspenders
   usingStdin || opts.as !== void 0 || opts.exts !== void 0 || opts.exclude !== void 0 && opts.exclude.length > 0 || opts.respectGitignore !== void 0 || (opts.cliSchemas?.length ?? 0) > 0;
+  const scoped = scopedByFlags || scopedToCollections;
   const configuredChecks = config?.checks ?? [];
+  if (!scopedByFlags) {
+    const covered = scopedToCollections ? collections.map((c) => c.name) : void 0;
+    const orphans = orphanEntries(externalMetadata, files, base, covered);
+    if (orphans.length > 0) throw orphanError(orphans);
+  }
   const checksWillRun = configuredChecks.length > 0 && opts.checks !== false && !scoped;
   const checkEntries = [];
-  const checkResolved = /* @__PURE__ */ new Map();
   const processOne = async (label, content, extension) => {
     const extractor = forcedExtractor ?? extractorForExtension(extension);
     if (!extractor) {
@@ -7005,10 +7766,11 @@ async function runValidate(opts) {
         `Unsupported file type "${extension}" for "${label}". Supported: ${supportedExtensions().join(", ")}. Use --as to override.`
       );
     }
+    const members = membersFor(label);
     let extracted;
     try {
       extracted = extractor.extract(content, label, {
-        elements: resolveElements(label, config)
+        elements: resolveElements(label, config, members)
       });
     } catch (err) {
       if (err instanceof DocmetaError) throw err;
@@ -7017,6 +7779,16 @@ async function runValidate(opts) {
       );
       return;
     }
+    const merged = mergeExternalMetadata(label, extracted, externalMetadata, members, base);
+    extracted = merged.extracted;
+    for (const j of merged.joins) {
+      const byValue = joinHits.get(j.field) ?? /* @__PURE__ */ new Map();
+      const line = extracted.lineFor(j.field);
+      const hits = byValue.get(j.value) ?? [];
+      hits.push({ label, file: j.file, ...line != null ? { line } : {} });
+      byValue.set(j.value, hits);
+      joinHits.set(j.field, byValue);
+    }
     if (checksWillRun) checkEntries.push({ label, extracted });
     let resolved;
     try {
@@ -7025,6 +7797,7 @@ async function runValidate(opts) {
         fileSchema: extracted.data[FILE_SCHEMA_KEY],
         cliSchemas: opts.cliSchemas,
         config,
+        memberOf: members,
         // A document's own `$schema` is measured from the run's directory, the
         // same base `loadSchema` will read it from, and contained to the
         // repository the run is standing in.
@@ -7038,7 +7811,6 @@ async function runValidate(opts) {
       );
       return;
     }
-    if (checksWillRun) checkResolved.set(label, resolved);
     const schemaSet = resolved.schemas;
     let errors;
     try {
@@ -7046,7 +7818,8 @@ async function runValidate(opts) {
         extracted.data,
         schemaSet,
         extracted.lineFor,
-        extracted.colFor
+        extracted.colFor,
+        merged.locate
       );
     } catch (err) {
       if (!(err instanceof DocmetaError) || resolved.source !== "document") {
@@ -7057,6 +7830,17 @@ async function runValidate(opts) {
       );
       return;
     }
+    for (const { key, file, collection } of merged.collisions) {
+      const line = extracted.lineFor(key);
+      errors.push({
+        schema: EXTERNAL_OWNED_SCHEMA,
+        keyword: EXTERNAL_KEYWORD,
+        subject: key,
+        instancePath: externalMetadataPointer(key),
+        message: `"${key}" is owned by manifest ${file} (collection ${collection}); remove it from the document`,
+        ...line != null ? { line } : {}
+      });
+    }
     results.push({
       file: label,
       format: extractor.name,
@@ -7075,24 +7859,52 @@ async function runValidate(opts) {
     await processOne(STDIN_LABEL, content, forcedExtractor.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile5(resolve7(base, file), "utf8");
+    const content = await readFile6(resolve9(base, file), "utf8");
     await processOne(file, content, extname2(file));
   }
+  if (externalMetadata) {
+    const byLabel = new Map(results.map((r) => [r.file, r]));
+    const matched = /* @__PURE__ */ new Map();
+    for (const [field, byValue] of joinHits) {
+      matched.set(field, new Set(byValue.keys()));
+      for (const [value, hits] of byValue) {
+        if (hits.length < 2) continue;
+        for (const hit of hits) {
+          const others = hits.filter((h) => h.label !== hit.label).map((h) => h.label).join(", ");
+          const result = byLabel.get(hit.label);
+          if (!result) continue;
+          result.errors.push({
+            schema: EXTERNAL_DUPLICATE_SCHEMA,
+            keyword: EXTERNAL_KEYWORD,
+            subject: value,
+            instancePath: externalMetadataPointer(field),
+            message: `${hits.length} documents carry ${field} "${value}"; ${hit.file} cannot tell them apart (${others})`,
+            ...hit.line != null ? { line: hit.line } : {}
+          });
+          result.ok = false;
+        }
+      }
+    }
+    if (!scopedByFlags) {
+      const covered = scopedToCollections ? collections.map((c) => c.name) : void 0;
+      const orphans = orphanJoins(externalMetadata, matched, covered);
+      if (orphans.length > 0) throw orphanError(orphans);
+    }
+  }
   if (configuredChecks.length > 0 && opts.checks !== false) {
     if (scoped) {
-      opts.onNotice?.("corpus checks skipped: run is scoped");
+      opts.onNotice?.(
+        scopedToCollections ? `corpus checks skipped: run is scoped to collections ${collections.map((c) => c.name).join(", ")}` : "corpus checks skipped: run is scoped"
+      );
     } else {
       const findings = await runChecks(configuredChecks, checkEntries, {
-        // The same resolution inputs the per-file loop used, so a check's
-        // collection views (0027) hold exactly the files each override group
-        // was validated as — and `resolved` hands over that loop's outcomes,
-        // so membership is read from them instead of resolving twice.
-        config,
-        ...opts.cliSchemas ? { cliSchemas: opts.cliSchemas } : {},
-        fileBase: cwd,
-        trustRoot,
-        resolved: checkResolved,
-        ...opts.onNotice ? { onNotice: opts.onNotice } : {}
+        // Every declared collection is a view (0041 rule 7), holding the
+        // members this run loaded — decided by the same path arithmetic
+        // `membersFor` uses, so a check and a `manni meta query` over the same
+        // corpus see the same collections.
+        collections: declaredCollections,
+        ...configDir !== void 0 ? { configDir } : {},
+        base
       });
       const byFile = new Map(results.map((r) => [r.file, r]));
       for (const [file, errs] of findings) {
@@ -7167,24 +7979,25 @@ async function settleBaseline(results, request, ctx) {
 }
 
 // src/meta/commands/get.ts
-import { readFile as readFile6 } from "node:fs/promises";
-import { resolve as resolve8, extname as extname3 } from "node:path";
+import { readFile as readFile7 } from "node:fs/promises";
+import { resolve as resolve10, extname as extname3 } from "node:path";
 async function runGet(opts) {
   const cwd = opts.cwd ?? process.cwd();
   if (opts.fields.length === 0) {
     throw new DocmetaError("Specify at least one field to get.");
   }
-  const { config, inputs, base } = await resolveRunConfig({
+  const { config, inputs, base, configDir, collections, fromCollections } = await resolveRunConfig({
     cwd,
     configPath: opts.configPath,
     noConfig: opts.noConfig,
     inputs: opts.inputs,
+    ...opts.collections !== void 0 ? { collections: opts.collections } : {},
     onConfigLoaded: opts.onConfigLoaded
   });
   const usingStdin = inputs.includes(STDIN_TOKEN);
   if (inputs.length === 0) {
     throw new DocmetaError(
-      "No files to read. Pass paths/globs, or add `paths:` under `meta:` in manni.config.yaml."
+      "No files to read. Pass paths/globs, or declare a collection under `collections:` in manni.config.yaml."
     );
   }
   const forced = opts.as ? extractorByName(opts.as) : void 0;
@@ -7196,8 +8009,9 @@ async function runGet(opts) {
   const exts = opts.exts ?? (forced ? forced.extensions : void 0);
   const fileInputs = inputs.filter((i) => i !== STDIN_TOKEN);
   const allowEmpty = opts.allowEmpty ?? config?.allowEmpty;
-  const exclude = [...config?.exclude ?? [], ...opts.exclude ?? []];
-  const { files, gitignoreSkipped } = await resolveTargetSet({
+  const exclude = opts.exclude ?? [];
+  const membersFor = (label) => memberOf(collections, configDir ?? cwd, base, label);
+  const { files: walked, gitignoreSkipped } = await resolveTargetSet({
     inputs: fileInputs,
     exts,
     exclude,
@@ -7209,6 +8023,7 @@ async function runGet(opts) {
       onNotice: opts.onNotice
     })
   });
+  const files = fromCollections ? retainMembers(walked, membersFor) : walked;
   assertNonEmpty({
     files,
     inputs: fileInputs,
@@ -7220,6 +8035,11 @@ async function runGet(opts) {
     action: "read"
   });
   const out = [];
+  const externalMetadata = await loadExternalMetadata(collections, {
+    configDir: configDir ?? cwd,
+    base,
+    offline: opts.offline ?? config?.offline ?? false
+  });
   const readOne = (label, content, extension) => {
     const extractor = forced ?? extractorForExtension(extension);
     if (!extractor) {
@@ -7227,11 +8047,18 @@ async function runGet(opts) {
         `Unsupported file type "${extension}" for "${label}". Supported: ${supportedExtensions().join(", ")}. Use --as to override.`
       );
     }
+    const members = membersFor(label);
     let extracted;
     try {
-      extracted = extractor.extract(content, label, {
-        elements: resolveElements(label, config)
-      });
+      extracted = mergeExternalMetadata(
+        label,
+        extractor.extract(content, label, {
+          elements: resolveElements(label, config, members)
+        }),
+        externalMetadata,
+        members,
+        base
+      ).extracted;
     } catch (err) {
       if (err instanceof DocmetaError) throw err;
       const reason = err instanceof Error ? err.message : String(err);
@@ -7251,7 +8078,7 @@ async function runGet(opts) {
     readOne("<stdin>", opts.stdinContent ?? "", forced.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile6(resolve8(base, file), "utf8");
+    const content = await readFile7(resolve10(base, file), "utf8");
     readOne(file, content, extname3(file));
   }
   return out;
@@ -7288,16 +8115,16 @@ function parseJsonPointer(pointer) {
 
 // src/meta/commands/schemas.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { mkdir as mkdir2, readFile as readFile7 } from "node:fs/promises";
-import { dirname as dirname4, extname as extname4, isAbsolute as isAbsolute2, join as join5, relative as relative5, resolve as resolve9, sep } from "node:path";
-import { parseDocument as parseDocument3, parse as parseYaml3, stringify } from "yaml";
+import { mkdir as mkdir2, readFile as readFile8 } from "node:fs/promises";
+import { dirname as dirname5, extname as extname4, isAbsolute as isAbsolute4, join as join5, relative as relative8, resolve as resolve11, sep as sep4 } from "node:path";
+import { parseDocument as parseDocument4, parse as parseYaml3, stringify } from "yaml";
 function getSchemasInfo() {
   return { builtins: listBuiltins(), formats: listFormats() };
 }
 var DEFAULT_VENDOR_DIR = "./schema";
 var DEFAULT_CONFIG_NAME = "manni.config.yaml";
 function posixRelative(from, to) {
-  return relative5(from, to).split(sep).join("/");
+  return relative8(from, to).split(sep4).join("/");
 }
 function vendorFileName(url) {
   let parsed2;
@@ -7362,7 +8189,7 @@ function renderConfig(existing, entries, section) {
   if (existing === null) {
     return stringify({ [META_SECTION]: { schemas: entries } });
   }
-  const doc = parseDocument3(existing);
+  const doc = parseDocument4(existing);
   doc.setIn(section === void 0 ? ["schemas"] : [section, "schemas"], entries);
   return doc.toString();
 }
@@ -7383,13 +8210,13 @@ async function runVendorSchema(opts) {
     );
   }
   const loaded = await loadConfig(opts.configPath, cwd);
-  const configPath = loaded?.path ?? resolve9(cwd, DEFAULT_CONFIG_NAME);
+  const configPath = loaded?.path ?? resolve11(cwd, DEFAULT_CONFIG_NAME);
   const configDir = loaded?.dir ?? cwd;
-  const absDir = resolve9(cwd, opts.dir ?? DEFAULT_VENDOR_DIR);
+  const absDir = resolve11(cwd, opts.dir ?? DEFAULT_VENDOR_DIR);
   const absFile = join5(absDir, vendorFileName(url));
   await assertNotIgnored(absFile, absDir, cwd, opts.onNotice);
   const fromConfig = posixRelative(configDir, absFile);
-  const ref = isAbsolute2(fromConfig) || fromConfig === "" ? absFile : fromConfig.startsWith(".") ? fromConfig : `./${fromConfig}`;
+  const ref = isAbsolute4(fromConfig) || fromConfig === "" ? absFile : fromConfig.startsWith(".") ? fromConfig : `./${fromConfig}`;
   const { bytes } = await fetchSchemaBytes(url, {
     ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
     ...opts.maxBytes !== void 0 ? { maxBytes: opts.maxBytes } : {}
@@ -7404,7 +8231,7 @@ async function runVendorSchema(opts) {
   }
   let unchanged = false;
   if (existsSync3(absFile)) {
-    const current = await readFile7(absFile);
+    const current = await readFile8(absFile);
     unchanged = bytes.equals(current);
     if (!unchanged && !folded.replaced) {
       throw new DocmetaError(
@@ -7414,7 +8241,7 @@ async function runVendorSchema(opts) {
   }
   await mkdir2(absDir, { recursive: true });
   await writeFileAtomic(absFile, bytes);
-  const existing = loaded ? await readFile7(configPath, "utf8") : null;
+  const existing = loaded ? await readFile8(configPath, "utf8") : null;
   const section = loaded ? loaded.section : META_SECTION;
   const text = renderConfig(existing, folded.entries, section);
   reparseConfig(text, posixRelative(cwd, configPath) || DEFAULT_CONFIG_NAME, section);
@@ -7533,17 +8360,23 @@ async function runInferSchema(opts) {
       `--min-coverage must be a percentage between 0 and 100, got ${minCoverage}.`
     );
   }
-  const { config, inputs, base } = await resolveRunConfig({
+  const { config, inputs, base, configDir, collections, fromCollections } = await resolveRunConfig({
     cwd,
     configPath: opts.configPath,
     noConfig: opts.noConfig,
     inputs: opts.inputs,
+    ...opts.collections !== void 0 ? { collections: opts.collections } : {},
     onConfigLoaded: opts.onConfigLoaded
   });
   const usingStdin = inputs.includes(STDIN_TOKEN);
+  const externalMetadata = await loadExternalMetadata(collections, {
+    configDir: configDir ?? cwd,
+    base,
+    offline: opts.offline ?? config?.offline ?? false
+  });
   if (inputs.length === 0) {
     throw new DocmetaError(
-      "No files to scan. Pass paths/globs, or add `paths:` under `meta:` in manni.config.yaml."
+      "No files to scan. Pass paths/globs, or declare a collection under `collections:` in manni.config.yaml."
     );
   }
   const forced = opts.as ? extractorByName(opts.as) : void 0;
@@ -7559,10 +8392,10 @@ async function runInferSchema(opts) {
   }
   let absOut;
   if (opts.out !== void 0) {
-    absOut = resolve9(cwd, opts.out);
+    absOut = resolve11(cwd, opts.out);
     await assertNotIgnored(
       absOut,
-      dirname4(absOut),
+      dirname5(absOut),
       cwd,
       opts.onNotice,
       DRAFT_IGNORE_TEXT
@@ -7576,8 +8409,9 @@ async function runInferSchema(opts) {
   const exts = opts.exts ?? (forced ? forced.extensions : void 0);
   const fileInputs = inputs.filter((i) => i !== STDIN_TOKEN);
   const allowEmpty = opts.allowEmpty ?? config?.allowEmpty;
-  const exclude = [...config?.exclude ?? [], ...opts.exclude ?? []];
-  const { files, gitignoreSkipped } = await resolveTargetSet({
+  const exclude = opts.exclude ?? [];
+  const membersFor = (label) => memberOf(collections, configDir ?? cwd, base, label);
+  const { files: walked, gitignoreSkipped } = await resolveTargetSet({
     inputs: fileInputs,
     exts,
     exclude,
@@ -7589,6 +8423,7 @@ async function runInferSchema(opts) {
       onNotice: opts.onNotice
     })
   });
+  const files = fromCollections ? retainMembers(walked, membersFor) : walked;
   assertNonEmpty({
     files,
     inputs: fileInputs,
@@ -7611,11 +8446,18 @@ async function runInferSchema(opts) {
       );
     }
     filesScanned += 1;
+    const members = membersFor(label);
     let extracted;
     try {
-      extracted = extractor.extract(content, label, {
-        elements: resolveElements(label, config)
-      });
+      extracted = mergeExternalMetadata(
+        label,
+        extractor.extract(content, label, {
+          elements: resolveElements(label, config, members)
+        }),
+        externalMetadata,
+        members,
+        base
+      ).extracted;
     } catch (err) {
       unreadable.push({
         file: label,
@@ -7637,7 +8479,7 @@ async function runInferSchema(opts) {
     scanOne(STDIN_LABEL, opts.stdinContent ?? "", forced.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile7(resolve9(base, file), "utf8");
+    const content = await readFile8(resolve11(base, file), "utf8");
     scanOne(file, content, extname4(file));
   }
   for (const u of unreadable) {
@@ -7679,7 +8521,7 @@ async function runInferSchema(opts) {
   };
   const keys = kept.map(({ sawEmptyString: _drop, ...rest }) => rest);
   if (absOut !== void 0) {
-    await mkdir2(dirname4(absOut), { recursive: true });
+    await mkdir2(dirname5(absOut), { recursive: true });
     await writeFileAtomic(absOut, `${JSON.stringify(draft, null, 2)}
 `);
   }
@@ -7698,9 +8540,9 @@ async function runInferSchema(opts) {
 // src/meta/commands/query.ts
 import { randomBytes } from "node:crypto";
 import { existsSync as existsSync4 } from "node:fs";
-import { mkdir as mkdir3, open, readFile as readFile8, rename as rename2, rm as rm2 } from "node:fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute3, resolve as resolve10, extname as extname5, sep as sep2 } from "node:path";
-import { parseDocument as parseDocument4, isMap as isMap3, isSeq as isSeq2, isScalar as isScalar2 } from "yaml";
+import { mkdir as mkdir3, open, readFile as readFile9, rename as rename2, rm as rm2 } from "node:fs/promises";
+import { dirname as dirname6, isAbsolute as isAbsolute5, resolve as resolve12, extname as extname5, sep as sep5 } from "node:path";
+import { parseDocument as parseDocument5, isMap as isMap4, isSeq as isSeq2, isScalar as isScalar3 } from "yaml";
 async function runQuery(opts) {
   const cwd = opts.cwd ?? process.cwd();
   const sql = opts.sql.trim();
@@ -7732,19 +8574,29 @@ async function runQuery(opts) {
       );
     }
   }
-  const { config, inputs, base, configDir, configPath } = await resolveRunConfig(
-    {
-      cwd,
-      configPath: opts.configPath,
-      noConfig: opts.noConfig,
-      inputs: opts.inputs,
-      onConfigLoaded: opts.onConfigLoaded
-    }
-  );
+  const {
+    config,
+    inputs,
+    base,
+    configDir,
+    configPath,
+    configSection,
+    collections,
+    declaredCollections,
+    fromCollections
+  } = await resolveRunConfig({
+    cwd,
+    configPath: opts.configPath,
+    noConfig: opts.noConfig,
+    inputs: opts.inputs,
+    ...opts.collections !== void 0 ? { collections: opts.collections } : {},
+    onConfigLoaded: opts.onConfigLoaded
+  });
+  const membersFor = (label) => memberOf(collections, configDir ?? cwd, base, label);
   const usingStdin = inputs.includes(STDIN_TOKEN);
   if (inputs.length === 0) {
     throw new DocmetaError(
-      "No files to read. Pass paths/globs, or add `paths:` under `meta:` in manni.config.yaml."
+      "No files to read. Pass paths/globs, or declare a collection under `collections:` in manni.config.yaml."
     );
   }
   const forced = opts.as ? extractorByName(opts.as) : void 0;
@@ -7756,8 +8608,8 @@ async function runQuery(opts) {
   const exts = opts.exts ?? (forced ? forced.extensions : void 0);
   const fileInputs = inputs.filter((i) => i !== STDIN_TOKEN);
   const allowEmpty = opts.allowEmpty ?? config?.allowEmpty;
-  const exclude = [...config?.exclude ?? [], ...opts.exclude ?? []];
-  const { files, gitignoreSkipped } = await resolveTargetSet({
+  const exclude = opts.exclude ?? [];
+  const { files: walked, gitignoreSkipped } = await resolveTargetSet({
     inputs: fileInputs,
     exts,
     exclude,
@@ -7769,6 +8621,7 @@ async function runQuery(opts) {
       onNotice: opts.onNotice
     })
   });
+  const files = fromCollections ? retainMembers(walked, membersFor) : walked;
   assertNonEmpty({
     files,
     inputs: fileInputs,
@@ -7780,6 +8633,11 @@ async function runQuery(opts) {
     action: "queried"
   });
   const entries = [];
+  const externalMetadata = await loadExternalMetadata(collections, {
+    configDir: configDir ?? cwd,
+    base,
+    offline: opts.offline ?? config?.offline ?? false
+  });
   const readOne = (label, content, extension) => {
     const extractor = forced ?? extractorForExtension(extension);
     if (!extractor) {
@@ -7787,9 +8645,16 @@ async function runQuery(opts) {
         `Unsupported file type "${extension}" for "${label}". Supported: ${supportedExtensions().join(", ")}. Use --as to override.`
       );
     }
-    const extracted = extractor.extract(content, label, {
-      elements: resolveElements(label, config)
-    });
+    const members = membersFor(label);
+    const extracted = mergeExternalMetadata(
+      label,
+      extractor.extract(content, label, {
+        elements: resolveElements(label, config, members)
+      }),
+      externalMetadata,
+      members,
+      base
+    ).extracted;
     entries.push({ label, extracted, extractor });
   };
   if (usingStdin) {
@@ -7807,10 +8672,10 @@ async function runQuery(opts) {
     readOne(STDIN_LABEL, opts.stdinContent ?? "", ext);
   }
   for (const file of files) {
-    const content = await readFile8(resolve10(base, file), "utf8");
+    const content = await readFile9(resolve12(base, file), "utf8");
     readOne(file, content, extname5(file));
   }
-  const db = opts.db === void 0 ? void 0 : { resolved: resolve10(cwd, opts.db), display: opts.db };
+  const db = opts.db === void 0 ? void 0 : { resolved: resolve12(cwd, opts.db), display: opts.db };
   const run = await runSql(sql, entries, {
     target: db,
     params: boundParams,
@@ -7821,7 +8686,12 @@ async function runQuery(opts) {
     cwd,
     configDir,
     configPath,
+    configSection,
     trustRoot: schemaTrustRoot(cwd, configDir),
+    externalMetadata,
+    collections,
+    declaredCollections,
+    memberships: membersFor,
     onNotice: opts.onNotice
   });
   return { ...run, frame: { cwd, base: configDir ?? cwd, runBase: base } };
@@ -7885,7 +8755,7 @@ async function runSql(sql, entries, ctx) {
   );
   const { DatabaseSync } = await loadSqlite();
   if (target) {
-    await mkdir3(dirname5(target.resolved), { recursive: true });
+    await mkdir3(dirname6(target.resolved), { recursive: true });
     await prepareDbTarget(target.resolved, target.display);
   }
   let db;
@@ -7909,10 +8779,9 @@ async function runSql(sql, entries, ctx) {
       createCollectionViews(
         db,
         collectCollections(entries, {
-          config: ctx.config,
-          fileBase: ctx.cwd,
-          trustRoot: ctx.trustRoot,
-          ...ctx.onNotice ? { onNotice: ctx.onNotice } : {}
+          collections: ctx.declaredCollections,
+          ...ctx.configDir !== void 0 ? { configDir: ctx.configDir } : {},
+          base: ctx.base
         })
       );
       viewsBuilt = true;
@@ -7928,7 +8797,9 @@ async function runSql(sql, entries, ctx) {
       );
     }
     const lower = sql.toLowerCase();
-    const observesCatalog = lower.includes("sqlite_master") || lower.includes("sqlite_schema") || lower.includes("pragma") || /^(create|drop|alter)\b/i.test(head) || collectionNames(ctx.config).some((n) => lower.includes(n.toLowerCase()));
+    const observesCatalog = lower.includes("sqlite_master") || lower.includes("sqlite_schema") || lower.includes("pragma") || /^(create|drop|alter)\b/i.test(head) || collectionNames(ctx.declaredCollections).some(
+      (n) => lower.includes(n.toLowerCase())
+    );
     if (observesCatalog) buildViews();
     const sentinel = `manni:null:${randomBytes(16).toString("hex")}`;
     db.function("explicit_null", () => sentinel);
@@ -7942,7 +8813,7 @@ async function runSql(sql, entries, ctx) {
       } catch (err) {
         const message = err.message;
         const missing = missingTableName(message);
-        if (missing !== void 0 && !viewsBuilt && namesConfiguredCollection(missing, ctx.config)) {
+        if (missing !== void 0 && !viewsBuilt && namesConfiguredCollection(missing, ctx.declaredCollections)) {
           throw new MissingCollectionView();
         }
         refuseSqlError(err);
@@ -8016,9 +8887,9 @@ function missingTableName(message) {
   const at = message.indexOf(prefix);
   return at === -1 ? void 0 : message.slice(at + prefix.length);
 }
-function namesConfiguredCollection(missing, config) {
+function namesConfiguredCollection(missing, collections) {
   const candidates = [missing, missing.replace(/^(main|temp)\./i, "")];
-  return collectionNames(config).some(
+  return collectionNames(collections).some(
     (n) => candidates.some((c) => c.toLowerCase() === n.toLowerCase())
   );
 }
@@ -8337,20 +9208,20 @@ function displayPath(ctx, abs) {
 }
 function assertSchemaWriteWithin(ctx, abs) {
   const within = posixRelative(ctx.trustRoot.dir, abs);
-  if (within !== "" && !within.startsWith("..") && !isAbsolute3(within)) return;
+  if (within !== "" && !within.startsWith("..") && !isAbsolute5(within)) return;
   throw new DocmetaError(
     `The resolved schema "${abs}" lives outside ${ctx.trustRoot.dir}; DDL edits schemas inside the repository. Evolve it where it lives, or vendor a copy in.`
   );
 }
 function foldPath(p) {
-  const abs = resolve10(p);
+  const abs = resolve12(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(resolve10(ctx.cwd, ref)), pin);
+    byPath.set(foldPath(resolve12(ctx.cwd, ref)), pin);
   }
   return byPath;
 }
@@ -8378,13 +9249,13 @@ async function loadSetMembers(refs, ctx) {
       });
       continue;
     }
-    const abs = resolve10(ctx.cwd, ref);
+    const abs = resolve12(ctx.cwd, ref);
     const canon = foldPath(abs);
     if (seenFiles.has(canon)) continue;
     seenFiles.add(canon);
     let text;
     try {
-      text = await readFile8(abs, "utf8");
+      text = await readFile9(abs, "utf8");
     } catch {
       throw new DocmetaError(
         `Schema file not found: "${ref}" (looked at ${abs}).`
@@ -8454,6 +9325,7 @@ async function planSchemaMutation(ops, entries, ctx) {
           filePath: e.label,
           fileSchema: e.extracted.data[FILE_SCHEMA_KEY],
           config: ctx.config,
+          memberOf: ctx.memberships(e.label),
           fileBase: ctx.cwd,
           trustRoot: ctx.trustRoot,
           onNotice: ctx.onNotice
@@ -8480,7 +9352,11 @@ async function planSchemaMutation(ops, entries, ctx) {
     const overrides = ctx.config?.overrides ?? [];
     const named = [...groupIndexes].sort((a, b) => a - b).flatMap((i) => {
       const o = overrides[i];
-      return o?.name !== void 0 ? [`${o.name} (${overrideGlobs(o.files).join(", ")})`] : [];
+      if (o?.collection === void 0) return [];
+      const declared = ctx.collections.find((c) => c.name === o.collection);
+      return [
+        `${o.collection} (${overrideGlobs(declared?.paths).join(", ")})`
+      ];
     });
     const last = named[named.length - 1];
     const remedy = named.length >= 2 && last !== void 0 ? `The run spans ${[named.slice(0, -1).join(", "), last].join(" and ")}; re-run over one group's files, or pass -s <schema> to name the contract directly.` : "Scope the run to one override group, or pass -s <schema> to name the contract directly.";
@@ -8578,7 +9454,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 = resolve10(ctx.configDir ?? ctx.cwd, "schemas", forkName);
+    schemaAbs = resolve12(ctx.configDir ?? ctx.cwd, "schemas", forkName);
     assertSchemaWriteWithin(ctx, schemaAbs);
     if (existsSync4(schemaAbs)) {
       throw new DocmetaError(
@@ -8587,7 +9463,7 @@ async function planSchemaMutation(ops, entries, ctx) {
     }
     await assertNotIgnored(
       schemaAbs,
-      dirname5(schemaAbs),
+      dirname6(schemaAbs),
       ctx.cwd,
       ctx.onNotice,
       FORK_IGNORE_TEXT
@@ -8734,18 +9610,18 @@ async function planConfigEdit(ctx, edit, runRefs) {
   if (configPath === void 0 || configDir === void 0) {
     return { changes: [], repointed: false };
   }
-  const text = await readFile8(configPath, "utf8");
-  const doc = parseDocument4(stripBom(text));
+  const text = await readFile9(configPath, "utf8");
+  const doc = parseDocument5(stripBom(text));
   const display = displayPath(ctx, configPath);
   const rawRefOf = (item) => {
-    if (isScalar2(item) && typeof item.value === "string") return item.value;
-    if (isMap3(item)) {
+    if (isScalar3(item) && typeof item.value === "string") return item.value;
+    if (isMap4(item)) {
       const ref = item.get("ref");
       if (typeof ref === "string") return ref;
     }
     return void 0;
   };
-  const rebaseRaw = (raw) => classifyRef(raw).kind === "file" && !isAbsolute3(raw) ? resolve10(configDir, raw) : raw;
+  const rebaseRaw = (raw) => classifyRef(raw).kind === "file" && !isAbsolute5(raw) ? resolve12(configDir, raw) : raw;
   const wantSet = runRefs.map(rebaseRaw).sort().join("\n");
   const seqResolvesToRunSet = (node) => {
     if (!isSeq2(node)) return false;
@@ -8761,22 +9637,24 @@ async function planConfigEdit(ctx, edit, runRefs) {
     for (const item of node.items) {
       const raw = rawRefOf(item);
       if (raw === void 0 || !wants(raw)) continue;
-      if (isScalar2(item)) {
+      if (isScalar3(item)) {
         item.value = spec.newRef;
         n += 1;
-      } else if (isMap3(item)) {
+      } else if (isMap4(item)) {
         item.set("ref", spec.newRef);
         n += 1;
       }
     }
     return n;
   };
-  const topSeq = doc.get("schemas", true);
+  const root = ctx.configSection === void 0 ? doc : doc.get(ctx.configSection, true);
+  const keyOf2 = (key) => root === doc ? doc.get(key, true) : isMap4(root) ? root.get(key, true) : void 0;
+  const topSeq = keyOf2("schemas");
   let repointCount = repoint(topSeq);
-  const overrides = doc.get("overrides", true);
+  const overrides = keyOf2("overrides");
   if (isSeq2(overrides)) {
     for (const entry of overrides.items) {
-      if (isMap3(entry)) repointCount += repoint(entry.get("schemas", true));
+      if (isMap4(entry)) repointCount += repoint(entry.get("schemas", true));
     }
   }
   const repointed = repointCount > 0;
@@ -8785,10 +9663,10 @@ async function planConfigEdit(ctx, edit, runRefs) {
   if (edit.integrity && isSeq2(topSeq)) {
     const wantPath = foldPath(edit.integrity.path);
     for (const item of topSeq.items) {
-      if (!isMap3(item)) continue;
+      if (!isMap4(item)) continue;
       const raw = rawRefOf(item);
       if (raw === void 0 || classifyRef(raw).kind !== "file") continue;
-      const abs = isAbsolute3(raw) ? raw : resolve10(configDir, raw);
+      const abs = isAbsolute5(raw) ? raw : resolve12(configDir, raw);
       if (foldPath(abs) !== wantPath) continue;
       pinFrom = item.get("integrity");
       item.set("integrity", edit.integrity.value);
@@ -9009,7 +9887,7 @@ function buildChanges(diff, entries, sentinel, ctx, renameHints = [], booleanAdd
         `"${file}": no writable format for that extension.`
       );
     }
-    if (existsSync4(resolve10(ctx.base, file))) {
+    if (existsSync4(resolve12(ctx.base, file))) {
       throw new DocmetaError(
         `"${file}" already exists; INSERT creates new files only.`
       );
@@ -9028,26 +9906,81 @@ function buildChanges(diff, entries, sentinel, ctx, renameHints = [], booleanAdd
         `"${from}" -> "${to}": a rename may not change the extension.`
       );
     }
-    if (existsSync4(resolve10(ctx.base, to))) {
+    if (existsSync4(resolve12(ctx.base, to))) {
       throw new DocmetaError(
         `"${to}" already exists; the rename would overwrite it.`
       );
     }
     changes.push({ file: from, renamed: to, written: false });
   }
+  refuseExternalMetadataWrites(changes, entries, ctx);
   return changes;
 }
 function validateNewPath(p, base) {
   const refuse = (why) => {
     throw new DocmetaError(`"${p}" is not a usable path: ${why}.`);
   };
-  if (isAbsolute3(p)) refuse("it is absolute");
+  if (isAbsolute5(p)) refuse("it is absolute");
   if (p.split(/[\\/]/).some((segment) => segment === "..")) {
     refuse("it traverses upward");
   }
-  const abs = resolve10(base, p);
-  if (abs === resolve10(base)) refuse("it points at the corpus root, not a file");
-  if (!abs.startsWith(resolve10(base) + sep2)) refuse("it escapes the corpus");
+  const abs = resolve12(base, p);
+  if (abs === resolve12(base)) refuse("it points at the corpus root, not a file");
+  if (!abs.startsWith(resolve12(base) + sep5)) refuse("it escapes the corpus");
+}
+function refuseExternalMetadataWrites(changes, entries, ctx) {
+  const index = ctx.externalMetadata;
+  if (!index) return;
+  const owned = (key) => index.owners.get(key)?.[0]?.file;
+  const refuse = (file, key, owner) => {
+    throw new DocmetaError(
+      `"${file}": "${key}" is owned by manifest ${owner}; edit the manifest instead.`
+    );
+  };
+  const data = new Map(entries.map((e) => [e.label, e.extracted.data]));
+  for (const c of changes) {
+    if ("schema" in c || "config" in c) continue;
+    if ("cleared" in c) {
+      for (const key of Object.keys(data.get(c.file) ?? {})) {
+        const owner = owned(key);
+        if (owner !== void 0) refuse(c.file, key, owner);
+      }
+      continue;
+    }
+    if ("created" in c) {
+      for (const key of Object.keys(c.to)) {
+        const owner = owned(key);
+        if (owner !== void 0) refuse(c.file, key, owner);
+      }
+      continue;
+    }
+    if ("renamed" in c) {
+      const entry = index.byPath.get(resolve12(ctx.base, c.file));
+      if (entry !== void 0 && entry.size > 0) {
+        const manifest = [...entry.values()][0]?.file ?? "manifest";
+        throw new DocmetaError(
+          `"${c.file}": manifest ${manifest} names it; rename the manifest entry first.`
+        );
+      }
+      continue;
+    }
+    const keys = "renamedFrom" in c ? [c.key, c.renamedFrom] : [c.key];
+    for (const key of keys) {
+      const owner = owned(key);
+      if (owner !== void 0) refuse(c.file, key, owner);
+      const byValue = index.byField.get(key);
+      if (byValue === void 0) continue;
+      const raw = data.get(c.file)?.[key];
+      const value = typeof raw === "string" ? raw : typeof raw === "number" || typeof raw === "boolean" ? String(raw) : void 0;
+      const entry = value === void 0 ? void 0 : byValue.get(value);
+      if (entry !== void 0) {
+        const manifest = entry.values().next().value?.file ?? "manifest";
+        throw new DocmetaError(
+          `"${c.file}": "${key}" is the field manifest ${manifest} joins on, and this document has an entry; change the manifest first.`
+        );
+      }
+    }
+  }
 }
 async function applyChanges(changes, entries, ctx, schemaPlan) {
   const schemaWrites = schemaPlan?.writes ?? [];
@@ -9075,14 +10008,14 @@ async function applyChanges(changes, entries, ctx, schemaPlan) {
   const pendingWrites = [];
   const pendingRenames = [];
   for (const [label, ops] of grouped) {
-    const path = resolve10(ctx.base, label);
+    const path = resolve12(ctx.base, label);
     if (ops.renamedTo !== void 0) {
       if (!existsSync4(path)) {
         throw new DocmetaError(
           `"${label}" is gone from disk since it was read; re-run the query.`
         );
       }
-      const toDisk = resolve10(ctx.base, ops.renamedTo);
+      const toDisk = resolve12(ctx.base, ops.renamedTo);
       if (existsSync4(toDisk)) {
         throw new DocmetaError(
           `"${ops.renamedTo}" appeared on disk since the plan; re-run the query.`
@@ -9115,10 +10048,17 @@ async function applyChanges(changes, entries, ctx, schemaPlan) {
     }
     const entry = byLabel.get(label);
     if (!entry) throw new DocmetaError(`No loaded entry for "${label}".`);
-    const content = await readFile8(path, "utf8");
-    const current = entry.extractor.extract(content, label, {
-      elements: resolveElements(label, ctx.config)
-    });
+    const content = await readFile9(path, "utf8");
+    const members = ctx.memberships(label);
+    const current = mergeExternalMetadata(
+      label,
+      entry.extractor.extract(content, label, {
+        elements: resolveElements(label, ctx.config, members)
+      }),
+      ctx.externalMetadata,
+      members,
+      ctx.base
+    ).extracted;
     if (ops.cleared) {
       if (!deepEqual(current.data, entry.extracted.data)) {
         throw new DocmetaError(
@@ -9152,9 +10092,15 @@ async function applyChanges(changes, entries, ctx, schemaPlan) {
       deletions: ops.deletions
     });
     if (ops.deletions.length > 0) {
-      const check = entry.extractor.extract(applied, label, {
-        elements: resolveElements(label, ctx.config)
-      });
+      const check = mergeExternalMetadata(
+        label,
+        entry.extractor.extract(applied, label, {
+          elements: resolveElements(label, ctx.config, members)
+        }),
+        ctx.externalMetadata,
+        members,
+        ctx.base
+      ).extracted;
       for (const key of ops.deletions) {
         if (check.data[key] !== void 0) {
           throw new DocmetaError(
@@ -9177,7 +10123,7 @@ async function applyChanges(changes, entries, ctx, schemaPlan) {
     }
     let now;
     try {
-      now = await readFile8(w.path, "utf8");
+      now = await readFile9(w.path, "utf8");
     } catch {
       now = void 0;
     }
@@ -9188,10 +10134,10 @@ async function applyChanges(changes, entries, ctx, schemaPlan) {
     }
   }
   const dirs = /* @__PURE__ */ new Set();
-  for (const w of schemaWrites) dirs.add(dirname5(w.path));
-  for (const r of pendingRenames) dirs.add(dirname5(r.to));
+  for (const w of schemaWrites) dirs.add(dirname6(w.path));
+  for (const r of pendingRenames) dirs.add(dirname6(r.to));
   for (const p of pendingWrites) {
-    if (p.ensureDir) dirs.add(dirname5(p.path));
+    if (p.ensureDir) dirs.add(dirname6(p.path));
   }
   for (const d of dirs) await mkdir3(d, { recursive: true });
   const writeSchema = async () => {
@@ -9306,8 +10252,8 @@ function skipExpression(sql, from) {
 }
 
 // src/meta/commands/fill.ts
-import { readFile as readFile9 } from "node:fs/promises";
-import { resolve as resolve11, extname as extname6, join as join6 } from "node:path";
+import { readFile as readFile10 } from "node:fs/promises";
+import { resolve as resolve13, extname as extname6, join as join6 } from "node:path";
 import {
   completeValidatedJSON,
   makeProvider,
@@ -9450,11 +10396,12 @@ function addUsage(total, next) {
 }
 async function runFill(opts) {
   const cwd = opts.cwd ?? process.cwd();
-  const { config, inputs, base, configDir } = await resolveRunConfig({
+  const { config, inputs, base, configDir, collections, fromCollections } = await resolveRunConfig({
     cwd,
     configPath: opts.configPath,
     noConfig: opts.noConfig,
     inputs: opts.inputs,
+    ...opts.collections !== void 0 ? { collections: opts.collections } : {},
     onConfigLoaded: opts.onConfigLoaded
   });
   const schemaOptions = schemaLoadOptions({
@@ -9469,7 +10416,7 @@ async function runFill(opts) {
   const usingStdin = inputs.includes(STDIN_TOKEN);
   if (inputs.length === 0) {
     throw new DocmetaError(
-      "No files to fill. Pass paths/globs, or add `paths:` under `meta:` in manni.config.yaml."
+      "No files to fill. Pass paths/globs, or declare a collection under `collections:` in manni.config.yaml."
     );
   }
   const forcedExtractor = opts.as ? extractorByName(opts.as) : void 0;
@@ -9518,8 +10465,9 @@ async function runFill(opts) {
   const fileInputs = inputs.filter((i) => i !== STDIN_TOKEN);
   const allowEmpty = opts.allowEmpty ?? config?.allowEmpty;
   const fillExts = opts.exts ?? forcedExtractor?.extensions;
-  const fillExclude = [...config?.exclude ?? [], ...opts.exclude ?? []];
-  const { files, gitignoreSkipped } = await resolveTargetSet({
+  const fillExclude = opts.exclude ?? [];
+  const membersFor = (label) => memberOf(collections, configDir ?? cwd, base, label);
+  const { files: walked, gitignoreSkipped } = await resolveTargetSet({
     inputs: fileInputs,
     exts: fillExts,
     exclude: fillExclude,
@@ -9531,6 +10479,7 @@ async function runFill(opts) {
       onNotice: opts.onNotice
     })
   });
+  const files = fromCollections ? retainMembers(walked, membersFor) : walked;
   assertNonEmpty({
     files,
     inputs: fileInputs,
@@ -9580,6 +10529,11 @@ async function runFill(opts) {
   let turnsUsed = 0;
   let inFlight = 0;
   const turnsExhausted = () => maxTurns != null && turnsUsed + inFlight >= maxTurns;
+  const externalMetadata = await loadExternalMetadata(collections, {
+    configDir: configDir ?? cwd,
+    base,
+    offline: opts.offline ?? config?.offline ?? false
+  });
   const processOne = async (label, content, extension) => {
     const extractor = forcedExtractor ?? extractorForExtension(extension);
     if (!extractor) {
@@ -9596,10 +10550,19 @@ async function runFill(opts) {
         `The "${extractor.name}" format is read-only; manni meta fill cannot write metadata back to it.`
       );
     }
-    const elements = resolveElements(label, config);
+    const members = membersFor(label);
+    const elements = resolveElements(label, config, members);
     let extracted;
+    let merged;
     try {
-      extracted = extractor.extract(content, label, { elements });
+      merged = mergeExternalMetadata(
+        label,
+        extractor.extract(content, label, { elements }),
+        externalMetadata,
+        members,
+        base
+      );
+      extracted = merged.extracted;
     } catch (err) {
       return errorResult(label, extractor.name, err.message);
     }
@@ -9610,6 +10573,7 @@ async function runFill(opts) {
         fileSchema: extracted.data[FILE_SCHEMA_KEY],
         cliSchemas: opts.cliSchemas,
         config,
+        memberOf: members,
         // Same trust boundary as `validate`: `fill` writes metadata back into
         // the document, so a schema a document chose for itself decides what
         // gets written — if anything, a stronger reason to guard it.
@@ -9631,7 +10595,8 @@ async function runFill(opts) {
         extracted.data,
         schemaSet,
         extracted.lineFor,
-        extracted.colFor
+        extracted.colFor,
+        merged.locate
       );
     } catch (err) {
       if (!(err instanceof DocmetaError) || resolved.source !== "document") {
@@ -9645,6 +10610,19 @@ async function runFill(opts) {
       existingErrors,
       only
     );
+    const ownedCandidates = externalMetadata ? candidates.flatMap((c) => {
+      const owner = externalMetadata.owners.get(c.key)?.[0];
+      return owner === void 0 ? [] : [{ key: c.key, file: owner.file }];
+    }) : [];
+    const firstOwned = ownedCandidates[0];
+    if (firstOwned) {
+      return errorResult(
+        label,
+        extractor.name,
+        `"${firstOwned.key}" is owned by manifest ${firstOwned.file}; manni meta fill cannot write a manifest key. Add it to the manifest instead.`,
+        schemaSet
+      );
+    }
     if (candidates.length === 0) {
       return {
         file: label,
@@ -9785,9 +10763,9 @@ async function runFill(opts) {
     const fields = gate(candidates, proposals, threshold);
     const accepted = fields.filter((f) => f.written);
     if (accepted.length > 0) {
-      const merged = { ...extracted.data, ...patchOf(accepted) };
+      const merged2 = { ...extracted.data, ...patchOf(accepted) };
       const after = await validator.validate(
-        merged,
+        merged2,
         schemaSet,
         extracted.lineFor,
         extracted.colFor
@@ -9831,7 +10809,7 @@ async function runFill(opts) {
     }
     const changed = next !== content;
     if (changed && !dryRun && label !== "<stdin>") {
-      await writeFileAtomic(resolve11(base, label), next);
+      await writeFileAtomic(resolve13(base, label), next);
     }
     return {
       file: label,
@@ -9853,7 +10831,7 @@ async function runFill(opts) {
     );
   }
   const fileResults = await mapConcurrent(files, concurrency, async (file) => {
-    const content = await readFile9(resolve11(base, file), "utf8");
+    const content = await readFile10(resolve13(base, file), "utf8");
     return processOne(file, content, extname6(file));
   });
   results.push(...fileResults);
@@ -10171,15 +11149,19 @@ async function mapConcurrent(items, limit, fn) {
 }
 
 // src/meta/reporters/sarif.ts
-import { isAbsolute as isAbsolute4 } from "node:path";
+import { isAbsolute as isAbsolute6 } from "node:path";
 
 // src/meta/reporters/rule-id.ts
 var SYNTHETIC_SCHEMA = "(parse)";
 var PARSE_ERROR_RULE = "manni/parse-error";
 var SCHEMA_ERROR_RULE = "manni/schema-error";
+var EXTERNAL_OWNED_RULE = "external:owned/external";
+var EXTERNAL_DUPLICATE_RULE = "external:duplicate/external";
 var RESERVED_RULES = {
   [PARSE_ERROR_RULE]: "The document's metadata block could not be parsed.",
-  [SCHEMA_ERROR_RULE]: "No schema set could be resolved for the document."
+  [SCHEMA_ERROR_RULE]: "No schema set could be resolved for the document.",
+  [EXTERNAL_OWNED_RULE]: "The document carries a key a manifest owns; the manifest is the only place that key may be set.",
+  [EXTERNAL_DUPLICATE_RULE]: "Two documents carry the same value of a manifest's join field, so one manifest entry matched both."
 };
 function ruleIdFor(e, frame) {
   if (e.schema === SYNTHETIC_SCHEMA) {
@@ -10207,7 +11189,7 @@ function uriFrame(frame) {
 }
 function artifactUri(file, frame) {
   const uri = canonicalFilePath(file, frame);
-  if (uri === "" || uri.startsWith("../") || isAbsolute4(uri)) return null;
+  if (uri === "" || uri.startsWith("../") || isAbsolute6(uri)) return null;
   return uri;
 }
 function renderSarif(results, opts = {}) {
@@ -10221,12 +11203,13 @@ function renderSarif(results, opts = {}) {
   for (const r of results) {
     if (r.errors.length === 0) continue;
     if (r.file === STDIN_LABEL) continue;
-    const uri = artifactUri(r.file, pathFrame);
-    if (uri === null) {
-      dropped += r.errors.length;
-      continue;
-    }
+    const docUri = artifactUri(r.file, pathFrame);
     for (const e of r.errors) {
+      const uri = e.file != null ? artifactUri(e.file, pathFrame) : docUri;
+      if (uri === null) {
+        dropped += 1;
+        continue;
+      }
       const ruleId = ruleIdFor(e, frame);
       if (!rules.has(ruleId)) {
         rules.set(ruleId, {
@@ -10334,7 +11317,7 @@ function renderJunit(results, opts = {}) {
     }
     lines.push(`${open2}>`);
     for (const e of r.errors) {
-      const where = e.line != null ? ` (line ${e.line})` : "";
+      const where = e.file != null ? ` (${e.file}${e.line != null ? `:${e.line}` : ""})` : e.line != null ? ` (line ${e.line})` : "";
       lines.push(
         `      <failure${attr("type", ruleIdFor(e, opts.frame))}${attr(
           "message",
@@ -10443,7 +11426,7 @@ function renderPretty(results, summary, opts = {}) {
     }
     lines.push(`${c.red("\u2717")} ${r.file}${forgiven}`);
     for (const e of r.errors) {
-      const loc = e.line != null ? c.dim(`  (line ${e.line})`) : "";
+      const loc = e.file != null ? c.dim(`  (${e.file}${e.line != null ? `:${e.line}` : ""})`) : e.line != null ? c.dim(`  (line ${e.line})`) : "";
       lines.push(
         `    ${c.cyan(fieldLabel(e.instancePath))}  ${e.message}${loc}  ${c.dim(
           `[${e.schema}]`
@@ -10467,7 +11450,7 @@ function renderGithub(results) {
   const lines = [];
   for (const r of results) {
     for (const e of r.errors) {
-      const params = [`file=${escapeWorkflowCommandProperty(r.file)}`];
+      const params = [`file=${escapeWorkflowCommandProperty(e.file ?? r.file)}`];
       if (e.line != null) params.push(`line=${e.line}`);
       if (e.col != null) params.push(`col=${e.col}`);
       const msg = escapeWorkflowCommandMessage(
@@ -10746,6 +11729,10 @@ export {
   ToolError,
   programName,
   setProgramName,
+  externalMetadataUrlProblem,
+  parseCollections,
+  selectCollections,
+  isMember,
   findConfigFile,
   readConfigFile,
   escapeWorkflowCommandMessage,
@@ -10766,22 +11753,37 @@ export {
   fetchSchemaBytes,
   schemaLoadOptions,
   loadSchema,
+  DEFAULT_SCHEMAS,
+  schemaEntryRef,
+  collectSchemaPins,
+  rebaseConfigSchemaRefs,
+  resolveSchemaSet,
+  EXTERNAL_METADATA_FETCH_TIMEOUT_MS,
+  EXTERNAL_METADATA_FETCH_MAX_BYTES,
+  fetchExternalMetadata,
   locateFrontmatter,
   frontmatterInnerText,
   extractFrontmatter,
   applyFrontmatter,
   extractorForExtension,
   supportedExtensions,
-  DEFAULT_SCHEMAS,
-  schemaEntryRef,
-  collectSchemaPins,
-  rebaseConfigSchemaRefs,
-  resolveSchemaSet,
+  EXTERNAL_OWNED_SCHEMA,
+  EXTERNAL_DUPLICATE_SCHEMA,
+  EXTERNAL_KEYWORD,
+  PATH_JOIN,
+  externalMetadataJoin,
+  loadExternalMetadata,
+  mergeExternalMetadata,
+  externalMetadataPointer,
+  orphanEntries,
+  orphanJoins,
+  orphanError,
   parseConfig,
   loadConfig,
   resolveRunConfig,
-  Validator,
   isParamName,
+  memberOf,
+  Validator,
   rowsToFindings,
   runValidate,
   runGet,
@@ -10817,4 +11819,4 @@ export {
   renderQuery,
   renderQueryCsv
 };
-//# sourceMappingURL=chunk-2OALUJV2.js.map
+//# sourceMappingURL=chunk-L7HN3AWA.js.map