@hawkeyexl/manni 0.3.0 → 1.0.1

package/dist/{chunk-7M2YOXVG.js → chunk-IRHWILCO.js}

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@hawkeyexl/manni",
-  version: "0.3.0",
+  version: "1.0.1",
   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. */
@@ -126,6 +396,19 @@ var ToolError = class extends Error {
     this.name = "ToolError";
   }
 };
+function errorMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  if (typeof err === "object" && err !== null && "message" in err && typeof err.message === "string") {
+    return err.message;
+  }
+  try {
+    const json = JSON.stringify(err);
+    if (json !== void 0) return json;
+  } catch {
+  }
+  return String(err);
+}
 
 // src/meta/types.ts
 var DocmetaError = class extends ToolError {
@@ -2617,9 +2900,9 @@ function assertPublishableBuiltinId(id) {
       `Built-in id "${id}" is not publishable: the "check" first segment is reserved for corpus check identities (check:<name>, proposal 0026).`
     );
   }
-  if (first === "sidecar") {
+  if (first === "external") {
     throw new Error(
-      `Built-in id "${id}" is not publishable: the "sidecar" first segment is reserved for sidecar finding identities (sidecar:owned, proposal 0037).`
+      `Built-in id "${id}" is not publishable: the "external" first segment is reserved for external-metadata finding identities (external:owned, external:duplicate, proposal 0037).`
     );
   }
 }
@@ -2843,7 +3126,7 @@ async function requestSchema(ref, timeoutMs, timedOut) {
   } catch (err) {
     if (isAbort(err)) throw timedOut;
     throw new RetryableFetchError(
-      `Failed to fetch schema "${ref}": ${err.message}`
+      `Failed to fetch schema "${ref}": ${errorMessage(err)}`
     );
   }
   if (!res.ok) {
@@ -2875,7 +3158,7 @@ async function fetchSchemaBytes(ref, options = {}) {
     if (err instanceof DocmetaError) throw err;
     if (isAbort(err)) throw timedOut;
     throw new DocmetaError(
-      `Failed to fetch schema "${ref}": ${err.message}`
+      `Failed to fetch schema "${ref}": ${errorMessage(err)}`
     );
   }
   const raw = stripBom(bytes.toString("utf8"));
@@ -2884,7 +3167,7 @@ async function fetchSchemaBytes(ref, options = {}) {
     parsed2 = JSON.parse(raw);
   } catch (err) {
     throw new DocmetaError(
-      `Schema "${ref}" did not return valid JSON: ${err.message}`
+      `Schema "${ref}" did not return valid JSON: ${errorMessage(err)}`
     );
   }
   return { bytes, schema: assertFetchedSchema(ref, parsed2, raw) };
@@ -2997,14 +3280,13 @@ async function loadSchema(ref, options = {}) {
     return JSON.parse(text);
   } catch (err) {
     throw new DocmetaError(
-      `Schema file "${ref}" is not valid JSON: ${withoutFileExcerpt(err.message, text)}`
+      `Schema file "${ref}" is not valid JSON: ${withoutFileExcerpt(errorMessage(err), text)}`
     );
   }
 }
 
 // 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"
@@ -3044,21 +3326,15 @@ function rebaseConfigSchemaRefs(config, configDir, cwd) {
     } : {}
   };
 }
-var matcherCache = /* @__PURE__ */ new Map();
 function overrideGlobs(files) {
+  if (files === void 0) return [];
   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);
+function overrideMatches(override, filePath, memberOf2) {
+  if (override.collection !== void 0) {
+    return memberOf2.includes(override.collection);
   }
-  return m(filePath.replace(/\\/g, "/"));
+  return override.files !== void 0 && matchesFileGlob(filePath, override.files);
 }
 function coerceFileSchema(value) {
   if (value === void 0 || value === null) return void 0;
@@ -3136,8 +3412,9 @@ function resolveSchemaSetWithSource(params) {
     }
   }
   if (config?.overrides) {
+    const memberOf2 = params.memberOf ?? [];
     for (const [i, ov] of config.overrides.entries()) {
-      if (matches(ov.files, filePath) && ov.schemas.length > 0) {
+      if (overrideMatches(ov, filePath, memberOf2) && ov.schemas.length > 0) {
         return { schemas: dedupe(ov.schemas), source: "override", overrideIndex: i };
       }
     }
@@ -3153,55 +3430,37 @@ function resolveSchemaSetWithSource(params) {
 function resolveSchemaSet(params) {
   return resolveSchemaSetWithSource(params).schemas;
 }
-function resolveElements(filePath, config) {
+function resolveElements(filePath, config, memberOf2 = []) {
   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);
+    if (ov.elements && overrideMatches(ov, filePath, memberOf2)) {
+      out.push(...ov.elements);
+    }
   }
   return dedupe(out);
 }
 
-// src/meta/core/sidecar-fetch.ts
-var SIDECAR_FETCH_TIMEOUT_MS = 1e4;
-var SIDECAR_FETCH_MAX_BYTES = 5 * 1024 * 1024;
+// 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;
-function sidecarUrlProblem(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.");
-}
-async function fetchSidecar(url, opts = {}) {
+async function fetchExternalMetadata(url, opts = {}) {
   if (opts.offline) {
     throw new DocmetaError(
-      `Sidecar manifest ${url} is remote and the run is offline. Vendor it to a path, or drop --offline.`
+      `Manifest ${url} is remote and the run is offline. Vendor it to a path, or drop --offline.`
     );
   }
-  const timeoutMs = opts.timeoutMs ?? SIDECAR_FETCH_TIMEOUT_MS;
-  const maxBytes = opts.maxBytes ?? SIDECAR_FETCH_MAX_BYTES;
+  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(
-        `Sidecar manifest ${url}: the environment variable ${opts.tokenEnv} named by "tokenEnv" is not set.`
+        `Manifest ${url}: the environment variable ${opts.tokenEnv} named by "tokenEnv" is not set.`
       );
     }
   }
@@ -3212,13 +3471,13 @@ async function fetchSidecar(url, opts = {}) {
   }
   if (res instanceof Error) {
     throw new DocmetaError(
-      `Sidecar manifest ${url} could not be fetched: ${res.message}`
+      `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(
-      `Sidecar manifest ${url} could not be fetched: HTTP ${res.status}${hint}.`
+      `Manifest ${url} could not be fetched: HTTP ${res.status}${hint}.`
     );
   }
   return readCapped(url, res, maxBytes);
@@ -3265,7 +3524,7 @@ async function readCapped(url, res, maxBytes) {
     if (total > maxBytes) {
       await reader.cancel();
       throw new DocmetaError(
-        `Sidecar manifest ${url} is too large: the response exceeds the ${maxBytes}-byte limit.`
+        `Manifest ${url} is too large: the response exceeds the ${maxBytes}-byte limit.`
       );
     }
     chunks.push(value);
@@ -4933,7 +5192,7 @@ function applyXml(original, patch, options = {}) {
     before = readXml(original, options.filePath, { elements: options.elements });
   } catch (err) {
     throw new DocmetaError(
-      `Refusing to write metadata: ${err.message}`
+      `Refusing to write metadata: ${errorMessage(err)}`
     );
   }
   const content = before.body;
@@ -5068,7 +5327,7 @@ function verify2(next, before, patch, options) {
     }).data;
   } catch (err) {
     throw new DocmetaError(
-      `Refusing to write XML metadata: the rewritten document did not parse (${err.message}).`
+      `Refusing to write XML metadata: the rewritten document did not parse (${errorMessage(err)}).`
     );
   }
   if (!deepEqual(actual, expected)) {
@@ -5458,7 +5717,7 @@ function listFormats() {
   }));
 }
 
-// src/meta/core/sidecars.ts
+// 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 {
@@ -5473,7 +5732,7 @@ import {
 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 picomatch2 from "picomatch";
+import picomatch3 from "picomatch";
 
 // src/meta/core/gitignore.ts
 import { spawn } from "node:child_process";
@@ -5648,7 +5907,7 @@ async function resolveTargetSet(opts) {
       for (const f of found2) if (keepByExt(f)) walked.add(f);
       continue;
     }
-    if (!picomatch2.scan(posixInput).isGlob) {
+    if (!picomatch3.scan(posixInput).isGlob) {
       missing.push(posixInput);
       continue;
     }
@@ -5708,44 +5967,50 @@ function assertNonEmpty(p) {
   );
 }
 
-// src/meta/core/sidecars.ts
-var SIDECAR_OWNED_SCHEMA = "sidecar:owned";
-var SIDECAR_DUPLICATE_SCHEMA = "sidecar:duplicate";
-var SIDECAR_KEYWORD = "sidecar";
+// 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 sidecarJoin(sidecar) {
-  return sidecar.join ?? PATH_JOIN;
+function externalMetadataJoin(manifest) {
+  return manifest.join ?? PATH_JOIN;
 }
-async function loadSidecars(config, opts) {
-  const configured = config?.sidecars;
-  if (!configured || configured.length === 0) return null;
+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 sidecar of configured) {
+  for (const { collection, manifest } of configured) {
     let text;
     let file;
-    if (classifyRef(sidecar.file).kind === "url") {
-      file = sidecar.file;
-      text = await fetchSidecar(sidecar.file, {
-        ...sidecar.tokenEnv !== void 0 ? { tokenEnv: sidecar.tokenEnv } : {},
+    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(sidecar.file) ? sidecar.file : resolve5(opts.configDir, sidecar.file);
+      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 sidecar.keys) owners.set(key, file);
-    const join7 = sidecarJoin(sidecar);
+    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;
@@ -5757,7 +6022,16 @@ async function loadSidecars(config, opts) {
         byField.set(join7, target);
       }
     }
-    parseManifest(sidecar, text, file, opts.configDir, join7, target, entries);
+    parseManifest(
+      manifest,
+      collection,
+      text,
+      file,
+      opts.configDir,
+      join7,
+      target,
+      entries
+    );
   }
   return { owners, byPath, byField, entries };
 }
@@ -5767,27 +6041,27 @@ async function readManifest(abs, file) {
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
     throw new DocmetaError(
-      `Sidecar manifest ${file} could not be read: ${reason}`
+      `Manifest ${file} could not be read: ${reason}`
     );
   }
 }
-function parseManifest(sidecar, text, file, configDir, join7, target, entries) {
+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(
-      `Sidecar manifest ${file} is not valid YAML: ${problem.message}`
+      `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(
-      `Sidecar manifest ${file}: the manifest must be a mapping from document ${join7 === PATH_JOIN ? "path" : `"${join7}"`} to owned keys.`
+      `Manifest ${file}: the manifest must be a mapping from document ${join7 === PATH_JOIN ? "path" : `"${join7}"`} to owned keys.`
     );
   }
-  const owned = new Set(sidecar.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;
@@ -5800,13 +6074,13 @@ function parseManifest(sidecar, text, file, configDir, join7, target, entries) {
     if (seen.has(spelled)) {
       const first = seen.get(spelled);
       throw new DocmetaError(
-        `Sidecar manifest ${where}: "${spelled}" is named twice (first at line ${first ?? "?"}). Merge the two entries into one.`
+        `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(
-        `Sidecar manifest ${where}: "${spelled}" must be a mapping of owned keys to values.`
+        `Manifest ${where}: "${spelled}" must be a mapping of owned keys to values.`
       );
     }
     const indexKey = join7 === PATH_JOIN ? resolve5(configDir, spelled) : spelled;
@@ -5815,20 +6089,26 @@ function parseManifest(sidecar, text, file, configDir, join7, target, entries) {
       const key = isScalar2(kv.key) ? String(kv.key.value) : String(kv.key);
       if (key === FILE_SCHEMA_KEY) {
         throw new DocmetaError(
-          `Sidecar manifest ${where}: "${spelled}" sets "${FILE_SCHEMA_KEY}" \u2014 a sidecar never chooses the schema a document is judged by; use "overrides" in the config.`
+          `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(
-          `Sidecar manifest ${where}: "${spelled}" sets "${key}", which this sidecar does not own. Add it to the sidecar's "keys", or remove it from the entry.`
+          `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, file, ...line === void 0 ? {} : { line } });
+      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,
@@ -5843,13 +6123,19 @@ function joinValue(raw) {
   if (typeof raw === "boolean") return String(raw);
   return void 0;
 }
-function mergeSidecars(label, extracted, index, base) {
+function mergeExternalMetadata(label, extracted, index, memberOf2, base) {
   const none = () => void 0;
-  if (!index) return { extracted, collisions: [], joins: [], locate: none };
+  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)) {
-    const file = index.owners.get(key);
-    if (file !== void 0) collisions.push({ key, file });
+    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 = [];
@@ -5863,8 +6149,23 @@ function mergeSidecars(label, extracted, index, base) {
     const hit = byValue.get(value);
     if (!hit) continue;
     sources.push(hit);
-    const first = hit.values().next().value;
-    joins.push({ field, value, file: first?.file ?? "manifest" });
+    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 };
@@ -5873,6 +6174,7 @@ function mergeSidecars(label, extracted, index, base) {
   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);
@@ -5893,20 +6195,23 @@ function topLevelKey(pointer) {
   const seg = pointer.slice(1).split("/")[0] ?? "";
   return seg.replace(/~1/g, "/").replace(/~0/g, "~");
 }
-function sidecarPointer(key) {
+function externalMetadataPointer(key) {
   return `/${escapePointerSegment(key)}`;
 }
-function orphanEntries(index, loaded, base) {
+function orphanEntries(index, loaded, base, collections) {
   if (!index) return [];
   const have = new Set(loaded.map((l) => resolve5(base, l)));
   return index.entries.filter(
-    (e) => e.join === PATH_JOIN && e.abs !== void 0 && !have.has(e.abs)
+    (e) => inCollections(e, collections) && e.join === PATH_JOIN && e.abs !== void 0 && !have.has(e.abs)
   );
 }
-function orphanJoins(index, matched) {
+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) => e.join !== PATH_JOIN && !(matched.get(e.join)?.has(e.spelled) ?? false)
+    (e) => inCollections(e, collections) && e.join !== PATH_JOIN && !(matched.get(e.join)?.has(e.spelled) ?? false)
   );
 }
 function orphanError(orphans) {
@@ -5916,7 +6221,7 @@ function orphanError(orphans) {
   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(
-    `Sidecar manifest ${where} ${what}${more}. Fix the entry, or remove it.`
+    `Manifest ${where} ${what}${more}. Fix the entry, or remove it.`
   );
 }
 
@@ -5961,7 +6266,7 @@ function parseMapping(text, source, opts) {
   try {
     raw = parseYaml(text);
   } catch (err) {
-    throw opts.toError(`${source}: invalid YAML: ${err.message}`);
+    throw opts.toError(`${source}: invalid YAML: ${errorMessage(err)}`);
   }
   if (raw == null) return null;
   if (typeof raw !== "object" || Array.isArray(raw)) {
@@ -5969,13 +6274,22 @@ function parseMapping(text, source, opts) {
   }
   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, "/");
 }
@@ -5999,7 +6313,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) {
@@ -6008,7 +6330,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,
@@ -6017,7 +6339,8 @@ async function findConfigFile(cwd, opts) {
         text: document.text,
         value: document.doc,
         wrapped: false,
-        kind: "legacy"
+        kind: "legacy",
+        collections: []
       };
     }
   }
@@ -6039,6 +6362,7 @@ async function readConfigFile(explicitPath, cwd, opts) {
     source: explicitPath,
     text: document.text,
     kind: "explicit",
+    collections: collectionsOf(document, explicitPath, opts),
     ...found
   };
 }
@@ -6054,14 +6378,13 @@ function asElementPaths(value, where, source) {
     try {
       parseElementPath(path);
     } catch (err) {
-      throw new DocmetaError(`${source}: ${where} \u2014 ${err.message}`);
+      throw new DocmetaError(`${source}: ${where} \u2014 ${errorMessage(err)}`);
     }
   }
   return list;
 }
-var OVERRIDE_KEYS = ["name", "files", "schemas", "elements"];
+var OVERRIDE_KEYS = ["collection", "files", "schemas", "elements"];
 var CHECK_KEYS = ["name", "query"];
-var SIDECAR_KEYS = ["file", "keys", "tokenEnv", "join"];
 var CHECK_NAME = /^[a-z0-9][a-z0-9._-]*$/;
 var RESERVED_CHECK_NAMES = /* @__PURE__ */ new Set(["query"]);
 var FILL_KEYS = [
@@ -6073,12 +6396,9 @@ var FILL_KEYS = [
   "concurrency"
 ];
 var CONFIG_KEYS = [
-  "paths",
-  "exclude",
   "schemas",
   "overrides",
   "checks",
-  "sidecars",
   "baseline",
   "allowEmpty",
   "respectGitignore",
@@ -6088,7 +6408,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(
@@ -6158,7 +6478,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.`
@@ -6195,12 +6515,13 @@ function parseConfig(text, source) {
     raw = parseYaml2(text);
   } catch (err) {
     throw new DocmetaError(
-      `${source}: invalid YAML: ${err.message}`
+      `${source}: invalid YAML: ${errorMessage(err)}`
     );
   }
   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);
@@ -6222,92 +6543,56 @@ function withSection(message, source, section) {
   if (/^[a-zA-Z]+(\[|\.| —)/.test(rest)) return `${head}${section}.${rest}`;
   return message;
 }
-function parseSidecars(raw, source) {
-  if (!Array.isArray(raw)) {
-    throw new DocmetaError(`${source}: "sidecars" must be a list.`);
-  }
-  const owners = /* @__PURE__ */ new Map();
-  return raw.map((entry, i) => {
-    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-      throw new DocmetaError(`${source}: sidecars[${i}] must be a mapping.`);
-    }
-    const e = entry;
-    rejectUnknownKeys(e, SIDECAR_KEYS, `sidecars[${i}]`, source);
-    if (typeof e.file !== "string" || e.file.trim() === "") {
+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}: sidecars[${i}].file must be a non-empty string naming the manifest, relative to the config file.`
+        `${source}: "${key}" is no longer a meta key. ${remedy}`
       );
     }
-    if (!Array.isArray(e.keys) || e.keys.length === 0 || e.keys.some((k) => typeof k !== "string" || k.trim() === "")) {
+  }
+  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}: sidecars[${i}].keys must be a non-empty list of key names.`
+        `${source}: overrides[${i}] no longer carries "name". Define a collection with that name and point the override at it with collection:.`
       );
     }
-    const isUrl = classifyRef(e.file).kind === "url";
-    if (isUrl) {
-      const problem = sidecarUrlProblem(e.file);
-      if (problem !== null) {
-        throw new DocmetaError(`${source}: sidecars[${i}].file ${problem}.`);
-      }
-    }
-    if (e.tokenEnv !== void 0) {
-      if (typeof e.tokenEnv !== "string" || e.tokenEnv.trim() === "") {
-        throw new DocmetaError(
-          `${source}: sidecars[${i}].tokenEnv must be the name of an environment variable.`
-        );
-      }
-      if (!isUrl) {
-        throw new DocmetaError(
-          `${source}: sidecars[${i}].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 = e.keys;
-    if (e.join !== void 0) {
-      if (typeof e.join !== "string" || e.join.trim() === "") {
-        throw new DocmetaError(
-          `${source}: sidecars[${i}].join must be "path" or the name of a top-level frontmatter field.`
-        );
-      }
-      if (e.join === FILE_SCHEMA_KEY) {
-        throw new DocmetaError(
-          `${source}: sidecars[${i}].join may not be "${FILE_SCHEMA_KEY}".`
-        );
-      }
-      if (keys.includes(e.join)) {
-        throw new DocmetaError(
-          `${source}: sidecars[${i}].join names "${e.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 === FILE_SCHEMA_KEY) {
-        throw new DocmetaError(
-          `${source}: sidecars[${i}].keys may not include "${FILE_SCHEMA_KEY}" \u2014 a sidecar never chooses the schema a document is judged by; use "overrides".`
-        );
-      }
-      if (seen.has(key)) {
-        throw new DocmetaError(
-          `${source}: sidecars[${i}].keys lists "${key}" twice.`
-        );
-      }
-      seen.add(key);
-      const owner = owners.get(key);
-      if (owner !== void 0) {
-        throw new DocmetaError(
-          `${source}: sidecars[${i}].keys claims "${key}", which sidecars[${owner}] already owns \u2014 a key has exactly one sidecar.`
-        );
-      }
-      owners.set(key, i);
-    }
-    return {
-      file: e.file,
-      keys,
-      ...typeof e.tokenEnv === "string" ? { tokenEnv: e.tokenEnv } : {},
-      ...typeof e.join === "string" ? { join: e.join } : {}
-    };
-  });
+  }
+}
+function inSection(message, source, section) {
+  return section === void 0 ? message : withSection(message, source, section);
+}
+function assertOverrideCollections(config, collections, source, section) {
+  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(
+      inSection(
+        `${source}: overrides[${i}].collection names "${ov.collection}", which collections: does not define. Defined: ${defined}.`,
+        source,
+        section
+      )
+    );
+  }
 }
 function parseConfigDocument(raw, source) {
   if (raw == null) return {};
@@ -6315,76 +6600,55 @@ function parseConfigDocument(raw, source) {
     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 } : {}
       };
     });
   }
   if (obj.checks !== void 0) {
     config.checks = parseChecks(obj.checks, source);
   }
-  if (obj.sidecars !== void 0) {
-    config.sidecars = parseSidecars(obj.sidecars, source);
-  }
   if (obj.elements !== void 0) {
     config.elements = asElementPaths(obj.elements, "elements", source);
   }
@@ -6435,7 +6699,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.`
@@ -6470,7 +6734,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) {
@@ -6490,7 +6754,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) {
@@ -6517,7 +6781,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];
@@ -6560,29 +6824,318 @@ 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, section);
   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/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);
+  }
+}
+function corpusDataColumns(entries, extraKeys = []) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const { extracted } of entries) {
+    for (const key of Object.keys(extracted.data)) {
+      if (key !== "" && !RESERVED.has(key)) keys.add(key);
+    }
+  }
+  for (const key of extraKeys) {
+    if (key !== "" && !RESERVED.has(key)) keys.add(key);
+  }
+  return [...keys].sort();
+}
+function createDocsTable(db, entries, dataColumns) {
+  db.exec(
+    `CREATE TABLE docs ("_path" TEXT PRIMARY KEY, "_format" TEXT, "_present" INTEGER, "_data" TEXT${dataColumns.map((c) => `, ${quoteIdent(c)}`).join("")})`
+  );
+  const insert = db.prepare(
+    `INSERT INTO docs VALUES (${["?", "?", "?", "?", ...dataColumns.map(() => "?")].join(", ")})`
+  );
+  db.exec("BEGIN");
+  let committed = false;
+  try {
+    for (const { label, extracted } of entries) {
+      insert.run(
+        label,
+        extracted.format,
+        extracted.present ? 1 : 0,
+        JSON.stringify(extracted.data),
+        ...dataColumns.map((c) => bindValue(extracted.data[c]))
+      );
+    }
+    db.exec("COMMIT");
+    committed = true;
+  } finally {
+    if (!committed) db.exec("ROLLBACK");
+  }
+}
+function registerLineFor(db, entries) {
+  const byLabel = new Map(entries.map((e) => [e.label, e.extracted]));
+  db.function("lineFor", { deterministic: true }, (path, key) => {
+    if (typeof path !== "string" || typeof key !== "string") return null;
+    return byLabel.get(path)?.lineFor(key) ?? null;
+  });
+}
+function assertSingleStatement(sql) {
+  const cut = topLevelSemicolon(sql);
+  if (cut === -1) return;
+  if (!isTrivia(sql.slice(cut + 1))) {
+    throw new DocmetaError(
+      "Run a single SQL statement per query; text after the first `;` would be silently ignored."
+    );
+  }
+}
+function startsStringOrIdent(sql, i) {
+  const ch = sql[i];
+  return ch === "'" || ch === '"' || ch === "`" || ch === "[";
+}
+function startsComment(sql, i) {
+  const ch = sql[i];
+  return ch === "-" && sql[i + 1] === "-" || ch === "/" && sql[i + 1] === "*";
+}
+function skipStringOrIdent(sql, i) {
+  const quote = sql[i];
+  if (quote === "[") {
+    let j2 = i + 1;
+    while (j2 < sql.length && sql[j2] !== "]") j2++;
+    return j2 + 1;
+  }
+  let j = i + 1;
+  while (j < sql.length) {
+    if (sql[j] === quote) {
+      if (sql[j + 1] === quote) {
+        j += 2;
+        continue;
+      }
+      return j + 1;
+    }
+    j++;
+  }
+  return j;
+}
+function skipComment(sql, i) {
+  if (sql[i] === "-") {
+    let j = i + 2;
+    while (j < sql.length && sql[j] !== "\n") j++;
+    return j < sql.length ? j + 1 : j;
+  }
+  const end = sql.indexOf("*/", i + 2);
+  return end === -1 ? sql.length : end + 2;
+}
+function topLevelSemicolon(sql) {
+  let i = 0;
+  while (i < sql.length) {
+    if (startsStringOrIdent(sql, i)) {
+      i = skipStringOrIdent(sql, i);
+    } else if (startsComment(sql, i)) {
+      i = skipComment(sql, i);
+    } else if (sql[i] === ";") {
+      return i;
+    } else {
+      i++;
+    }
+  }
+  return -1;
+}
+var PARAM_NAME_HEAD = /^[A-Za-z_][A-Za-z0-9_]*/;
+function isParamName(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 tokens;
+}
+function stripLeadingTrivia(sql) {
+  let i = 0;
+  for (; ; ) {
+    while (i < sql.length && /\s/.test(sql[i] ?? "")) i++;
+    if (startsComment(sql, i)) {
+      i = skipComment(sql, i);
+      continue;
+    }
+    return sql.slice(i);
+  }
+}
+function isTrivia(text) {
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === void 0 || /\s/.test(ch) || ch === ";") {
+      i++;
+      continue;
+    }
+    if (startsComment(text, i)) {
+      i = skipComment(text, i);
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+var sqliteModule;
+function loadSqlite() {
+  sqliteModule ??= (async () => {
+    const original = process.emitWarning.bind(process);
+    const filtered = (warning, ...rest) => {
+      const text = typeof warning === "string" ? warning : warning.message;
+      if (text.includes("SQLite is an experimental feature")) return;
+      Reflect.apply(original, process, [warning, ...rest]);
+    };
+    process.emitWarning = filtered;
+    try {
+      return await import("node:sqlite");
+    } finally {
+      process.emitWarning = original;
+    }
+  })();
+  return sqliteModule;
+}
+
+// src/meta/core/collections.ts
+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 retainMembers(files, membersFor) {
+  return files.filter((label) => membersFor(label).length > 0);
+}
+function collectionNames(collections) {
+  return (collections ?? []).map((c) => c.name);
+}
+function collectCollections(entries, params) {
+  const declared = params.collections ?? [];
+  if (declared.length === 0) return [];
+  const base = params.base ?? ".";
+  const configDir = params.configDir ?? base;
+  const members = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const name2 of memberOf(declared, configDir, base, entry.label)) {
+      const list = members.get(name2);
+      if (list) list.push(entry.label);
+      else members.set(name2, [entry.label]);
+    }
+  }
+  return declared.map((c) => ({ name: c.name, members: members.get(c.name) ?? [] }));
+}
+function quoteSqlString(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function createCollectionViews(db, collections) {
+  for (const c of collections) {
+    const where = c.members.length === 0 ? "0" : `_path IN (${c.members.map(quoteSqlString).join(", ")})`;
+    db.exec(
+      `CREATE VIEW ${quoteIdent(c.name)} AS SELECT * FROM docs WHERE ${where}`
+    );
+  }
+}
+
 // src/meta/core/validator.ts
 import * as AjvDraft07Ns from "ajv";
 import * as Ajv2019Ns from "ajv/dist/2019.js";
@@ -6721,7 +7274,7 @@ var Validator = class {
       return ajv.compile(schema);
     } catch (err) {
       throw new DocmetaError(
-        `Schema "${ref}" failed to compile: ${err.message}`
+        `Schema "${ref}" failed to compile: ${errorMessage(err)}`
       );
     }
   }
@@ -6813,7 +7366,7 @@ 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 relative6, resolve as resolve8 } from "node:path";
+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;
@@ -6821,13 +7374,13 @@ var FINGERPRINT_RE = /^[0-9a-f]{16}$/;
 function canonicalFilePath(file, ctx) {
   if (!ctx) return file;
   const from = ctx.runBase ?? ctx.base;
-  return relative6(ctx.base, resolve8(from, file)).replace(/\\/g, "/");
+  return relative7(ctx.base, resolve8(from, file)).replace(/\\/g, "/");
 }
 function canonicalSchemaRef(ref, ctx) {
   if (!ctx) return ref;
   if (classifyRef(ref).kind !== "file") return ref;
   const abs = resolve8(ctx.cwd, ref);
-  return relative6(ctx.base, abs).replace(/\\/g, "/");
+  return relative7(ctx.base, abs).replace(/\\/g, "/");
 }
 function fingerprint(e, ctx) {
   const parts = [
@@ -6850,409 +7403,135 @@ function serializeBaseline(baseline) {
       entries
     },
     null,
-    2
-  )}
-`;
-}
-function bad(source, detail) {
-  throw new DocmetaError(`Baseline "${source}": ${detail}`);
-}
-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).`
-      );
-    }
-    entries[file] = value;
-  }
-  return { version: BASELINE_VERSION, generatedWith, entries };
-}
-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);
-}
-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 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/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);
-  }
-}
-function corpusDataColumns(entries, extraKeys = []) {
-  const keys = /* @__PURE__ */ new Set();
-  for (const { extracted } of entries) {
-    for (const key of Object.keys(extracted.data)) {
-      if (key !== "" && !RESERVED.has(key)) keys.add(key);
-    }
-  }
-  for (const key of extraKeys) {
-    if (key !== "" && !RESERVED.has(key)) keys.add(key);
-  }
-  return [...keys].sort();
-}
-function createDocsTable(db, entries, dataColumns) {
-  db.exec(
-    `CREATE TABLE docs ("_path" TEXT PRIMARY KEY, "_format" TEXT, "_present" INTEGER, "_data" TEXT${dataColumns.map((c) => `, ${quoteIdent(c)}`).join("")})`
-  );
-  const insert = db.prepare(
-    `INSERT INTO docs VALUES (${["?", "?", "?", "?", ...dataColumns.map(() => "?")].join(", ")})`
-  );
-  db.exec("BEGIN");
-  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 registerLineFor(db, entries) {
-  const byLabel = new Map(entries.map((e) => [e.label, e.extracted]));
-  db.function("lineFor", { deterministic: true }, (path, key) => {
-    if (typeof path !== "string" || typeof key !== "string") return null;
-    return byLabel.get(path)?.lineFor(key) ?? null;
-  });
-}
-function assertSingleStatement(sql) {
-  const cut = topLevelSemicolon(sql);
-  if (cut === -1) return;
-  if (!isTrivia(sql.slice(cut + 1))) {
-    throw new DocmetaError(
-      "Run a single SQL statement per query; text after the first `;` would be silently ignored."
-    );
-  }
-}
-function startsStringOrIdent(sql, i) {
-  const ch = sql[i];
-  return ch === "'" || ch === '"' || ch === "`" || ch === "[";
-}
-function startsComment(sql, i) {
-  const ch = sql[i];
-  return ch === "-" && sql[i + 1] === "-" || ch === "/" && sql[i + 1] === "*";
-}
-function skipStringOrIdent(sql, i) {
-  const quote = sql[i];
-  if (quote === "[") {
-    let j2 = i + 1;
-    while (j2 < sql.length && sql[j2] !== "]") j2++;
-    return j2 + 1;
-  }
-  let j = i + 1;
-  while (j < sql.length) {
-    if (sql[j] === quote) {
-      if (sql[j + 1] === quote) {
-        j += 2;
-        continue;
-      }
-      return j + 1;
-    }
-    j++;
-  }
-  return j;
-}
-function skipComment(sql, i) {
-  if (sql[i] === "-") {
-    let j = i + 2;
-    while (j < sql.length && sql[j] !== "\n") j++;
-    return j < sql.length ? j + 1 : j;
-  }
-  const end = sql.indexOf("*/", i + 2);
-  return end === -1 ? sql.length : end + 2;
-}
-function topLevelSemicolon(sql) {
-  let i = 0;
-  while (i < sql.length) {
-    if (startsStringOrIdent(sql, i)) {
-      i = skipStringOrIdent(sql, i);
-    } else if (startsComment(sql, i)) {
-      i = skipComment(sql, i);
-    } else if (sql[i] === ";") {
-      return i;
-    } else {
-      i++;
-    }
-  }
-  return -1;
+    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: ${errorMessage(err)}`);
   }
-  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: ${errorMessage(err)}`
+    );
+  }
+  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: ${errorMessage(err)}`
+    );
+  }
 }
-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
@@ -7335,7 +7614,7 @@ async function runChecks(checks, entries, ctx = {}) {
         tokens = collectNamedParameters(check.query);
       } catch (err) {
         throw new DocmetaError(
-          `check "${check.name}": ${err.message}`
+          `check "${check.name}": ${errorMessage(err)}`
         );
       }
       if (tokens.length > 0) {
@@ -7351,7 +7630,7 @@ async function runChecks(checks, entries, ctx = {}) {
         columns = stmt.columns().map((c) => c.name);
         rows = stmt.all();
       } catch (err) {
-        const message = err.message;
+        const message = errorMessage(err);
         throw new DocmetaError(
           message.includes("attempt to write a readonly database") ? `check "${check.name}": ${message} \u2014 checks are read-only by design; a check is a SELECT over the projection. Edit the corpus with \`manni meta query\` instead.` : `check "${check.name}": ${message}`
         );
@@ -7416,17 +7695,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;
@@ -7438,8 +7727,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,
@@ -7451,6 +7740,7 @@ async function runValidate(opts) {
       onNotice: opts.onNotice
     })
   });
+  const files = fromCollections ? retainMembers(walked, membersFor) : walked;
   assertNonEmpty({
     files,
     inputs: fileInputs,
@@ -7462,7 +7752,7 @@ async function runValidate(opts) {
     action: "validated"
   });
   const trustRoot = schemaTrustRoot(cwd, configDir);
-  const sidecars = await loadSidecars(config, {
+  const externalMetadata = await loadExternalMetadata(collections, {
     configDir: configDir ?? cwd,
     base,
     offline: opts.offline ?? config?.offline ?? false
@@ -7483,16 +7773,18 @@ async function runValidate(opts) {
   );
   const results = [];
   const joinHits = /* @__PURE__ */ new Map();
-  const scoped = opts.inputs.length > 0 || // redundant with inputs.length (stdin is an input) — kept as belt-and-suspenders
+  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 (!scoped) {
-    const orphans = orphanEntries(sidecars, files, base);
+  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) {
@@ -7500,19 +7792,20 @@ 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;
       results.push(
-        parseErrorResult(label, extractor.name, err.message, "parse")
+        parseErrorResult(label, extractor.name, errorMessage(err), "parse")
       );
       return;
     }
-    const merged = mergeSidecars(label, extracted, sidecars, base);
+    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();
@@ -7530,6 +7823,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.
@@ -7539,11 +7833,10 @@ async function runValidate(opts) {
       });
     } catch (err) {
       results.push(
-        parseErrorResult(label, extractor.name, err.message, "schema")
+        parseErrorResult(label, extractor.name, errorMessage(err), "schema")
       );
       return;
     }
-    if (checksWillRun) checkResolved.set(label, resolved);
     const schemaSet = resolved.schemas;
     let errors;
     try {
@@ -7563,14 +7856,14 @@ async function runValidate(opts) {
       );
       return;
     }
-    for (const { key, file } of merged.collisions) {
+    for (const { key, file, collection } of merged.collisions) {
       const line = extracted.lineFor(key);
       errors.push({
-        schema: SIDECAR_OWNED_SCHEMA,
-        keyword: SIDECAR_KEYWORD,
+        schema: EXTERNAL_OWNED_SCHEMA,
+        keyword: EXTERNAL_KEYWORD,
         subject: key,
-        instancePath: sidecarPointer(key),
-        message: `"${key}" is owned by sidecar ${file}; remove it from the document`,
+        instancePath: externalMetadataPointer(key),
+        message: `"${key}" is owned by manifest ${file} (collection ${collection}); remove it from the document`,
         ...line != null ? { line } : {}
       });
     }
@@ -7595,7 +7888,7 @@ async function runValidate(opts) {
     const content = await readFile6(resolve9(base, file), "utf8");
     await processOne(file, content, extname2(file));
   }
-  if (sidecars) {
+  if (externalMetadata) {
     const byLabel = new Map(results.map((r) => [r.file, r]));
     const matched = /* @__PURE__ */ new Map();
     for (const [field, byValue] of joinHits) {
@@ -7607,10 +7900,10 @@ async function runValidate(opts) {
           const result = byLabel.get(hit.label);
           if (!result) continue;
           result.errors.push({
-            schema: SIDECAR_DUPLICATE_SCHEMA,
-            keyword: SIDECAR_KEYWORD,
+            schema: EXTERNAL_DUPLICATE_SCHEMA,
+            keyword: EXTERNAL_KEYWORD,
             subject: value,
-            instancePath: sidecarPointer(field),
+            instancePath: externalMetadataPointer(field),
             message: `${hits.length} documents carry ${field} "${value}"; ${hit.file} cannot tell them apart (${others})`,
             ...hit.line != null ? { line: hit.line } : {}
           });
@@ -7618,26 +7911,26 @@ async function runValidate(opts) {
         }
       }
     }
-    if (!scoped) {
-      const orphans = orphanJoins(sidecars, matched);
+    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) {
@@ -7719,17 +8012,18 @@ async function runGet(opts) {
   if (opts.fields.length === 0) {
     throw new DocmetaError("Specify at least one field to get.");
   }
-  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 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;
@@ -7741,8 +8035,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,
@@ -7754,6 +8049,7 @@ async function runGet(opts) {
       onNotice: opts.onNotice
     })
   });
+  const files = fromCollections ? retainMembers(walked, membersFor) : walked;
   assertNonEmpty({
     files,
     inputs: fileInputs,
@@ -7765,7 +8061,7 @@ async function runGet(opts) {
     action: "read"
   });
   const out = [];
-  const sidecars = await loadSidecars(config, {
+  const externalMetadata = await loadExternalMetadata(collections, {
     configDir: configDir ?? cwd,
     base,
     offline: opts.offline ?? config?.offline ?? false
@@ -7777,14 +8073,16 @@ 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 = mergeSidecars(
+      extracted = mergeExternalMetadata(
         label,
         extractor.extract(content, label, {
-          elements: resolveElements(label, config)
+          elements: resolveElements(label, config, members)
         }),
-        sidecars,
+        externalMetadata,
+        members,
         base
       ).extracted;
     } catch (err) {
@@ -7844,7 +8142,7 @@ function parseJsonPointer(pointer) {
 // src/meta/commands/schemas.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { mkdir as mkdir2, readFile as readFile8 } from "node:fs/promises";
-import { dirname as dirname5, extname as extname4, isAbsolute as isAbsolute3, join as join5, relative as relative7, resolve as resolve11, sep as sep3 } from "node:path";
+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() };
@@ -7852,7 +8150,7 @@ function getSchemasInfo() {
 var DEFAULT_VENDOR_DIR = "./schema";
 var DEFAULT_CONFIG_NAME = "manni.config.yaml";
 function posixRelative(from, to) {
-  return relative7(from, to).split(sep3).join("/");
+  return relative8(from, to).split(sep4).join("/");
 }
 function vendorFileName(url) {
   let parsed2;
@@ -7944,7 +8242,7 @@ async function runVendorSchema(opts) {
   const absFile = join5(absDir, vendorFileName(url));
   await assertNotIgnored(absFile, absDir, cwd, opts.onNotice);
   const fromConfig = posixRelative(configDir, absFile);
-  const ref = isAbsolute3(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 } : {}
@@ -8088,22 +8386,23 @@ async function runInferSchema(opts) {
       `--min-coverage must be a percentage between 0 and 100, got ${minCoverage}.`
     );
   }
-  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 usingStdin = inputs.includes(STDIN_TOKEN);
-  const sidecars = await loadSidecars(config, {
+  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;
@@ -8136,8 +8435,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,
@@ -8149,6 +8449,7 @@ async function runInferSchema(opts) {
       onNotice: opts.onNotice
     })
   });
+  const files = fromCollections ? retainMembers(walked, membersFor) : walked;
   assertNonEmpty({
     files,
     inputs: fileInputs,
@@ -8171,14 +8472,16 @@ async function runInferSchema(opts) {
       );
     }
     filesScanned += 1;
+    const members = membersFor(label);
     let extracted;
     try {
-      extracted = mergeSidecars(
+      extracted = mergeExternalMetadata(
         label,
         extractor.extract(content, label, {
-          elements: resolveElements(label, config)
+          elements: resolveElements(label, config, members)
         }),
-        sidecars,
+        externalMetadata,
+        members,
         base
       ).extracted;
     } catch (err) {
@@ -8264,7 +8567,7 @@ async function runInferSchema(opts) {
 import { randomBytes } from "node:crypto";
 import { existsSync as existsSync4 } from "node:fs";
 import { mkdir as mkdir3, open, readFile as readFile9, rename as rename2, rm as rm2 } from "node:fs/promises";
-import { dirname as dirname6, isAbsolute as isAbsolute4, resolve as resolve12, extname as extname5, sep as sep4 } from "node:path";
+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();
@@ -8297,19 +8600,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;
@@ -8321,8 +8634,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,
@@ -8334,6 +8647,7 @@ async function runQuery(opts) {
       onNotice: opts.onNotice
     })
   });
+  const files = fromCollections ? retainMembers(walked, membersFor) : walked;
   assertNonEmpty({
     files,
     inputs: fileInputs,
@@ -8345,7 +8659,7 @@ async function runQuery(opts) {
     action: "queried"
   });
   const entries = [];
-  const sidecars = await loadSidecars(config, {
+  const externalMetadata = await loadExternalMetadata(collections, {
     configDir: configDir ?? cwd,
     base,
     offline: opts.offline ?? config?.offline ?? false
@@ -8357,12 +8671,14 @@ async function runQuery(opts) {
         `Unsupported file type "${extension}" for "${label}". Supported: ${supportedExtensions().join(", ")}. Use --as to override.`
       );
     }
-    const extracted = mergeSidecars(
+    const members = membersFor(label);
+    const extracted = mergeExternalMetadata(
       label,
       extractor.extract(content, label, {
-        elements: resolveElements(label, config)
+        elements: resolveElements(label, config, members)
       }),
-      sidecars,
+      externalMetadata,
+      members,
       base
     ).extracted;
     entries.push({ label, extracted, extractor });
@@ -8396,8 +8712,12 @@ async function runQuery(opts) {
     cwd,
     configDir,
     configPath,
+    configSection,
     trustRoot: schemaTrustRoot(cwd, configDir),
-    sidecars,
+    externalMetadata,
+    collections,
+    declaredCollections,
+    memberships: membersFor,
     onNotice: opts.onNotice
   });
   return { ...run, frame: { cwd, base: configDir ?? cwd, runBase: base } };
@@ -8440,7 +8760,7 @@ async function prepareDbTarget(resolved, display) {
 var MissingCollectionView = class extends Error {
 };
 function refuseSqlError(err) {
-  const message = err.message;
+  const message = errorMessage(err);
   if (message.includes("UNIQUE constraint failed: docs._path")) {
     throw new DocmetaError("That _path already exists in the corpus.");
   }
@@ -8469,7 +8789,7 @@ async function runSql(sql, entries, ctx) {
     db = new DatabaseSync(target ? target.resolved : ":memory:");
   } catch (err) {
     throw new DocmetaError(
-      `Cannot open "${target?.display ?? ":memory:"}": ${err.message}`
+      `Cannot open "${target?.display ?? ":memory:"}": ${errorMessage(err)}`
     );
   }
   const dbInfo = target ? {
@@ -8485,10 +8805,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;
@@ -8504,7 +8823,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);
@@ -8516,9 +8837,9 @@ async function runSql(sql, entries, ctx) {
         stmt = db.prepare(sql);
         columns = stmt.columns().map((c) => c.name);
       } catch (err) {
-        const message = err.message;
+        const message = errorMessage(err);
         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);
@@ -8592,9 +8913,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())
   );
 }
@@ -8913,7 +9234,7 @@ function displayPath(ctx, abs) {
 }
 function assertSchemaWriteWithin(ctx, abs) {
   const within = posixRelative(ctx.trustRoot.dir, abs);
-  if (within !== "" && !within.startsWith("..") && !isAbsolute4(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.`
   );
@@ -9030,12 +9351,13 @@ 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
         });
       } catch (err) {
-        throw new DocmetaError(`"${e.label}": ${err.message}`);
+        throw new DocmetaError(`"${e.label}": ${errorMessage(err)}`);
       }
       sources.add(resolved.source);
       if (resolved.overrideIndex !== void 0) {
@@ -9056,7 +9378,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.";
@@ -9321,7 +9647,7 @@ async function planConfigEdit(ctx, edit, runRefs) {
     }
     return void 0;
   };
-  const rebaseRaw = (raw) => classifyRef(raw).kind === "file" && !isAbsolute4(raw) ? resolve12(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;
@@ -9347,9 +9673,11 @@ async function planConfigEdit(ctx, edit, runRefs) {
     }
     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 (isMap4(entry)) repointCount += repoint(entry.get("schemas", true));
@@ -9364,7 +9692,7 @@ async function planConfigEdit(ctx, edit, runRefs) {
       if (!isMap4(item)) continue;
       const raw = rawRefOf(item);
       if (raw === void 0 || classifyRef(raw).kind !== "file") continue;
-      const abs = isAbsolute4(raw) ? raw : resolve12(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);
@@ -9611,28 +9939,28 @@ function buildChanges(diff, entries, sentinel, ctx, renameHints = [], booleanAdd
     }
     changes.push({ file: from, renamed: to, written: false });
   }
-  refuseSidecarWrites(changes, entries, ctx);
+  refuseExternalMetadataWrites(changes, entries, ctx);
   return changes;
 }
 function validateNewPath(p, base) {
   const refuse = (why) => {
     throw new DocmetaError(`"${p}" is not a usable path: ${why}.`);
   };
-  if (isAbsolute4(p)) refuse("it is absolute");
+  if (isAbsolute5(p)) refuse("it is absolute");
   if (p.split(/[\\/]/).some((segment) => segment === "..")) {
     refuse("it traverses upward");
   }
   const abs = resolve12(base, p);
   if (abs === resolve12(base)) refuse("it points at the corpus root, not a file");
-  if (!abs.startsWith(resolve12(base) + sep4)) refuse("it escapes the corpus");
+  if (!abs.startsWith(resolve12(base) + sep5)) refuse("it escapes the corpus");
 }
-function refuseSidecarWrites(changes, entries, ctx) {
-  const index = ctx.sidecars;
+function refuseExternalMetadataWrites(changes, entries, ctx) {
+  const index = ctx.externalMetadata;
   if (!index) return;
-  const owned = (key) => index.owners.get(key);
+  const owned = (key) => index.owners.get(key)?.[0]?.file;
   const refuse = (file, key, owner) => {
     throw new DocmetaError(
-      `"${file}": "${key}" is owned by sidecar ${owner}; edit the sidecar file instead.`
+      `"${file}": "${key}" is owned by manifest ${owner}; edit the manifest instead.`
     );
   };
   const data = new Map(entries.map((e) => [e.label, e.extracted.data]));
@@ -9657,7 +9985,7 @@ function refuseSidecarWrites(changes, entries, ctx) {
       if (entry !== void 0 && entry.size > 0) {
         const manifest = [...entry.values()][0]?.file ?? "manifest";
         throw new DocmetaError(
-          `"${c.file}": sidecar ${manifest} names it; rename the manifest entry first.`
+          `"${c.file}": manifest ${manifest} names it; rename the manifest entry first.`
         );
       }
       continue;
@@ -9674,7 +10002,7 @@ function refuseSidecarWrites(changes, entries, ctx) {
       if (entry !== void 0) {
         const manifest = entry.values().next().value?.file ?? "manifest";
         throw new DocmetaError(
-          `"${c.file}": "${key}" is the field sidecar ${manifest} joins on, and this document has an entry; change the manifest first.`
+          `"${c.file}": "${key}" is the field manifest ${manifest} joins on, and this document has an entry; change the manifest first.`
         );
       }
     }
@@ -9738,7 +10066,9 @@ async function applyChanges(changes, entries, ctx, schemaPlan) {
         path,
         content: extractor.apply("", ops.created, {
           filePath: label,
-          elements: resolveElements(label, ctx.config)
+          // The new file's memberships, from its path alone. An INSERT has to
+          // write through the element set a read of that file would use.
+          elements: resolveElements(label, ctx.config, ctx.memberships(label))
         }),
         ensureDir: true
       });
@@ -9747,12 +10077,14 @@ 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 readFile9(path, "utf8");
-    const current = mergeSidecars(
+    const members = ctx.memberships(label);
+    const current = mergeExternalMetadata(
       label,
       entry.extractor.extract(content, label, {
-        elements: resolveElements(label, ctx.config)
+        elements: resolveElements(label, ctx.config, members)
       }),
-      ctx.sidecars,
+      ctx.externalMetadata,
+      members,
       ctx.base
     ).extracted;
     if (ops.cleared) {
@@ -9784,16 +10116,19 @@ async function applyChanges(changes, entries, ctx, schemaPlan) {
     }
     const applied = entry.extractor.apply(content, ops.patch, {
       filePath: label,
-      elements: resolveElements(label, ctx.config),
+      // The memberships the read above used. Without them a collection-scoped
+      // element the read found has nowhere to be written.
+      elements: resolveElements(label, ctx.config, members),
       deletions: ops.deletions
     });
     if (ops.deletions.length > 0) {
-      const check = mergeSidecars(
+      const check = mergeExternalMetadata(
         label,
         entry.extractor.extract(applied, label, {
-          elements: resolveElements(label, ctx.config)
+          elements: resolveElements(label, ctx.config, members)
         }),
-        ctx.sidecars,
+        ctx.externalMetadata,
+        members,
         ctx.base
       ).extracted;
       for (const key of ops.deletions) {
@@ -9846,7 +10181,7 @@ async function applyChanges(changes, entries, ctx, schemaPlan) {
       await rename2(r.from, r.to);
     } catch (err) {
       throw new DocmetaError(
-        `Cannot move "${r.from}" to "${r.to}": ${err.message}`
+        `Cannot move "${r.from}" to "${r.to}": ${errorMessage(err)}`
       );
     }
   }
@@ -10091,11 +10426,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({
@@ -10110,7 +10446,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;
@@ -10159,8 +10495,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,
@@ -10172,6 +10509,7 @@ async function runFill(opts) {
       onNotice: opts.onNotice
     })
   });
+  const files = fromCollections ? retainMembers(walked, membersFor) : walked;
   assertNonEmpty({
     files,
     inputs: fileInputs,
@@ -10206,7 +10544,7 @@ async function runFill(opts) {
         provider = construct();
       } catch (err) {
         throw new DocmetaError(
-          err instanceof InferenceError ? err.message : `Could not construct the "${providerName}" provider: ${err.message}`
+          err instanceof InferenceError ? err.message : `Could not construct the "${providerName}" provider: ${errorMessage(err)}`
         );
       }
     }
@@ -10221,7 +10559,7 @@ async function runFill(opts) {
   let turnsUsed = 0;
   let inFlight = 0;
   const turnsExhausted = () => maxTurns != null && turnsUsed + inFlight >= maxTurns;
-  const sidecars = await loadSidecars(config, {
+  const externalMetadata = await loadExternalMetadata(collections, {
     configDir: configDir ?? cwd,
     base,
     offline: opts.offline ?? config?.offline ?? false
@@ -10242,19 +10580,21 @@ 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 {
-      merged = mergeSidecars(
+      merged = mergeExternalMetadata(
         label,
         extractor.extract(content, label, { elements }),
-        sidecars,
+        externalMetadata,
+        members,
         base
       );
       extracted = merged.extracted;
     } catch (err) {
-      return errorResult(label, extractor.name, err.message);
+      return errorResult(label, extractor.name, errorMessage(err));
     }
     let resolved;
     try {
@@ -10263,6 +10603,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.
@@ -10271,7 +10612,7 @@ async function runFill(opts) {
         onNotice: opts.onNotice
       });
     } catch (err) {
-      return errorResult(label, extractor.name, err.message);
+      return errorResult(label, extractor.name, errorMessage(err));
     }
     const schemaSet = resolved.schemas;
     let schemas;
@@ -10299,16 +10640,16 @@ async function runFill(opts) {
       existingErrors,
       only
     );
-    const ownedCandidates = sidecars ? candidates.flatMap((c) => {
-      const file = sidecars.owners.get(c.key);
-      return file === void 0 ? [] : [{ key: c.key, file }];
+    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 sidecar ${firstOwned.file}; manni meta fill cannot write a sidecar key. Add it to the manifest instead.`,
+        `"${firstOwned.key}" is owned by manifest ${firstOwned.file}; manni meta fill cannot write a manifest key. Add it to the manifest instead.`,
         schemaSet
       );
     }
@@ -10325,7 +10666,7 @@ async function runFill(opts) {
     try {
       extractor.apply(content, {}, { filePath: label, elements });
     } catch (err) {
-      return errorResult(label, extractor.name, err.message, schemaSet);
+      return errorResult(label, extractor.name, errorMessage(err), schemaSet);
     }
     const cacheKey = buildCacheKey([
       identity.provider,
@@ -10363,7 +10704,7 @@ async function runFill(opts) {
         return errorResult(
           label,
           extractor.name,
-          `Could not build a proposal schema from ${schemaSet.join(", ")}: ${err.message}`,
+          `Could not build a proposal schema from ${schemaSet.join(", ")}: ${errorMessage(err)}`,
           schemaSet
         );
       }
@@ -10491,7 +10832,7 @@ async function runFill(opts) {
       return errorResult(
         label,
         extractor.name,
-        err.message,
+        errorMessage(err),
         schemaSet,
         fields
       );
@@ -10791,7 +11132,7 @@ async function resolveIdentity(spec) {
     return await resolveProviderIdentityAsync(spec);
   } catch (err) {
     throw new DocmetaError(
-      err instanceof InferenceError ? err.message : `Could not resolve provider "${spec.provider}": ${err.message}`
+      err instanceof InferenceError ? err.message : `Could not resolve provider "${spec.provider}": ${errorMessage(err)}`
     );
   }
 }
@@ -10838,19 +11179,19 @@ async function mapConcurrent(items, limit, fn) {
 }
 
 // src/meta/reporters/sarif.ts
-import { isAbsolute as isAbsolute5 } 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 SIDECAR_OWNED_RULE = "sidecar:owned/sidecar";
-var SIDECAR_DUPLICATE_RULE = "sidecar:duplicate/sidecar";
+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.",
-  [SIDECAR_OWNED_RULE]: "The document carries a key a sidecar manifest owns; the manifest is the only place that key may be set.",
-  [SIDECAR_DUPLICATE_RULE]: "Two documents carry the same value of a sidecar's join field, so one manifest entry matched both."
+  [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) {
@@ -10878,7 +11219,7 @@ function uriFrame(frame) {
 }
 function artifactUri(file, frame) {
   const uri = canonicalFilePath(file, frame);
-  if (uri === "" || uri.startsWith("../") || isAbsolute5(uri)) return null;
+  if (uri === "" || uri.startsWith("../") || isAbsolute6(uri)) return null;
   return uri;
 }
 function renderSarif(results, opts = {}) {
@@ -11416,8 +11757,13 @@ export {
   palette,
   shouldColor,
   ToolError,
+  errorMessage,
   programName,
   setProgramName,
+  externalMetadataUrlProblem,
+  parseCollections,
+  selectCollections,
+  isMember,
   findConfigFile,
   readConfigFile,
   escapeWorkflowCommandMessage,
@@ -11443,32 +11789,32 @@ export {
   collectSchemaPins,
   rebaseConfigSchemaRefs,
   resolveSchemaSet,
-  SIDECAR_FETCH_TIMEOUT_MS,
-  SIDECAR_FETCH_MAX_BYTES,
-  sidecarUrlProblem,
-  fetchSidecar,
+  EXTERNAL_METADATA_FETCH_TIMEOUT_MS,
+  EXTERNAL_METADATA_FETCH_MAX_BYTES,
+  fetchExternalMetadata,
   locateFrontmatter,
   frontmatterInnerText,
   extractFrontmatter,
   applyFrontmatter,
   extractorForExtension,
   supportedExtensions,
-  SIDECAR_OWNED_SCHEMA,
-  SIDECAR_DUPLICATE_SCHEMA,
-  SIDECAR_KEYWORD,
+  EXTERNAL_OWNED_SCHEMA,
+  EXTERNAL_DUPLICATE_SCHEMA,
+  EXTERNAL_KEYWORD,
   PATH_JOIN,
-  sidecarJoin,
-  loadSidecars,
-  mergeSidecars,
-  sidecarPointer,
+  externalMetadataJoin,
+  loadExternalMetadata,
+  mergeExternalMetadata,
+  externalMetadataPointer,
   orphanEntries,
   orphanJoins,
   orphanError,
   parseConfig,
   loadConfig,
   resolveRunConfig,
-  Validator,
   isParamName,
+  memberOf,
+  Validator,
   rowsToFindings,
   runValidate,
   runGet,
@@ -11504,4 +11850,4 @@ export {
   renderQuery,
   renderQueryCsv
 };
-//# sourceMappingURL=chunk-7M2YOXVG.js.map
+//# sourceMappingURL=chunk-IRHWILCO.js.map