@hawkeyexl/manni 4.0.3 → 4.2.0

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

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 // package.json
 var package_default = {
   name: "@hawkeyexl/manni",
-  version: "4.0.3",
+  version: "4.2.0",
   description: "One command line for documentation that is meant to be checked. `manni meta` validates the presence and format of document metadata (Markdown frontmatter and more) against JSON Schema, built for CI. Formerly docmeta.",
   type: "module",
   bin: {
@@ -23,11 +23,20 @@ var package_default = {
       types: "./dist/index.d.ts",
       import: "./dist/index.js"
     },
+    "./graph/runtime": {
+      types: "./dist/graph/runtime.d.ts",
+      import: "./dist/graph/runtime.js"
+    },
+    "./graph/embed": {
+      types: "./dist/graph/embed.d.ts",
+      import: "./dist/graph/embed.js"
+    },
     "./package.json": "./package.json"
   },
   files: [
     "dist",
     "schemas",
+    "shapes",
     "templates"
   ],
   repository: {
@@ -46,11 +55,12 @@ var package_default = {
   },
   scripts: {
     prebuild: "npm run check:deps",
-    build: "tsup",
-    dev: "tsup --watch",
+    build: "node scripts/clean-dist.mjs && tsup",
+    dev: "node scripts/clean-dist.mjs && tsup --watch",
     pretest: "npm run check:deps",
     test: "vitest run",
     "test:watch": "vitest",
+    "test:graph:real": "vitest run --config vitest.graph-real.config.ts",
     "test:coverage": "vitest run --coverage",
     pretypecheck: "npm run check:deps",
     typecheck: "tsc --noEmit",
@@ -63,6 +73,8 @@ var package_default = {
     "docs:check-action": "node scripts/check-action-reference.mjs",
     "docs:check-api": "node scripts/check-api-reference.mjs",
     "docs:check-links": "node scripts/check-doc-links.mjs",
+    "docs:check-docevals": "node dist/cli.js docevals run --deterministic-only --no-generate",
+    "docs:check-graph": "node scripts/check-docs-graph.mjs",
     "docs:check-tables": "node scripts/check-table-rows.mjs",
     "docs:check-versions": "node scripts/check-versions.mjs",
     "docs:sync-versions": "node scripts/sync-versions.mjs",
@@ -92,7 +104,8 @@ var package_default = {
     "@apidevtools/json-schema-ref-parser": "^11.9.3",
     "@asciidoctor/core": "^3.0.4",
     "@axe-core/playwright": "^4.13.0",
-    "@hawkeyexl/inference": "^0.3.2",
+    "@hawkeyexl/inference": "^0.4.0",
+    "@types/n3": "^1.26.3",
     "@xmldom/xmldom": "^0.9.12",
     ajv: "^8.17.1",
     "ajv-draft-04": "^1.0.0",
@@ -101,10 +114,13 @@ var package_default = {
     "fast-glob": "^3.3.2",
     "github-slugger": "^2.0.0",
     "mdast-util-to-string": "^4.0.0",
+    minisearch: "^7.2.0",
+    n3: "^1.26.0",
     parse5: "^8.0.1",
     picocolors: "^1.1.1",
     picomatch: "^4.0.7",
     "playwright-core": "^1.63.0",
+    "rdf-validate-shacl": "^0.6.5",
     "remark-frontmatter": "^5.0.0",
     "remark-gfm": "^4.0.1",
     "remark-mdx": "^3.1.1",
@@ -117,26 +133,45 @@ var package_default = {
   devDependencies: {
     "@commitlint/cli": "^21.2.2",
     "@commitlint/config-conventional": "^21.2.2",
+    "@comunica/query-sparql-rdfjs-lite": "^5.3.0",
     "@eslint/js": "^10.0.1",
+    "@rdfjs/types": "^2.0.1",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/github": "^12.0.8",
     "@semantic-release/npm": "^13.1.5",
     "@semantic-release/release-notes-generator": "^14.1.1",
+    "@types/jsonld": "^1.5.15",
     "@types/mdast": "^4.0.4",
     "@types/node": "^26.3.0",
     "@types/picomatch": "^4.0.3",
     "@types/unist": "^3.0.3",
+    "@types/yauzl": "^3.4.0",
     "@vitest/coverage-v8": "^4.1.11",
     eslint: "^10.9.1",
     globals: "^17.11.0",
     husky: "^9.1.7",
+    jsonld: "^9.0.0",
+    "rdfxml-streaming-parser": "^3.3.0",
     "semantic-release": "^25.0.9",
     tsup: "^8.3.5",
     typescript: "^6.0.3",
     "typescript-eslint": "^8.68.0",
-    vitest: "^4.1.11"
+    vitest: "^4.1.11",
+    yauzl: "^3.4.0"
+  },
+  peerDependencies: {
+    "@huggingface/transformers": ">=4",
+    "node-llama-cpp": "^3.19.0"
+  },
+  peerDependenciesMeta: {
+    "@huggingface/transformers": {
+      optional: true
+    },
+    "node-llama-cpp": {
+      optional: true
+    }
   }
 };
 
@@ -3232,8 +3267,8 @@ var RENAME_ATTEMPTS = 3;
 function errorCode(err) {
   return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
 }
-var wait = (ms) => new Promise((resolve25) => {
-  setTimeout(resolve25, ms);
+var wait = (ms) => new Promise((resolve26) => {
+  setTimeout(resolve26, ms);
 });
 async function writeFileAtomic(path, contents, options = {}) {
   const tmp = join(
@@ -8344,6 +8379,251 @@ var __default47 = {
   }
 };
 
+// src/meta/schemas/stewardship/1.1.0.json
+var __default48 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "manni:stewardship:1.1.0",
+  title: "manni stewardship vocabulary v1.1.0",
+  description: "Is this page cared for? This vocabulary covers attribution, ownership, review, the document's own dates, and the anchors that make drift detectable. Every field records a fact a person asserts about the document, not one a tool reads off the file. That is why `created`, `last-updated` and `authors` are here. Git records when a path changed and who committed the change, not when the document was written or who wrote it. Those part company at every migration, split, squashed import, typo fix and bulk frontmatter sweep. A published page carries no repo, so a stamped date travels with the document where a derived one cannot. The cost is that a hand-typed `last-updated` goes stale quietly, and no JSON Schema can catch that. The review dates are records, not freshness gates. Tooling that can read a clock derives the due date from `last-reviewed` and `review-interval`. Version 1.1.0 adds `x-manni-graph-output: false` to `owner`, `stakeholders` and `reviewed-by`. Those three name people, so a published graph leaves them out: its Turtle, its JSON-LD, its iiRDS package and its search index. Validation is the same as in 1.0.0.",
+  type: "object",
+  additionalProperties: true,
+  properties: {
+    authors: {
+      type: [
+        "string",
+        "object",
+        "array"
+      ],
+      description: "Who wrote the page: a name, a list of names, or the structured person objects MyST and Docusaurus define. Attribution rather than answerability \u2014 `owner` is the party on the hook for the page now, and the two part company the moment an author moves on. Not a `stringList`, and not the only field here that isn't: `verified-against` and `source-of-truth` take the same string-or-object-or-list shape, as `entryList`. `authors` keeps its own inline copy rather than sharing that definition, because MyST and Docusaurus claim this key too and the composability law holds it at their loosest published definition, which `entryList`'s uniqueness and member floors go past. List members are names or person objects \u2014 never bare numbers or nulls. Never empty in any form: minLength, minItems and minProperties each bind to their own type and are ignored for the others.",
+      items: {
+        type: [
+          "string",
+          "object"
+        ]
+      },
+      minLength: 1,
+      minItems: 1,
+      minProperties: 1,
+      "x-manni-location": "external"
+    },
+    owner: {
+      $ref: "#/$defs/stringList",
+      description: "The person or team answerable for this page \u2014 the one required field of every docs-ownership system from Backstage to GitLab. A name, a handle, a chat channel, a team slug, or a list of them; write the spelling people can actually reach. A published graph does not carry it, because it names people.",
+      "x-manni-location": "external",
+      "x-manni-graph-output": false
+    },
+    stakeholders: {
+      $ref: "#/$defs/stringList",
+      description: "Who has a stake in this page being right: the feature's engineer, the product owner, the support lead who fields its tickets. The standing parties to consult before changing the page \u2014 where `reviewed-by` records who actually did the last pass. Page-level on purpose: the right stakeholders differ page by page, and project-wide ones belong in your project docs, not in every file's frontmatter. A published graph does not carry it, because it names people.",
+      "x-manni-location": "external",
+      "x-manni-graph-output": false
+    },
+    "reviewed-by": {
+      $ref: "#/$defs/stringList",
+      description: "Who last reviewed the page. Named `reviewed-by` rather than `reviewers` because MyST already defines `reviewers` as scholarly person objects. A published graph does not carry it, because it names people.",
+      "x-manni-location": "external",
+      "x-manni-graph-output": false
+    },
+    created: {
+      $ref: "#/$defs/w3cdtf",
+      description: "When the document was written, as a W3CDTF date. The document's date, not the file's: a page migrated from a CMS, imported from another repo, split out of a longer one, or landed through a squashed history has a path in this repo that is younger than the content it holds, and `git log` can only report the path. Where the two agree, git agreeing is a bonus rather than the source.",
+      "x-manni-location": "external"
+    },
+    "last-updated": {
+      $ref: "#/$defs/w3cdtf",
+      description: "When the content last changed in a way a reader would notice, as a W3CDTF date. The editorial fact, not the file's: a commit date also moves for a typo fix, a link sweep, a formatting pass and a bulk frontmatter migration, none of which change what the page says. Distinct from `last-reviewed`, which records the page being checked and found still true \u2014 an update changes the content, a review confirms it, and a page can have either without the other. Spelled with the `last-` prefix for exactly the reason `last-reviewed` carries one: both name the most recent instance of a repeating event, and the two read as the pair they are. That also keeps the key clear of every neighbour's spelling of the same fact, which are `lastmod`, `last_update`, `lastUpdated` and `article:modified_time`. A stale value here is the accepted cost of stamping a date instead of deriving one, and a check comparing it against the repo's own last-change date is the tooling answer, not a schema's.",
+      "x-manni-location": "page"
+    },
+    "last-reviewed": {
+      $ref: "#/$defs/w3cdtf",
+      description: "When the page was last reviewed, as a W3CDTF date. The field freshness tooling reads to derive review deadlines. A record, not a freshness gate \u2014 JSON Schema cannot compare a date to today.",
+      "x-manni-location": "external"
+    },
+    "review-interval": {
+      type: "string",
+      pattern: "^P(?:\\d+W|(?=\\d|T\\d)(?:\\d+Y)?(?:\\d+M)?(?:\\d+D)?(?:T(?=\\d)(?:\\d+H)?(?:\\d+M)?(?:\\d+S)?)?)$",
+      description: "How often the page should be reviewed, as an ISO 8601 duration: `P90D`, `P1Y`. ISO rather than `90d` so the value is machine-comparable. With `last-reviewed`, this is everything review tooling needs to derive the due date \u2014 a stored due date would only ever agree with them or lie.",
+      "x-manni-location": "external"
+    },
+    "verified-against": {
+      $ref: "#/$defs/entryList",
+      description: 'The product version, API revision, or spec the content was last verified against. A string is the short spelling \u2014 `operator 1.4.2` \u2014 and an object the checkable one, such as `{name: operator, version: 1.4.2}`, which a drift check can compare without parsing prose. A list says a page was verified against more than one thing, such as the operator and the cluster it runs on. What turns "reviewed" into "reviewed against something".',
+      "x-manni-location": "external"
+    },
+    "source-of-truth": {
+      $ref: "#/$defs/entryList",
+      description: "Where reality lives for this page: a repo path, an API spec, a schema file. A string names it, an object structures it \u2014 `{path: charts/operator/values.yaml, kind: helm-values}` \u2014 and a list carries several, because a page usually answers to more than one source. The anchor a drift check compares the page against; a page without one cannot be drift-monitored.",
+      "x-manni-location": "external"
+    }
+  },
+  $defs: {
+    stringList: {
+      if: {
+        type: "array"
+      },
+      then: {
+        type: "array",
+        minItems: 1,
+        uniqueItems: true,
+        items: {
+          type: "string",
+          minLength: 1
+        }
+      },
+      else: {
+        type: "string",
+        minLength: 1
+      },
+      description: "One non-empty string, or a non-empty list of unique ones \u2014 the same shape as the `labelList` of manni:graph:1.0.0."
+    },
+    entryList: {
+      type: [
+        "string",
+        "object",
+        "array"
+      ],
+      items: {
+        $comment: "The parent's keyword-per-type pattern again, one level down: minLength binds to a string member, minProperties to an object one, and each is ignored for the other. Repeated here rather than hoisted because a member's floor is a different assertion from the whole value's.",
+        type: [
+          "string",
+          "object"
+        ],
+        minLength: 1,
+        minProperties: 1
+      },
+      minLength: 1,
+      minItems: 1,
+      minProperties: 1,
+      uniqueItems: true,
+      description: 'One entry, or a non-empty list of unique ones, where an entry is a non-empty string or a non-empty object. The shape `authors` carries, made a definition because two more fields need it: the short human spelling and the structured machine-checkable one, without minting a second field name for the same fact. Object keys are left open on purpose, and the recommendations live in each field\'s description. Every non-empty floor binds to its own type \u2014 minLength for the string, minProperties for the object, minItems and uniqueItems for the list \u2014 and `items` repeats the first two, so `""`, `[]`, `{}`, `[""]` and `[{}]` all fail. Unlike `authors`, no other schema claims the keys that use this, so the family is free to set that floor.',
+      $comment: "minLength, minItems, minProperties and uniqueItems each apply to one instance type and are ignored for the others; that is what lets one subschema hold three shapes without an anyOf whose errors name all three branches."
+    },
+    w3cdtf: {
+      type: "string",
+      pattern: "^[0-9]{4}(-(0[1-9]|1[0-2])(-(0[1-9]|[12][0-9]|3[01])(T([01][0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9](\\.[0-9]+)?)?(Z|[+-]([01][0-9]|2[0-3]):[0-5][0-9]))?)?)?$",
+      description: "A W3CDTF date, permitting reduced precision: `2026`, `2026-08`, `2026-08-23`, or a full timestamp \u2014 in which case the timezone designator is required, as the W3CDTF profile itself mandates (no local-time form). Field-ranged (month 01-12, day 01-31, hour 00-23) so an impossible date fails here rather than becoming Invalid Date in the tooling that derives review deadlines; not calendar-exact \u2014 February 31 is a reviewer's catch."
+    }
+  }
+};
+
+// src/meta/schemas/stewardship-strict/1.1.0.json
+var __default49 = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "manni:stewardship-strict:1.1.0",
+  title: "manni stewardship strict overlay v1.1.0",
+  description: "The strict overlay for manni:stewardship:1.1.0. Stack it beside the open vocabulary. It narrows the form of values the open vocabulary already claims and requires no key.",
+  additionalProperties: true,
+  type: "object",
+  properties: {
+    authors: {
+      type: "array",
+      uniqueItems: true,
+      items: {
+        pattern: "^\\S(?:.*\\S)?$",
+        required: [
+          "name"
+        ],
+        properties: {
+          name: {
+            type: "string",
+            pattern: "^\\S(?:.*\\S)?$"
+          },
+          email: {
+            type: "string",
+            pattern: "^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$"
+          },
+          url: {
+            type: "string",
+            pattern: "^https?://\\S+$"
+          }
+        }
+      },
+      description: "Strict takes authors as a list of unique entries. A string entry is one line with no surrounding space. A person object names the person, and its `email` and `url` are well formed."
+    },
+    owner: {
+      $ref: "#/$defs/handles",
+      description: "Strict holds each owner to a handle a GitHub or GitLab CODEOWNERS file accepts, in the string form and the list form alike."
+    },
+    stakeholders: {
+      $ref: "#/$defs/names",
+      description: "Strict holds each stakeholder to one line with no surrounding space. A stakeholder is a person or team, named in any form."
+    },
+    "reviewed-by": {
+      $ref: "#/$defs/names",
+      description: "Strict holds each reviewer to one line with no surrounding space. `manni meta derive` writes review-API logins and commit-trailer names, so no handle form is required."
+    },
+    created: {
+      $ref: "#/$defs/date",
+      description: "Strict holds the creation date to an RFC 3339 full date or date-time. A year or month alone fails, and so does a timestamp without seconds."
+    },
+    "last-updated": {
+      $ref: "#/$defs/date",
+      description: "Strict holds the update date to an RFC 3339 full date or date-time. A year or month alone fails, and so does a timestamp without seconds."
+    },
+    "last-reviewed": {
+      $ref: "#/$defs/date",
+      description: "Strict holds the review date to an RFC 3339 full date or date-time. A year or month alone fails, and so does a timestamp without seconds."
+    },
+    "verified-against": {
+      required: [
+        "name",
+        "version"
+      ],
+      items: {
+        required: [
+          "name",
+          "version"
+        ]
+      },
+      description: "Strict requires an object entry to carry `name` and `version`, alone or in a list. The version's format stays free, and a string entry is unchanged. The top-level `required` holds the single-object form, and `items` holds each object in a list, since `required` applies only to an object."
+    },
+    "source-of-truth": {
+      $ref: "#/$defs/source",
+      items: {
+        $ref: "#/$defs/source"
+      },
+      description: "Strict requires an object entry to carry `path` or `url`, alone or in a list. A string entry is one id, path or URL on one line with no surrounding space. The top-level `$ref` holds the string and single-object forms, and `items` holds each entry in a list, since `required` applies only to an object."
+    }
+  },
+  $defs: {
+    handles: {
+      pattern: "^(?:@@?[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?(?:/[A-Za-z0-9._-]+)*|[^\\s@]+@[^\\s@]+\\.[^\\s@]+)$",
+      items: {
+        pattern: "^(?:@@?[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?(?:/[A-Za-z0-9._-]+)*|[^\\s@]+@[^\\s@]+\\.[^\\s@]+)$"
+      },
+      description: "A handle a CODEOWNERS file accepts, as a string or as each member of a list. That is `@user`, `@org/team`, a GitLab nested group or `@@role`, or an email address."
+    },
+    names: {
+      pattern: "^\\S(?:.*\\S)?$",
+      items: {
+        pattern: "^\\S(?:.*\\S)?$"
+      },
+      description: "One line with no surrounding space, as a string or as each member of a list."
+    },
+    date: {
+      type: "string",
+      pattern: "^[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])(?:T(?:[01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\\.[0-9]+)?(?:Z|[+-](?:[01][0-9]|2[0-3]):[0-5][0-9]))?$",
+      description: "An RFC 3339 full date, or a date-time with seconds and an offset."
+    },
+    source: {
+      pattern: "^\\S(?:.*\\S)?$",
+      anyOf: [
+        {
+          required: [
+            "path"
+          ]
+        },
+        {
+          required: [
+            "url"
+          ]
+        }
+      ],
+      description: "A source entry. A string is one id, path or URL on one line with no surrounding space. An object carries `path` or `url`."
+    }
+  }
+};
+
 // src/meta/core/schema-registry.ts
 var BUILTINS = /* @__PURE__ */ new Map([
   ["google:okf:0.1", __default],
@@ -8392,7 +8672,13 @@ var BUILTINS = /* @__PURE__ */ new Map([
   ["manni:graph-strict:1.0.0", __default44],
   ["manni:citations-strict:1.0.0", __default45],
   ["tgdp:templates:1.1", __default46],
-  ["tgdp:templates-strict:1.1", __default47]
+  ["tgdp:templates-strict:1.1", __default47],
+  ["manni:stewardship:1.1.0", __default48],
+  ["manni:stewardship-strict:1.1.0", __default49]
+]);
+var ANNOTATION_ONLY_PREDECESSORS = /* @__PURE__ */ new Map([
+  ["manni:stewardship:1.1.0", "manni:stewardship:1.0.0"],
+  ["manni:stewardship-strict:1.1.0", "manni:stewardship-strict:1.0.0"]
 ]);
 function assertPublishableBuiltinId(id) {
   const first = id.split(":")[0];
@@ -8485,7 +8771,9 @@ var PUBLISHED_PATHS = [
   ["graph-strict/1.0.0.json", "manni:graph-strict:1.0.0"],
   ["citations-strict/1.0.0.json", "manni:citations-strict:1.0.0"],
   ["tgdp/1.1.json", "tgdp:templates:1.1"],
-  ["tgdp-strict/1.1.json", "tgdp:templates-strict:1.1"]
+  ["tgdp-strict/1.1.json", "tgdp:templates-strict:1.1"],
+  ["stewardship/1.1.0.json", "manni:stewardship:1.1.0"],
+  ["stewardship-strict/1.1.0.json", "manni:stewardship-strict:1.1.0"]
 ];
 var PUBLISHED_ALIAS = new Map(
   PUBLISHED_PATHS.map(([path, id]) => [`${PUBLISHED_BASE}${path}`, id])
@@ -8578,8 +8866,8 @@ var SCHEMA_KEYS = [
   "multipleOf"
 ];
 var RETRY_DELAY_MS = 500;
-var wait2 = (ms) => new Promise((resolve25) => {
-  setTimeout(resolve25, ms);
+var wait2 = (ms) => new Promise((resolve26) => {
+  setTimeout(resolve26, ms);
 });
 var RetryableFetchError = class extends DocmetaError {
 };
@@ -8841,7 +9129,7 @@ var DEFAULT_SCHEMAS = Object.freeze([
   "manni:core:1.0.0",
   "manni:audience:1.0.0",
   "manni:structure:1.0.0",
-  "manni:stewardship:1.0.0",
+  "manni:stewardship:1.1.0",
   "manni:lifecycle:1.0.0",
   "manni:ai-context:1.0.0",
   "manni:evals:1.0.0",
@@ -8849,7 +9137,14 @@ var DEFAULT_SCHEMAS = Object.freeze([
   "manni:citations:1.0.0"
 ]);
 var FILE_SCHEMA_KEY = "$schema";
-var DEFAULT_SCHEMA_SET = new Set(DEFAULT_SCHEMAS);
+function vocabularyOf(id) {
+  const parts = id.split(":");
+  if (parts.length !== 3) return void 0;
+  return `${parts[0] ?? ""}:${parts[1] ?? ""}`;
+}
+var DEFAULT_VOCABULARIES = new Set(
+  DEFAULT_SCHEMAS.map(vocabularyOf).filter((v) => v !== void 0)
+);
 function schemaEntryRef(entry) {
   return typeof entry === "string" ? entry : entry.ref;
 }
@@ -8960,14 +9255,34 @@ function withStrict(refs, registered2) {
     out.push(ref);
     const strictId = strictIdOf(ref);
     if (strictId === void 0) continue;
-    if (DEFAULT_SCHEMA_SET.has(ref) && isBuiltinId(strictId)) out.push(strictId);
+    const vocabulary = vocabularyOf(ref);
+    const isDefault = vocabulary !== void 0 && DEFAULT_VOCABULARIES.has(vocabulary);
+    if (isDefault && isBuiltinId(ref) && isBuiltinId(strictId)) out.push(strictId);
     else if (registered2?.has(ref) === true && registered2.has(strictId)) out.push(strictId);
   }
   return dedupe(out);
 }
+function withoutReplacedVersions(set, listed) {
+  const explicit = /* @__PURE__ */ new Set();
+  for (const ref of listed) {
+    if (!isBuiltinId(ref)) continue;
+    explicit.add(ref);
+    const strictId = strictIdOf(ref);
+    if (strictId !== void 0) explicit.add(strictId);
+  }
+  const pinned = new Set(
+    [...explicit].map(vocabularyOf).filter((v) => v !== void 0)
+  );
+  return set.filter((ref) => {
+    if (explicit.has(ref) || !isBuiltinId(ref)) return true;
+    const vocabulary = vocabularyOf(ref);
+    return vocabulary === void 0 || !pinned.has(vocabulary);
+  });
+}
 function joined(listed, defaults, strict, registered2) {
   const set = dedupe([...defaults ? DEFAULT_SCHEMAS : [], ...listed]);
-  return strict ? withStrict(set, registered2) : set;
+  const paired = strict ? withStrict(set, registered2) : set;
+  return defaults ? withoutReplacedVersions(paired, listed) : paired;
 }
 function isDefaultSetOnly(resolved) {
   if (!resolved.defaults) return false;
@@ -9146,12 +9461,12 @@ function isPlainObject(v) {
 }
 
 // src/meta/core/config.ts
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 import { parse as parseYaml2 } from "yaml";
 
 // src/shared/config-file.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname3, join as join4, relative as relative3, resolve as resolve6 } from "node:path";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { basename as basename2, dirname as dirname3, join as join4, relative as relative3, resolve as resolve7 } from "node:path";
 import { parse as parseYaml } from "yaml";
 
 // src/shared/encryption.ts
@@ -9280,23 +9595,230 @@ function keyedPin(text2, key) {
   return `${KEYED_PIN_PREFIX}${mac}`;
 }
 
-// src/shared/git-root.ts
-import { existsSync } from "node:fs";
-import { dirname as dirname2, join as join3, resolve as resolve4 } from "node:path";
-function findGitRoot(cwd) {
-  let dir = resolve4(cwd);
-  for (; ; ) {
-    if (existsSync(join3(dir, ".git"))) return dir;
-    const parent = dirname2(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-function searchPath(cwd) {
-  const start = resolve4(cwd);
-  const root = findGitRoot(start);
-  if (root === null) return [start];
-  const chain = [];
+// src/shared/providers.ts
+import { resolve as resolve4 } from "node:path";
+import {
+  DEFAULT_MODELS,
+  DEFAULT_OPENAI_BASE_URL,
+  InferenceError,
+  resolveProviderIdentityAsync
+} from "@hawkeyexl/inference";
+var DEFAULT_PROVIDER = "auto";
+var PROVIDERS = /* @__PURE__ */ new Set([
+  ...Object.keys(DEFAULT_MODELS),
+  DEFAULT_PROVIDER
+]);
+var NAMEABLE_PROVIDERS = Object.keys(DEFAULT_MODELS).filter(
+  (name2) => name2 !== "mock"
+);
+function assertKnownProvider(name2, toError) {
+  if (PROVIDERS.has(name2)) return;
+  throw toError(
+    `Unknown provider "${name2}". Available: ${[...NAMEABLE_PROVIDERS, DEFAULT_PROVIDER].join(", ")}.`
+  );
+}
+function assertModelHasProvider(name2, model, configKey, toError) {
+  if (name2 !== DEFAULT_PROVIDER || model == null) return;
+  throw toError(
+    `Model "${model}" was given without a provider: a model name does not say which provider owns it. Set --provider or ${configKey} to one of ${NAMEABLE_PROVIDERS.join(", ")}, or drop the model to take the detected provider's default.`
+  );
+}
+var PROVIDERS_KEY = "providers";
+var CONNECTION_KEYS = {
+  anthropic: ["apiKeyEnv"],
+  openai: ["baseUrl", "apiKeyEnv"],
+  "claude-cli": ["command"],
+  "llama-cpp": ["modelsDir", "thoughtTokens"]
+};
+var CONNECTION_NAMES = Object.keys(CONNECTION_KEYS);
+var TOP_LEVEL_KEYS = ["provider", "model", ...CONNECTION_NAMES];
+function isMapping2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rejectUnknown(raw, allowed, label, source, toError) {
+  for (const key of Object.keys(raw)) {
+    if (!allowed.includes(key)) {
+      throw toError(
+        `${source}: "${label}" has unknown key "${key}". Supported keys: ${allowed.join(", ")}.`
+      );
+    }
+  }
+}
+function parseProviders(value, source, dir, toError) {
+  if (value == null) return {};
+  if (!isMapping2(value)) {
+    throw toError(`${source}: "${PROVIDERS_KEY}" must be a mapping.`);
+  }
+  rejectUnknown(value, TOP_LEVEL_KEYS, PROVIDERS_KEY, source, toError);
+  const string = (raw, key, label) => {
+    const v = raw[key];
+    if (v === void 0) return void 0;
+    if (typeof v !== "string") {
+      throw toError(`${source}: "${label}" must be a string.`);
+    }
+    return v;
+  };
+  const parsed2 = {};
+  const provider = string(value, "provider", `${PROVIDERS_KEY}.provider`);
+  if (provider !== void 0) {
+    assertKnownProvider(provider, (message) => toError(`${source}: ${message}`));
+    parsed2.provider = provider;
+  }
+  const model = string(value, "model", `${PROVIDERS_KEY}.model`);
+  if (model !== void 0) {
+    if (provider === void 0 || provider === DEFAULT_PROVIDER) {
+      throw toError(
+        `${source}: "${PROVIDERS_KEY}.model" was given without a provider: a model name does not say which provider owns it. Set ${PROVIDERS_KEY}.provider to one of ${NAMEABLE_PROVIDERS.join(", ")}, or drop the model to take the detected provider's default.`
+      );
+    }
+    parsed2.model = model;
+  }
+  for (const name2 of CONNECTION_NAMES) {
+    const section = value[name2];
+    if (section == null) continue;
+    const label = `${PROVIDERS_KEY}.${name2}`;
+    if (!isMapping2(section)) {
+      throw toError(`${source}: "${label}" must be a mapping.`);
+    }
+    rejectUnknown(section, CONNECTION_KEYS[name2], label, source, toError);
+    const field = (key) => string(section, key, `${label}.${key}`);
+    switch (name2) {
+      case "anthropic": {
+        const apiKeyEnv = field("apiKeyEnv");
+        parsed2.anthropic = apiKeyEnv === void 0 ? {} : { apiKeyEnv };
+        break;
+      }
+      case "openai": {
+        const baseUrl = field("baseUrl");
+        const apiKeyEnv = field("apiKeyEnv");
+        parsed2.openai = {
+          ...baseUrl !== void 0 ? { baseUrl } : {},
+          ...apiKeyEnv !== void 0 ? { apiKeyEnv } : {}
+        };
+        break;
+      }
+      case "claude-cli": {
+        const command = field("command");
+        parsed2["claude-cli"] = command === void 0 ? {} : { command };
+        break;
+      }
+      case "llama-cpp": {
+        const modelsDir = field("modelsDir");
+        const thoughtTokens = section["thoughtTokens"];
+        if (thoughtTokens !== void 0 && (typeof thoughtTokens !== "number" || !Number.isInteger(thoughtTokens) || thoughtTokens < 0)) {
+          throw toError(
+            `${source}: "${label}.thoughtTokens" must be a whole number of 0 or more, got ${JSON.stringify(thoughtTokens)}.`
+          );
+        }
+        parsed2["llama-cpp"] = {
+          ...modelsDir !== void 0 ? { modelsDir: resolve4(dir, modelsDir) } : {},
+          ...thoughtTokens !== void 0 ? { thoughtTokens } : {}
+        };
+        break;
+      }
+    }
+  }
+  return parsed2;
+}
+var LOCAL_PROVIDER = "llama-cpp";
+var LOCAL_FLAG_HELP = "run inference on this machine (llama-cpp); overrides any configured or eval-level provider";
+var LOCAL_COMPATIBLE = /* @__PURE__ */ new Set([LOCAL_PROVIDER, DEFAULT_PROVIDER, "mock"]);
+function assertLocalFlag(flag, toError) {
+  if (flag.local !== true || flag.provider === void 0) return;
+  assertKnownProvider(flag.provider, toError);
+  if (LOCAL_COMPATIBLE.has(flag.provider)) return;
+  throw toError(
+    `--local and --provider ${flag.provider} contradict each other: --local runs inference on this machine with ${LOCAL_PROVIDER}. Drop one of them.`
+  );
+}
+function selectProvider(flag, levels) {
+  if (flag.local === true) return selectLocal(flag, levels);
+  const provider = flag.provider ?? levels.find((level) => level.provider !== void 0)?.provider ?? DEFAULT_PROVIDER;
+  const model = flag.model ?? levels.find(
+    (level) => level.model !== void 0 && (level.provider === void 0 || level.provider === provider)
+  )?.model;
+  return { provider, model };
+}
+function selectLocal(flag, levels) {
+  const provider = flag.provider === "mock" ? "mock" : LOCAL_PROVIDER;
+  const model = flag.model ?? levels.find((level) => level.model !== void 0 && level.provider === provider)?.model;
+  const chosen = flag.provider === void 0 ? levels.find((level) => level.provider !== void 0) : void 0;
+  const replaced = chosen?.provider !== void 0 && chosen.origin !== void 0 && chosen.provider !== provider && chosen.provider !== DEFAULT_PROVIDER ? { provider: chosen.provider, source: chosen.origin } : void 0;
+  return replaced === void 0 ? { provider, model } : { provider, model, replaced };
+}
+function localNotice(selection) {
+  const { replaced } = selection;
+  if (replaced === void 0) return void 0;
+  return `--local: using ${LOCAL_PROVIDER} instead of "${replaced.provider}" from ${replaced.source}.`;
+}
+function providerSpecFor(connections, selection) {
+  const { provider, model } = selection;
+  const local = connections["llama-cpp"] ?? {};
+  const llamaCpp = {
+    thoughtTokens: local.thoughtTokens ?? 0,
+    ...local.modelsDir !== void 0 ? { modelsDirectory: local.modelsDir } : {}
+  };
+  switch (provider) {
+    case "anthropic":
+      return {
+        provider,
+        model,
+        apiKeyEnv: connections.anthropic?.apiKeyEnv ?? "ANTHROPIC_API_KEY"
+      };
+    case "openai":
+      return {
+        provider,
+        model,
+        apiKeyEnv: connections.openai?.apiKeyEnv ?? "OPENAI_API_KEY",
+        baseUrl: connections.openai?.baseUrl ?? DEFAULT_OPENAI_BASE_URL
+      };
+    case "claude-cli":
+      return { provider, model, command: connections["claude-cli"]?.command ?? "claude" };
+    case "llama-cpp":
+      return { provider, model, llamaCpp };
+    case "mock":
+      return { provider, model };
+    case "auto": {
+      const baseUrl = connections.openai?.baseUrl;
+      const command = connections["claude-cli"]?.command;
+      const configuredLocal = local.thoughtTokens !== void 0 || local.modelsDir !== void 0;
+      return {
+        provider,
+        model,
+        ...baseUrl !== void 0 ? { baseUrl } : {},
+        ...command !== void 0 ? { command } : {},
+        ...configuredLocal ? { llamaCpp } : {}
+      };
+    }
+  }
+}
+async function resolveIdentity(spec, toError) {
+  try {
+    return await resolveProviderIdentityAsync(spec);
+  } catch (err) {
+    throw toError(
+      err instanceof InferenceError ? err.message : `Could not resolve provider "${String(spec.provider)}": ${errorMessage(err)}`
+    );
+  }
+}
+
+// src/shared/git-root.ts
+import { existsSync } from "node:fs";
+import { dirname as dirname2, join as join3, resolve as resolve5 } from "node:path";
+function findGitRoot(cwd) {
+  let dir = resolve5(cwd);
+  for (; ; ) {
+    if (existsSync(join3(dir, ".git"))) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function searchPath(cwd) {
+  const start = resolve5(cwd);
+  const root = findGitRoot(start);
+  if (root === null) return [start];
+  const chain = [];
   let dir = start;
   for (; ; ) {
     chain.push(dir);
@@ -9308,11 +9830,11 @@ function searchPath(cwd) {
 }
 
 // src/shared/tools.ts
-import { isAbsolute as isAbsolute3, resolve as resolve5 } from "node:path";
+import { isAbsolute as isAbsolute3, resolve as resolve6 } from "node:path";
 var TOOL_KEYS = ["vale", "dita-ot"];
 var VALE_KEYS = ["config"];
 var DITA_OT_KEYS = ["home"];
-function isMapping2(value) {
+function isMapping3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function rejectUnknownKeys2(raw, allowed, where, source, toError) {
@@ -9326,7 +9848,7 @@ function rejectUnknownKeys2(raw, allowed, where, source, toError) {
 }
 function parseTools(raw, source, toError) {
   if (raw === null || raw === void 0) return {};
-  if (!isMapping2(raw)) {
+  if (!isMapping3(raw)) {
     throw toError(`${source}: "tools" must be a mapping.`);
   }
   rejectUnknownKeys2(raw, TOOL_KEYS, "tools", source, toError);
@@ -9340,7 +9862,7 @@ function parseTools(raw, source, toError) {
   return tools;
 }
 function parseVale(raw, source, toError) {
-  if (!isMapping2(raw)) {
+  if (!isMapping3(raw)) {
     throw toError(`${source}: tools.vale must be a mapping.`);
   }
   rejectUnknownKeys2(raw, VALE_KEYS, "tools.vale", source, toError);
@@ -9355,7 +9877,7 @@ function parseVale(raw, source, toError) {
   return vale;
 }
 function parseDitaOt(raw, source, toError) {
-  if (!isMapping2(raw)) {
+  if (!isMapping3(raw)) {
     throw toError(`${source}: tools.dita-ot must be a mapping.`);
   }
   rejectUnknownKeys2(raw, DITA_OT_KEYS, "tools.dita-ot", source, toError);
@@ -9372,12 +9894,12 @@ function parseDitaOt(raw, source, toError) {
 function valeConfigPath(tools, configDir) {
   const config = tools.vale?.config;
   if (config === void 0) return void 0;
-  return isAbsolute3(config) ? config : resolve5(configDir, config);
+  return isAbsolute3(config) ? config : resolve6(configDir, config);
 }
 function ditaOtHome(tools, configDir) {
   const home = tools["dita-ot"]?.home;
   if (home === void 0) return void 0;
-  return isAbsolute3(home) ? home : resolve5(configDir, home);
+  return isAbsolute3(home) ? home : resolve6(configDir, home);
 }
 
 // src/shared/warn.ts
@@ -9392,22 +9914,24 @@ function notice(message) {
   process.stderr.write(`${programName()}: ${message}
 `);
 }
+var noticed = /* @__PURE__ */ new Set();
+function noticeOnce(message) {
+  if (noticed.has(message)) return;
+  noticed.add(message);
+  notice(message);
+}
 
 // src/shared/config-file.ts
 var FAMILY_CONFIG_NAMES = [
   "manni.config.yaml",
   "manni.config.yml"
 ];
-var MOOSE_CONFIG_NAMES = [
-  "moose.config.yaml",
-  "moose.config.yml"
-];
 var ENCRYPTION_KEY_FIELD = "encryptionKey";
 var ENCRYPTION_KEY_PREVIOUS_FIELD = "encryptionKeyPrevious";
-async function readDocument(path, source, toError) {
+function readDocument(path, source, toError) {
   let text2;
   try {
-    text2 = await readFile3(path, "utf8");
+    text2 = readFileSync2(path, "utf8");
   } catch {
     return null;
   }
@@ -9428,7 +9952,12 @@ function parseMapping(text2, source, toError) {
 }
 var COLLECTIONS_KEY = "collections";
 var TOOLS_KEY = "tools";
-var FAMILY_KEYS = [COLLECTIONS_KEY, TOOLS_KEY, ENCRYPTION_KEY_FIELD];
+var FAMILY_KEYS = [
+  COLLECTIONS_KEY,
+  TOOLS_KEY,
+  ENCRYPTION_KEY_FIELD,
+  PROVIDERS_KEY
+];
 function slice(document, opts) {
   const { doc } = document;
   if (doc !== null && Object.hasOwn(doc, opts.section)) {
@@ -9473,6 +10002,11 @@ function encryptionKeyOf(document, source, toError) {
   }
   return keys;
 }
+function providersOf(document, source, dir, toError) {
+  const { doc } = document;
+  if (doc === null || !Object.hasOwn(doc, PROVIDERS_KEY)) return {};
+  return { providers: parseProviders(doc[PROVIDERS_KEY], source, dir, toError) };
+}
 function tolerantKeysOf(document) {
   const key = document.doc?.[ENCRYPTION_KEY_FIELD];
   const previous = document.doc?.[ENCRYPTION_KEY_PREVIOUS_FIELD];
@@ -9484,42 +10018,33 @@ function tolerantKeysOf(document) {
 function relativeSource(cwd, path) {
   return relative3(cwd, path).replace(/\\/g, "/");
 }
-function mooseWarning(name2) {
-  return `"${name2}" is the pre-rename name of the family config file. Rename it to "${FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml"}".`;
-}
-var FAMILY_FILES = [
-  { names: FAMILY_CONFIG_NAMES, kind: "manni" },
-  { names: MOOSE_CONFIG_NAMES, kind: "moose" }
-];
-async function findConfigFile(cwd, opts) {
-  const start = resolve6(cwd);
+function findConfigFileSync(cwd, opts) {
+  const start = resolve7(cwd);
   for (const dir of searchPath(start)) {
-    for (const { names, kind } of FAMILY_FILES) {
-      for (const name2 of names) {
-        const path = join4(dir, name2);
-        const source = relativeSource(start, path);
-        const document = await readDocument(path, source, opts.toError);
-        if (document === null) continue;
-        const found = slice(document, opts);
-        if (found === null) continue;
-        if (kind === "moose") warn(mooseWarning(name2));
-        return {
-          path,
-          dir,
-          source,
-          text: document.text,
-          kind,
-          collections: collectionsOf(document, source, opts.toError),
-          tools: toolsOf(document, source, opts.toError),
-          ...encryptionKeyOf(document, source, opts.toError),
-          ...found
-        };
-      }
+    for (const name2 of FAMILY_CONFIG_NAMES) {
+      const path = join4(dir, name2);
+      const source = relativeSource(start, path);
+      const document = readDocument(path, source, opts.toError);
+      if (document === null) continue;
+      const found = slice(document, opts);
+      if (found === null) continue;
+      return {
+        path,
+        dir,
+        source,
+        text: document.text,
+        kind: "manni",
+        collections: collectionsOf(document, source, opts.toError),
+        tools: toolsOf(document, source, opts.toError),
+        ...encryptionKeyOf(document, source, opts.toError),
+        ...providersOf(document, source, dir, opts.toError),
+        ...found
+      };
     }
     for (const name2 of opts.legacyNames) {
       const path = join4(dir, name2);
       const source = relativeSource(start, path);
-      const document = await readDocument(path, source, opts.toError);
+      const document = readDocument(path, source, opts.toError);
       if (document === null) continue;
       warn(
         `"${name2}" is a deprecated config file name. Move its keys under \`${opts.section}:\` in "${FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml"}", and its paths, exclude and sidecars keys to a top-level collections: list, where sidecars becomes externalMetadata.`
@@ -9539,9 +10064,9 @@ async function findConfigFile(cwd, opts) {
   }
   return null;
 }
-async function readConfigFile(explicitPath, cwd, opts) {
-  const path = resolve6(cwd, explicitPath);
-  const document = await readDocument(path, explicitPath, opts.toError);
+function readConfigFileSync(explicitPath, cwd, opts) {
+  const path = resolve7(cwd, explicitPath);
+  const document = readDocument(path, explicitPath, opts.toError);
   if (document === null) {
     throw opts.toError(`Config file not found: "${explicitPath}".`);
   }
@@ -9560,44 +10085,58 @@ async function readConfigFile(explicitPath, cwd, opts) {
     // An unwrapped document carries no family key (else it would be wrapped),
     // so this only ever reads a family file's key.
     ...encryptionKeyOf(document, explicitPath, opts.toError),
+    ...providersOf(document, explicitPath, dirname3(path), opts.toError),
     ...found
   };
 }
-async function findFamilyConfigFile(cwd, toError) {
-  const start = resolve6(cwd);
+function findConfigFile(cwd, opts) {
+  return Promise.resolve().then(() => findConfigFileSync(cwd, opts));
+}
+function readConfigFile(explicitPath, cwd, opts) {
+  return Promise.resolve().then(
+    () => readConfigFileSync(explicitPath, cwd, opts)
+  );
+}
+function findFamilyConfigFile(cwd, toError) {
+  return Promise.resolve().then(() => findFamilyConfigFileSync(cwd, toError));
+}
+function findFamilyConfigFileSync(cwd, toError) {
+  const start = resolve7(cwd);
   for (const dir of searchPath(start)) {
-    for (const { names, kind } of FAMILY_FILES) {
-      for (const name2 of names) {
-        const path = join4(dir, name2);
-        const source = relativeSource(start, path);
-        const document = await readDocument(path, source, toError);
-        if (document === null) continue;
-        if (kind === "moose") warn(mooseWarning(name2));
-        return {
-          path,
-          dir,
-          source,
-          text: document.text,
-          value: null,
-          wrapped: true,
-          kind,
-          collections: collectionsOf(document, source, toError),
-          tools: toolsOf(document, source, toError),
-          ...tolerantKeysOf(document)
-        };
-      }
+    for (const name2 of FAMILY_CONFIG_NAMES) {
+      const path = join4(dir, name2);
+      const source = relativeSource(start, path);
+      const document = readDocument(path, source, toError);
+      if (document === null) continue;
+      return {
+        path,
+        dir,
+        source,
+        text: document.text,
+        value: null,
+        wrapped: true,
+        kind: "manni",
+        collections: collectionsOf(document, source, toError),
+        tools: toolsOf(document, source, toError),
+        ...tolerantKeysOf(document)
+      };
     }
   }
   return null;
 }
-async function readFamilyConfigFile(explicitPath, cwd, toError) {
-  const path = resolve6(cwd, explicitPath);
-  const document = await readDocument(path, explicitPath, toError);
+function readFamilyConfigFile(explicitPath, cwd, toError) {
+  return Promise.resolve().then(
+    () => readFamilyConfigFileSync(explicitPath, cwd, toError)
+  );
+}
+function readFamilyConfigFileSync(explicitPath, cwd, toError) {
+  const path = resolve7(cwd, explicitPath);
+  const document = readDocument(path, explicitPath, toError);
   if (document === null) {
     throw toError(`Config file not found: "${explicitPath}".`);
   }
   const { doc } = document;
-  const named = [...FAMILY_CONFIG_NAMES, ...MOOSE_CONFIG_NAMES].includes(basename2(path));
+  const named = FAMILY_CONFIG_NAMES.includes(basename2(path));
   const family = doc === null || named || FAMILY_KEYS.some((key) => Object.hasOwn(doc, key));
   return {
     path,
@@ -9614,8 +10153,8 @@ async function readFamilyConfigFile(explicitPath, cwd, toError) {
 }
 
 // src/meta/core/register.ts
-import { readFile as readFile4, readdir, stat as stat4 } from "node:fs/promises";
-import { join as join5, relative as relative4, resolve as resolve7, sep as sep2 } from "node:path";
+import { readFile as readFile3, readdir, stat as stat4 } from "node:fs/promises";
+import { join as join5, relative as relative4, resolve as resolve8, sep as sep2 } from "node:path";
 var RESERVED_VENDORS = [
   "manni",
   "check",
@@ -9671,7 +10210,7 @@ function shown(configDir, path) {
 async function loadRegisteredSchemas(register2, configDir) {
   const files = [];
   for (const [i, entry] of register2.entries()) {
-    const path = resolve7(configDir, entry);
+    const path = resolve8(configDir, entry);
     let entryStats;
     try {
       entryStats = await stat4(path);
@@ -9701,7 +10240,7 @@ async function loadRegisteredSchemas(register2, configDir) {
     const file = shown(configDir, path);
     let parsed2;
     try {
-      parsed2 = JSON.parse(stripBom2(await readFile4(path, "utf8")));
+      parsed2 = JSON.parse(stripBom2(await readFile3(path, "utf8")));
     } catch {
       throw new DocmetaError(`register: ${file} is not valid JSON.`);
     }
@@ -10470,12 +11009,20 @@ function parseFill(value, source) {
 function schemaTrustRoot(cwd, configDir) {
   const git2 = findGitRoot(cwd);
   if (git2 !== null) return { dir: git2, source: "git" };
-  if (configDir !== void 0) return { dir: resolve8(configDir), source: "config" };
-  return { dir: resolve8(cwd), source: "cwd" };
+  if (configDir !== void 0) return { dir: resolve9(configDir), source: "config" };
+  return { dir: resolve9(cwd), source: "cwd" };
 }
 async function loadConfig(explicitPath, cwd = process.cwd()) {
   const file = explicitPath ? await readConfigFile(explicitPath, cwd, CONFIG_FILE) : await findConfigFile(cwd, CONFIG_FILE);
   if (file === null) return null;
+  return loadedFrom(file);
+}
+async function loadMetaSection(explicitPath, cwd = process.cwd()) {
+  if (explicitPath === void 0) return loadConfig(void 0, cwd);
+  const file = await readConfigFile(explicitPath, cwd, CONFIG_FILE);
+  return file.wrapped ? loadedFrom(file) : null;
+}
+async function loadedFrom(file) {
   const section = file.wrapped ? META_SECTION : void 0;
   const config = parseConfigValue(file.value, file.source, section);
   assertOverrideCollections(config, file.collections, file.source, section);
@@ -10550,18 +11097,18 @@ import { isAbsolute as isAbsolute4 } from "node:path";
 // src/meta/core/baseline.ts
 import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
-import { readFile as readFile5 } from "node:fs/promises";
-import { relative as relative7, resolve as resolve11 } from "node:path";
+import { readFile as readFile4 } from "node:fs/promises";
+import { relative as relative7, resolve as resolve12 } from "node:path";
 
 // src/meta/core/load-files.ts
 import { stat as stat5 } from "node:fs/promises";
-import { extname, relative as relative6, resolve as resolve10 } from "node:path";
+import { extname, relative as relative6, resolve as resolve11 } from "node:path";
 import fg2 from "fast-glob";
 import picomatch3 from "picomatch";
 
 // src/meta/core/gitignore.ts
 import { spawn } from "node:child_process";
-import { dirname as dirname4, relative as relative5, resolve as resolve9, sep as sep3 } from "node:path";
+import { dirname as dirname4, relative as relative5, resolve as resolve10, sep as sep3 } from "node:path";
 var GITIGNORE_UNAVAILABLE = ".gitignore filtering was requested but git could not answer here (no repository, or no git on PATH); no files were skipped.";
 var unavailable = () => ({
   ignored: /* @__PURE__ */ new Set(),
@@ -10575,7 +11122,7 @@ async function gitIgnored(paths, cwd) {
   const byRoot = /* @__PURE__ */ new Map();
   let inSomeRepo = false;
   for (const spelled of paths) {
-    const abs = resolve9(cwd, spelled);
+    const abs = resolve10(cwd, spelled);
     const dir = dirname4(abs);
     let root = rootOf.get(dir);
     if (root === void 0) {
@@ -10693,7 +11240,7 @@ async function walkDirectory(cwd, abs, ignore, framed) {
   });
   const files = [];
   for (const file of found) {
-    const rel = toPosix(relative6(cwd, resolve10(root, file)));
+    const rel = toPosix(relative6(cwd, resolve11(root, file)));
     if (!ignoredByGlobs(rel, framed)) files.push(rel);
   }
   return files;
@@ -10724,7 +11271,7 @@ async function resolveTargetSet(opts) {
   for (const input of opts.inputs) {
     if (input === STDIN_TOKEN) continue;
     const posixInput = toPosix(input);
-    const abs = resolve10(cwd, posixInput);
+    const abs = resolve11(cwd, posixInput);
     const st = await statOrNull(abs);
     if (st?.isFile()) {
       named.add(toPosix(relative6(cwd, abs)));
@@ -10808,17 +11355,18 @@ var FINGERPRINT_RE = /^[0-9a-f]{16}$/;
 function canonicalFilePath(file, ctx) {
   if (!ctx) return file;
   const from = ctx.runBase ?? ctx.base;
-  return relative7(ctx.base, resolve11(from, file)).replace(/\\/g, "/");
+  return relative7(ctx.base, resolve12(from, file)).replace(/\\/g, "/");
 }
 function canonicalSchemaRef(ref, ctx) {
   if (!ctx) return ref;
   if (classifyRef(ref).kind !== "file") return ref;
-  const abs = resolve11(ctx.cwd, ref);
+  const abs = resolve12(ctx.cwd, ref);
   return relative7(ctx.base, abs).replace(/\\/g, "/");
 }
 function fingerprint(e, ctx) {
+  const ref = canonicalSchemaRef(e.schema, ctx);
   const parts = [
-    canonicalSchemaRef(e.schema, ctx),
+    ANNOTATION_ONLY_PREDECESSORS.get(ref) ?? ref,
     e.instancePath,
     e.keyword,
     e.subject ?? ""
@@ -10887,7 +11435,7 @@ function parseBaseline(text2, source) {
 async function readBaseline(absPath, source) {
   let text2;
   try {
-    text2 = await readFile5(absPath, "utf8");
+    text2 = await readFile4(absPath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw new DocmetaError(
@@ -10971,17 +11519,17 @@ function countFingerprints(baseline) {
 }
 function resolveBaselineRequest(opts, configured, configDir, cwd, defaults) {
   const named = (label) => ({
-    absPath: resolve11(cwd, label),
+    absPath: resolve12(cwd, label),
     label
   });
   const implied = () => {
     const base = configDir ?? cwd;
     if (configured !== void 0) {
-      return { absPath: resolve11(base, configured), label: configured };
+      return { absPath: resolve12(base, configured), label: configured };
     }
-    const current = resolve11(base, defaults.current);
+    const current = resolve12(base, defaults.current);
     if (defaults.legacy !== void 0) {
-      const legacy = resolve11(base, defaults.legacy);
+      const legacy = resolve12(base, defaults.legacy);
       if (!existsSync2(current) && existsSync2(legacy)) {
         warn(
           `"${defaults.legacy}" is the pre-rename baseline file name. Rename it to "${defaults.current}".`
@@ -11487,8 +12035,8 @@ async function readCapped(url, res, maxBytes) {
 }
 
 // src/meta/core/external-metadata.ts
-import { readFile as readFile7 } from "node:fs/promises";
-import { isAbsolute as isAbsolute5, relative as relative9, resolve as resolve13, sep as sep4 } from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import { isAbsolute as isAbsolute5, relative as relative9, resolve as resolve14, sep as sep4 } from "node:path";
 import {
   LineCounter as LineCounter3,
   isMap as isMap6,
@@ -11570,8 +12118,8 @@ function isMissing(error) {
 
 // src/shared/encryption-key.ts
 import { spawnSync } from "node:child_process";
-import { readFile as readFile6 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname6, join as join7, relative as relative8, resolve as resolve12 } from "node:path";
+import { readFile as readFile5 } from "node:fs/promises";
+import { basename as basename4, dirname as dirname6, join as join7, relative as relative8, resolve as resolve13 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { isMap as isMap5, parseDocument as parseDocument4, parse as parseYaml3, stringify as stringify2 } from "yaml";
 
@@ -11583,8 +12131,8 @@ var RENAME_ATTEMPTS2 = 3;
 function errorCode2(err) {
   return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
 }
-var wait3 = (ms) => new Promise((resolve25) => {
-  setTimeout(resolve25, ms);
+var wait3 = (ms) => new Promise((resolve26) => {
+  setTimeout(resolve26, ms);
 });
 async function writeTextAtomic(path, text2) {
   const tmp = join6(
@@ -11633,14 +12181,14 @@ function resolveEncryptionKey(opts) {
   return { key: void 0, source: "none" };
 }
 function relativeSource2(cwd, path) {
-  return relative8(resolve12(cwd), path).replace(/\\/g, "/");
+  return relative8(resolve13(cwd), path).replace(/\\/g, "/");
 }
 function errorCode3(err) {
   return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
 }
 async function readIfPresent(path) {
   try {
-    return await readFile6(path, "utf8");
+    return await readFile5(path, "utf8");
   } catch (err) {
     if (errorCode3(err) === "ENOENT") return null;
     throw err;
@@ -11656,8 +12204,8 @@ async function fileTarget(file, toError) {
   return { path: file.path, source: file.source, text: text2 ?? file.text };
 }
 async function defaultTarget(cwd) {
-  const root = findGitRoot(cwd) ?? resolve12(cwd);
-  for (const name2 of [...FAMILY_CONFIG_NAMES, ...MOOSE_CONFIG_NAMES]) {
+  const root = findGitRoot(cwd) ?? resolve13(cwd);
+  for (const name2 of FAMILY_CONFIG_NAMES) {
     const path2 = join7(root, name2);
     const text2 = await readIfPresent(path2);
     if (text2 !== null) return { path: path2, source: relativeSource2(cwd, path2), text: text2 };
@@ -11679,20 +12227,20 @@ function withKey(text2, key, previous, source, toError) {
   if (previous === null) doc.delete(ENCRYPTION_KEY_PREVIOUS_FIELD);
   return doc.toString();
 }
-function isMapping3(value) {
+function isMapping4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function verify4(before, after, key, previous, source, toError) {
   const old = before === null ? null : parseYaml3(before);
   const expected = Object.fromEntries(
     Object.entries({
-      ...isMapping3(old) ? old : {},
+      ...isMapping4(old) ? old : {},
       [ENCRYPTION_KEY_FIELD]: key,
       ...typeof previous === "string" ? { [ENCRYPTION_KEY_PREVIOUS_FIELD]: previous } : {}
     }).filter(([name2]) => previous !== null || name2 !== ENCRYPTION_KEY_PREVIOUS_FIELD)
   );
   const reread = parseYaml3(after);
-  if (!isMapping3(reread) || !isDeepStrictEqual(reread, expected)) {
+  if (!isMapping4(reread) || !isDeepStrictEqual(reread, expected)) {
     throw toError(
       `Could not write ${ENCRYPTION_KEY_FIELD} to ${source}; add the key by hand.`
     );
@@ -11992,7 +12540,7 @@ async function loadExternalMetadata(collections, opts) {
       });
       parsed2 = parseManifest(manifest, collection, text2, file, opts.configDir, join12, ownership(declared, manifest));
     } else {
-      const abs = isAbsolute5(manifest.file) ? manifest.file : resolve13(opts.configDir, manifest.file);
+      const abs = isAbsolute5(manifest.file) ? manifest.file : resolve14(opts.configDir, manifest.file);
       const label = reportedPath(abs, opts.base);
       file = label;
       parsed2 = await parsedManifests.parse(
@@ -12154,7 +12702,7 @@ function outsideRefusal(manifest, collection, pageRel) {
 }
 async function readPageManifest(abs, file) {
   try {
-    return await readFile7(abs, "utf8");
+    return await readFile6(abs, "utf8");
   } catch (err) {
     if (isMissing(err)) return "";
     throw unreadable(file, err);
@@ -12162,7 +12710,7 @@ async function readPageManifest(abs, file) {
 }
 async function readManifest(abs, file) {
   try {
-    return await readFile7(abs, "utf8");
+    return await readFile6(abs, "utf8");
   } catch (err) {
     throw unreadable(file, err);
   }
@@ -12211,7 +12759,7 @@ function parseManifest(manifest, collection, text2, file, configDir, join12, own
         `Manifest ${where}: "${spelled}" must be a mapping of owned keys to values.`
       );
     }
-    const indexKey = join12 === PATH_JOIN2 ? resolve13(configDir, spelled) : spelled;
+    const indexKey = join12 === PATH_JOIN2 ? resolve14(configDir, spelled) : spelled;
     const values = target.get(indexKey) ?? /* @__PURE__ */ new Map();
     for (const kv of pair.value.items) {
       const key = isScalar5(kv.key) ? String(kv.key.value) : String(kv.key);
@@ -12299,10 +12847,10 @@ function mergeWith(label, extracted, index, memberOf2, base, encryptionKey, mark
   const entryOf = /* @__PURE__ */ new Map();
   const joins = [];
   if (label !== STDIN_LABEL) {
-    const byPath = index.byPath.get(resolve13(base, label));
+    const byPath = index.byPath.get(resolve14(base, label));
     if (byPath) {
       sources.push(byPath);
-      const abs = resolve13(base, label);
+      const abs = resolve14(base, label);
       entryOf.set(byPath, (sv) => index.entries.find((e) => e.file === sv.file && e.abs === abs));
     }
   }
@@ -12427,7 +12975,7 @@ function externalMetadataPointer(key) {
 }
 function orphanEntries(index, loaded, base, collections) {
   if (!index) return [];
-  const have = new Set(loaded.map((l) => resolve13(base, l)));
+  const have = new Set(loaded.map((l) => resolve14(base, l)));
   const orphans = index.entries.filter(
     (e) => inCollections(e, collections) && e.join === PATH_JOIN2 && e.abs !== void 0 && !have.has(e.abs)
   );
@@ -12491,77 +13039,340 @@ function pageOwners(index, key, memberOf2, marked) {
   ];
 }
 
-// src/meta/core/location.ts
-var LOCATION_KEYWORD = "x-manni-location";
-var LOCATION_EXTERNAL_SCHEMA = "location:external";
-var LOCATION_PAGE_SCHEMA = "location:page";
-var LOCATION_FINDING_KEYWORD = "location";
-function isFieldLocation(value) {
-  return value === "page" || value === "external";
-}
+// src/meta/core/collections.ts
+import { isAbsolute as isAbsolute6, relative as relative10, resolve as resolvePath2, sep as sep5 } from "node:path";
 
-// src/meta/core/validator.ts
-import * as AjvDraft07Ns from "ajv";
-import * as Ajv2019Ns from "ajv/dist/2019.js";
-import * as Ajv2020Ns from "ajv/dist/2020.js";
-import * as AjvDraft04Ns from "ajv-draft-04";
-import * as addFormatsNs from "ajv-formats";
-import { createRequire } from "node:module";
-var draft06MetaSchema = createRequire(import.meta.url)(
-  "ajv/dist/refs/json-schema-draft-06.json"
-);
-var AjvDraft07 = AjvDraft07Ns.default;
-var Ajv2019 = Ajv2019Ns.default;
-var Ajv2020 = Ajv2020Ns.default;
-var AjvDraft04 = AjvDraft04Ns.default;
-var addFormats = addFormatsNs.default;
-function dialectOf(schema) {
-  const meta = typeof schema.$schema === "string" ? schema.$schema : "";
-  if (meta.includes("2019-09")) return "2019";
-  if (meta.includes("draft-07") || meta.includes("draft/7") || meta.includes("draft-06") || meta.includes("draft/6")) {
-    return "draft7";
+// src/meta/core/projection.ts
+var SYSTEM_COLUMNS = ["_path", "_format", "_present", "_data"];
+var RESERVED = new Set(SYSTEM_COLUMNS);
+function quoteIdent(name2) {
+  return `"${name2.replaceAll('"', '""')}"`;
+}
+function bindValue(value) {
+  if (value === void 0 || value === null) return null;
+  switch (typeof value) {
+    case "boolean":
+      return value ? 1 : 0;
+    case "number":
+      return Number.isFinite(value) ? value : null;
+    case "bigint":
+    case "string":
+      return value;
+    default:
+      return JSON.stringify(value);
   }
-  if (meta.includes("draft-04") || meta.includes("draft/4")) return "draft4";
-  return "2020";
 }
-function buildAjv(dialect, coerceTypes = false) {
-  const opts = { allErrors: true, strict: false, coerceTypes };
-  const ajv = dialect === "2019" ? new Ajv2019(opts) : dialect === "draft7" ? new AjvDraft07(opts) : dialect === "draft4" ? new AjvDraft04(opts) : new Ajv2020(opts);
-  addFormats(ajv);
-  if (dialect === "draft7") ajv.addMetaSchema(draft06MetaSchema);
-  registerEncryptKeyword(ajv);
-  registerLocationKeyword(ajv);
-  registerBuiltins(ajv, dialect);
-  return ajv;
+function 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();
 }
-var markRecorder;
-function registerEncryptKeyword(ajv) {
-  ajv.addKeyword({
-    keyword: ENCRYPT_KEYWORD,
-    metaSchema: { type: "boolean" },
-    errors: false,
-    validate: (schema, _data, _parent, cxt) => {
-      if (schema === true && markRecorder !== void 0) {
-        markRecorder.add(cxt?.instancePath ?? "");
-      }
-      return true;
+function 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 isMarkShapeError(err) {
-  return err instanceof Error && err.message.includes(`"${ENCRYPT_KEYWORD}"`);
+function registerLineFor(db, entries) {
+  const byLabel = new Map(entries.map((e) => [e.label, e.extracted]));
+  db.function("lineFor", { deterministic: true }, (path, key) => {
+    if (typeof path !== "string" || typeof key !== "string") return null;
+    return byLabel.get(path)?.lineFor(key) ?? null;
+  });
 }
-var locationRecorder;
-function topLevelKey(instancePath) {
-  if (!instancePath.startsWith("/") || instancePath.indexOf("/", 1) !== -1) {
-    return void 0;
+function assertSingleStatement(sql) {
+  const cut = topLevelSemicolon(sql);
+  if (cut === -1) return;
+  if (!isTrivia(sql.slice(cut + 1))) {
+    throw new DocmetaError(
+      "Run a single SQL statement per query; text after the first `;` would be silently ignored."
+    );
   }
-  return instancePath.slice(1).replace(/~1/g, "/").replace(/~0/g, "~");
 }
-function registerLocationKeyword(ajv) {
-  ajv.addKeyword({
-    keyword: LOCATION_KEYWORD,
-    metaSchema: { type: "string", enum: ["page", "external"] },
+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 tokens2 = [];
+  const seen = /* @__PURE__ */ new Set();
+  const prefixOf = /* @__PURE__ */ new Map();
+  let i = 0;
+  while (i < sql.length) {
+    const ch = sql[i];
+    if (startsStringOrIdent(sql, i)) {
+      i = skipStringOrIdent(sql, i);
+    } else if (startsComment(sql, i)) {
+      i = skipComment(sql, i);
+    } else if (ch === "$" || ch === ":" || ch === "@") {
+      if (ch === ":" && sql[i + 1] === ":") {
+        i += 2;
+        continue;
+      }
+      const m = PARAM_NAME_HEAD.exec(sql.slice(i + 1));
+      if (!m) {
+        i++;
+        continue;
+      }
+      const token = ch + m[0];
+      const priorPrefix = prefixOf.get(m[0]);
+      if (priorPrefix !== void 0 && priorPrefix !== ch) {
+        throw new DocmetaError(
+          `The statement references both ${priorPrefix}${m[0]} and ${token} \u2014 one name under two prefixes, which the engine rejects as conflicting. Use one spelling throughout.`
+        );
+      }
+      prefixOf.set(m[0], ch);
+      if (!seen.has(token)) {
+        seen.add(token);
+        tokens2.push(token);
+      }
+      i += 1 + m[0].length;
+    } else {
+      i++;
+    }
+  }
+  return tokens2;
+}
+function stripLeadingTrivia(sql) {
+  let i = 0;
+  for (; ; ) {
+    while (i < sql.length && /\s/.test(sql[i] ?? "")) i++;
+    if (startsComment(sql, i)) {
+      i = skipComment(sql, i);
+      continue;
+    }
+    return sql.slice(i);
+  }
+}
+function isTrivia(text2) {
+  let i = 0;
+  while (i < text2.length) {
+    const ch = text2[i];
+    if (ch === void 0 || /\s/.test(ch) || ch === ";") {
+      i++;
+      continue;
+    }
+    if (startsComment(text2, i)) {
+      i = skipComment(text2, i);
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+var sqliteModule;
+function loadSqlite() {
+  sqliteModule ??= (async () => {
+    const original = process.emitWarning.bind(process);
+    const filtered = (warning, ...rest) => {
+      const text2 = typeof warning === "string" ? warning : warning.message;
+      if (text2.includes("SQLite is an experimental feature")) return;
+      Reflect.apply(original, process, [warning, ...rest]);
+    };
+    process.emitWarning = filtered;
+    try {
+      return await import("node:sqlite");
+    } finally {
+      process.emitWarning = original;
+    }
+  })();
+  return sqliteModule;
+}
+
+// src/meta/core/collections.ts
+function memberOf(collections, configDir, base, label) {
+  if (collections.length === 0) return [];
+  if (label === STDIN_LABEL) return [];
+  const rel = relative10(configDir, resolvePath2(base, label)).split(sep5).join("/");
+  if (isAbsolute6(rel)) return [];
+  return collections.filter((c) => isMember(c, rel)).map((c) => c.name);
+}
+function retainMembers(files, membersFor) {
+  return files.filter((label) => membersFor(label).length > 0);
+}
+function collectionNames(collections) {
+  return (collections ?? []).map((c) => c.name);
+}
+function collectCollections(entries, params) {
+  const declared = params.collections ?? [];
+  if (declared.length === 0) return [];
+  const base = params.base ?? ".";
+  const configDir = params.configDir ?? base;
+  const members = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const name2 of memberOf(declared, configDir, base, entry.label)) {
+      const list2 = members.get(name2);
+      if (list2) list2.push(entry.label);
+      else members.set(name2, [entry.label]);
+    }
+  }
+  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/location.ts
+var LOCATION_KEYWORD = "x-manni-location";
+var LOCATION_EXTERNAL_SCHEMA = "location:external";
+var LOCATION_PAGE_SCHEMA = "location:page";
+var LOCATION_FINDING_KEYWORD = "location";
+function isFieldLocation(value) {
+  return value === "page" || value === "external";
+}
+
+// src/meta/core/graph-output.ts
+var GRAPH_OUTPUT_KEYWORD = "x-manni-graph-output";
+
+// src/meta/core/validator.ts
+import * as AjvDraft07Ns from "ajv";
+import * as Ajv2019Ns from "ajv/dist/2019.js";
+import * as Ajv2020Ns from "ajv/dist/2020.js";
+import * as AjvDraft04Ns from "ajv-draft-04";
+import * as addFormatsNs from "ajv-formats";
+import { createRequire } from "node:module";
+var draft06MetaSchema = createRequire(import.meta.url)(
+  "ajv/dist/refs/json-schema-draft-06.json"
+);
+var AjvDraft07 = AjvDraft07Ns.default;
+var Ajv2019 = Ajv2019Ns.default;
+var Ajv2020 = Ajv2020Ns.default;
+var AjvDraft04 = AjvDraft04Ns.default;
+var addFormats = addFormatsNs.default;
+function dialectOf(schema) {
+  const meta = typeof schema.$schema === "string" ? schema.$schema : "";
+  if (meta.includes("2019-09")) return "2019";
+  if (meta.includes("draft-07") || meta.includes("draft/7") || meta.includes("draft-06") || meta.includes("draft/6")) {
+    return "draft7";
+  }
+  if (meta.includes("draft-04") || meta.includes("draft/4")) return "draft4";
+  return "2020";
+}
+function buildAjv(dialect, coerceTypes = false) {
+  const opts = { allErrors: true, strict: false, coerceTypes };
+  const ajv = dialect === "2019" ? new Ajv2019(opts) : dialect === "draft7" ? new AjvDraft07(opts) : dialect === "draft4" ? new AjvDraft04(opts) : new Ajv2020(opts);
+  addFormats(ajv);
+  if (dialect === "draft7") ajv.addMetaSchema(draft06MetaSchema);
+  registerEncryptKeyword(ajv);
+  registerLocationKeyword(ajv);
+  registerGraphOutputKeyword(ajv);
+  registerBuiltins(ajv, dialect);
+  return ajv;
+}
+var markRecorder;
+function registerEncryptKeyword(ajv) {
+  ajv.addKeyword({
+    keyword: ENCRYPT_KEYWORD,
+    metaSchema: { type: "boolean" },
+    errors: false,
+    validate: (schema, _data, _parent, cxt) => {
+      if (schema === true && markRecorder !== void 0) {
+        markRecorder.add(cxt?.instancePath ?? "");
+      }
+      return true;
+    }
+  });
+}
+function isMarkShapeError(err) {
+  return err instanceof Error && err.message.includes(`"${ENCRYPT_KEYWORD}"`);
+}
+var locationRecorder;
+function topLevelKey(instancePath) {
+  if (!instancePath.startsWith("/") || instancePath.indexOf("/", 1) !== -1) {
+    return void 0;
+  }
+  return instancePath.slice(1).replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function registerLocationKeyword(ajv) {
+  ajv.addKeyword({
+    keyword: LOCATION_KEYWORD,
+    metaSchema: { type: "string", enum: ["page", "external"] },
     errors: false,
     validate: (schema, _data, _parent, cxt) => {
       if (locationRecorder !== void 0 && isFieldLocation(schema)) {
@@ -12569,15 +13380,37 @@ function registerLocationKeyword(ajv) {
         if (key !== void 0) {
           const seen = locationRecorder.get(key);
           if (seen) seen.add(schema);
-          else locationRecorder.set(key, /* @__PURE__ */ new Set([schema]));
+          else locationRecorder.set(key, /* @__PURE__ */ new Set([schema]));
+        }
+      }
+      return true;
+    }
+  });
+}
+function isLocationShapeError(err) {
+  return err instanceof Error && err.message.includes(`"${LOCATION_KEYWORD}"`);
+}
+var graphOutputRecorder;
+function registerGraphOutputKeyword(ajv) {
+  ajv.addKeyword({
+    keyword: GRAPH_OUTPUT_KEYWORD,
+    metaSchema: { type: "boolean" },
+    errors: false,
+    validate: (schema, _data, _parent, cxt) => {
+      if (graphOutputRecorder !== void 0 && typeof schema === "boolean") {
+        const key = topLevelKey(cxt?.instancePath ?? "");
+        if (key !== void 0) {
+          const seen = graphOutputRecorder.get(key);
+          if (seen) seen.add(schema);
+          else graphOutputRecorder.set(key, /* @__PURE__ */ new Set([schema]));
         }
       }
       return true;
     }
   });
 }
-function isLocationShapeError(err) {
-  return err instanceof Error && err.message.includes(`"${LOCATION_KEYWORD}"`);
+function isGraphOutputShapeError(err) {
+  return err instanceof Error && err.message.includes(`"${GRAPH_OUTPUT_KEYWORD}"`);
 }
 function marksSchemaExternal(schema) {
   const properties = schema["properties"];
@@ -12589,7 +13422,7 @@ function marksSchemaExternal(schema) {
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function definiteLocationConflict(root) {
+function definiteMarkConflict(root, keyword, isMark) {
   const marks = /* @__PURE__ */ new Map();
   const localRef = (node, embedded) => {
     const ref = node["$ref"];
@@ -12617,8 +13450,8 @@ function definiteLocationConflict(root) {
     if (!isRecord2(node) || visited.has(node)) return;
     visited.add(node);
     const inner = isEmbedded(node, embedded);
-    const mark = node[LOCATION_KEYWORD];
-    if (isFieldLocation(mark)) {
+    const mark = node[keyword];
+    if (isMark(mark)) {
       const seen = marks.get(key);
       if (seen) seen.add(mark);
       else marks.set(key, /* @__PURE__ */ new Set([mark]));
@@ -12748,12 +13581,22 @@ var Validator = class {
         `${ref}: "${FILE_SCHEMA_KEY}" cannot be stored in external metadata.`
       );
     }
-    const contradicted = definiteLocationConflict(schema);
+    const contradicted = definiteMarkConflict(schema, LOCATION_KEYWORD, isFieldLocation);
     if (contradicted !== void 0) {
       throw new DocmetaError(
         `${ref}: "${LOCATION_KEYWORD}" says both "page" and "external" for "${contradicted}".`
       );
     }
+    const graphContradicted = definiteMarkConflict(
+      schema,
+      GRAPH_OUTPUT_KEYWORD,
+      (value) => typeof value === "boolean"
+    );
+    if (graphContradicted !== void 0) {
+      throw new DocmetaError(
+        `${ref}: "${GRAPH_OUTPUT_KEYWORD}" says both true and false for "${graphContradicted}".`
+      );
+    }
     try {
       const ajv = this.ajvFor(dialectOf(schema));
       const id = typeof schema["$id"] === "string" ? schema["$id"] : void 0;
@@ -12775,6 +13618,11 @@ var Validator = class {
           `${ref}: "${LOCATION_KEYWORD}" must be "page" or "external".`
         );
       }
+      if (isGraphOutputShapeError(err)) {
+        throw new DocmetaError(
+          `${ref}: "${GRAPH_OUTPUT_KEYWORD}" must be true or false.`
+        );
+      }
       throw new DocmetaError(
         `Schema "${ref}" failed to compile: ${errorMessage(err)}`
       );
@@ -12865,347 +13713,127 @@ var Validator = class {
     return claimed;
   }
   /**
-   * Validate `data` against every schema in `refs`. Returns all violations,
-   * each tagged with the schema that produced it and a source line via
-   * `lineFor`.
+   * Whether each top-level key of `data` belongs in a published graph under
+   * `refs`, as its `x-manni-graph-output` mark says. A key no schema marks has no
+   * entry, which the caller reads as `true`: absent means harvested.
    *
-   * `colFor` is optional and additive: this signature is public, so a fourth
-   * *required* parameter — or a widened third one — would be a consumer break.
-   * Callers with an extractor that supplies no column pass nothing and get the
-   * previous behavior exactly.
+   * A first pass with the recording keyword, as `locationPreferences` runs, so
+   * a mark counts exactly where validation would evaluate it, and a mark nested
+   * inside `graph` is ignored. Only present values are marked: Ajv applies a
+   * property's subschema to a property that exists. `$schema` is stripped
+   * first, as validation does.
+   *
+   * Refs are evaluated in order and a later ref's mark wins, so a house schema
+   * listed after a vocabulary refines it. A schema that says both on paths
+   * every document takes is refused when it compiles. A ref whose conditional
+   * branches say both `true` and `false` gives that key no preference: with
+   * `allErrors`, Ajv evaluates failing branches too, so neither value is that
+   * ref's answer and an earlier ref's stands.
    */
-  async validate(data, refs, lineFor, colFor, locate) {
+  async graphOutputPreferences(data, refs) {
     const { [FILE_SCHEMA_KEY]: _omit, ...subject } = data;
     void _omit;
-    const errors = [];
+    const preferences = /* @__PURE__ */ new Map();
     for (const ref of refs) {
       const fn = await this.compile(ref);
-      const ok = fn(subject);
-      if (ok) continue;
-      for (const e of fn.errors ?? []) {
-        errors.push(toFieldError(ref, e, lineFor, colFor, locate));
-      }
-    }
-    return errors;
-  }
-};
-function subjectOf(e) {
-  switch (e.keyword) {
-    case "required":
-      return e.params.missingProperty;
-    case "additionalProperties":
-      return e.params.additionalProperty;
-    case "format":
-      return e.params.format;
-    case "type":
-      return e.params.type;
-    default:
-      return void 0;
-  }
-}
-function toFieldError(schema, e, lineFor, colFor, locate) {
-  const defined = e;
-  const instancePath = e.instancePath;
-  const subject = subjectOf(defined);
-  let message = e.message ?? "is invalid";
-  let wantsColumn = true;
-  if (defined.keyword === "required") {
-    message = `must have required property '${defined.params.missingProperty}'`;
-    wantsColumn = false;
-  } else if (defined.keyword === "additionalProperties") {
-    message = `must NOT have additional property '${defined.params.additionalProperty}'`;
-    wantsColumn = false;
-  }
-  const located = defined.keyword === "additionalProperties" ? locate?.(
-    `${instancePath}/${escapePointerSegment(defined.params.additionalProperty)}`
-  ) ?? locate?.(instancePath) : locate?.(instancePath);
-  if (located) {
-    return {
-      schema,
-      instancePath,
-      message,
-      keyword: e.keyword,
-      ...subject != null ? { subject } : {},
-      file: located.file,
-      ...located.line != null ? { line: located.line } : {},
-      ...wantsColumn && located.col != null ? { col: located.col } : {}
-    };
-  }
-  const line = lineFor(instancePath);
-  const col = wantsColumn ? colFor?.(instancePath) : void 0;
-  return {
-    schema,
-    instancePath,
-    message,
-    keyword: e.keyword,
-    ...subject != null ? { subject } : {},
-    ...line != null ? { line } : {},
-    ...col != null ? { col } : {}
-  };
-}
-
-// src/meta/core/collections.ts
-import { isAbsolute as isAbsolute6, relative as relative10, resolve as resolvePath2, sep as sep5 } from "node:path";
-
-// src/meta/core/projection.ts
-var SYSTEM_COLUMNS = ["_path", "_format", "_present", "_data"];
-var RESERVED = new Set(SYSTEM_COLUMNS);
-function quoteIdent(name2) {
-  return `"${name2.replaceAll('"', '""')}"`;
-}
-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 tokens2 = [];
-  const seen = /* @__PURE__ */ new Set();
-  const prefixOf = /* @__PURE__ */ new Map();
-  let i = 0;
-  while (i < sql.length) {
-    const ch = sql[i];
-    if (startsStringOrIdent(sql, i)) {
-      i = skipStringOrIdent(sql, i);
-    } else if (startsComment(sql, i)) {
-      i = skipComment(sql, i);
-    } else if (ch === "$" || ch === ":" || ch === "@") {
-      if (ch === ":" && sql[i + 1] === ":") {
-        i += 2;
-        continue;
-      }
-      const m = PARAM_NAME_HEAD.exec(sql.slice(i + 1));
-      if (!m) {
-        i++;
-        continue;
-      }
-      const token = ch + m[0];
-      const priorPrefix = prefixOf.get(m[0]);
-      if (priorPrefix !== void 0 && priorPrefix !== ch) {
-        throw new DocmetaError(
-          `The statement references both ${priorPrefix}${m[0]} and ${token} \u2014 one name under two prefixes, which the engine rejects as conflicting. Use one spelling throughout.`
-        );
+      const seen = /* @__PURE__ */ new Map();
+      graphOutputRecorder = seen;
+      try {
+        fn(subject);
+      } finally {
+        graphOutputRecorder = void 0;
       }
-      prefixOf.set(m[0], ch);
-      if (!seen.has(token)) {
-        seen.add(token);
-        tokens2.push(token);
+      for (const [key, values] of seen) {
+        const [value, ...others] = [...values];
+        if (value === void 0 || others.length > 0) continue;
+        preferences.set(key, value);
       }
-      i += 1 + m[0].length;
-    } else {
-      i++;
     }
+    return preferences;
   }
-  return tokens2;
-}
-function stripLeadingTrivia(sql) {
-  let i = 0;
-  for (; ; ) {
-    while (i < sql.length && /\s/.test(sql[i] ?? "")) i++;
-    if (startsComment(sql, i)) {
-      i = skipComment(sql, i);
-      continue;
+  /**
+   * Validate `data` against every schema in `refs`. Returns all violations,
+   * each tagged with the schema that produced it and a source line via
+   * `lineFor`.
+   *
+   * `colFor` is optional and additive: this signature is public, so a fourth
+   * *required* parameter — or a widened third one — would be a consumer break.
+   * Callers with an extractor that supplies no column pass nothing and get the
+   * previous behavior exactly.
+   */
+  async validate(data, refs, lineFor, colFor, locate) {
+    const { [FILE_SCHEMA_KEY]: _omit, ...subject } = data;
+    void _omit;
+    const errors = [];
+    for (const ref of refs) {
+      const fn = await this.compile(ref);
+      const ok = fn(subject);
+      if (ok) continue;
+      for (const e of fn.errors ?? []) {
+        errors.push(toFieldError(ref, e, lineFor, colFor, locate));
+      }
     }
-    return sql.slice(i);
+    return errors;
   }
-}
-function isTrivia(text2) {
-  let i = 0;
-  while (i < text2.length) {
-    const ch = text2[i];
-    if (ch === void 0 || /\s/.test(ch) || ch === ";") {
-      i++;
-      continue;
-    }
-    if (startsComment(text2, i)) {
-      i = skipComment(text2, i);
-      continue;
-    }
-    return false;
+};
+function subjectOf(e) {
+  switch (e.keyword) {
+    case "required":
+      return e.params.missingProperty;
+    case "additionalProperties":
+      return e.params.additionalProperty;
+    case "format":
+      return e.params.format;
+    case "type":
+      return e.params.type;
+    default:
+      return void 0;
   }
-  return true;
-}
-var sqliteModule;
-function loadSqlite() {
-  sqliteModule ??= (async () => {
-    const original = process.emitWarning.bind(process);
-    const filtered = (warning, ...rest) => {
-      const text2 = typeof warning === "string" ? warning : warning.message;
-      if (text2.includes("SQLite is an experimental feature")) return;
-      Reflect.apply(original, process, [warning, ...rest]);
-    };
-    process.emitWarning = filtered;
-    try {
-      return await import("node:sqlite");
-    } finally {
-      process.emitWarning = original;
-    }
-  })();
-  return sqliteModule;
-}
-
-// src/meta/core/collections.ts
-function memberOf(collections, configDir, base, label) {
-  if (collections.length === 0) return [];
-  if (label === STDIN_LABEL) return [];
-  const rel = relative10(configDir, resolvePath2(base, label)).split(sep5).join("/");
-  if (isAbsolute6(rel)) return [];
-  return collections.filter((c) => isMember(c, rel)).map((c) => c.name);
 }
-function retainMembers(files, membersFor) {
-  return files.filter((label) => membersFor(label).length > 0);
-}
-function collectionNames(collections) {
-  return (collections ?? []).map((c) => c.name);
-}
-function collectCollections(entries, params) {
-  const declared = params.collections ?? [];
-  if (declared.length === 0) return [];
-  const base = params.base ?? ".";
-  const configDir = params.configDir ?? base;
-  const members = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    for (const name2 of memberOf(declared, configDir, base, entry.label)) {
-      const list2 = members.get(name2);
-      if (list2) list2.push(entry.label);
-      else members.set(name2, [entry.label]);
-    }
+function toFieldError(schema, e, lineFor, colFor, locate) {
+  const defined = e;
+  const instancePath = e.instancePath;
+  const subject = subjectOf(defined);
+  let message = e.message ?? "is invalid";
+  let wantsColumn = true;
+  if (defined.keyword === "required") {
+    message = `must have required property '${defined.params.missingProperty}'`;
+    wantsColumn = false;
+  } else if (defined.keyword === "additionalProperties") {
+    message = `must NOT have additional property '${defined.params.additionalProperty}'`;
+    wantsColumn = false;
   }
-  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}`
-    );
+  const located = defined.keyword === "additionalProperties" ? locate?.(
+    `${instancePath}/${escapePointerSegment(defined.params.additionalProperty)}`
+  ) ?? locate?.(instancePath) : locate?.(instancePath);
+  if (located) {
+    return {
+      schema,
+      instancePath,
+      message,
+      keyword: e.keyword,
+      ...subject != null ? { subject } : {},
+      file: located.file,
+      ...located.line != null ? { line: located.line } : {},
+      ...wantsColumn && located.col != null ? { col: located.col } : {}
+    };
   }
+  const line = lineFor(instancePath);
+  const col = wantsColumn ? colFor?.(instancePath) : void 0;
+  return {
+    schema,
+    instancePath,
+    message,
+    keyword: e.keyword,
+    ...subject != null ? { subject } : {},
+    ...line != null ? { line } : {},
+    ...col != null ? { col } : {}
+  };
 }
 
 // src/meta/core/derive/cache.ts
 import { createHash as createHash4 } from "node:crypto";
-import { mkdirSync, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync as readFileSync3, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join as join8 } from "node:path";
 var REVIEW_CACHE_DIR = ".manni/meta/review-cache";
 var REVIEW_CACHE_VERSION = 1;
@@ -13225,7 +13853,7 @@ var ReviewCache = class {
     if (!this.enabled) return void 0;
     let raw;
     try {
-      raw = JSON.parse(readFileSync2(this.entryPath(key), "utf8"));
+      raw = JSON.parse(readFileSync3(this.entryPath(key), "utf8"));
     } catch {
       return void 0;
     }
@@ -13789,12 +14417,12 @@ function utcDate(iso) {
 }
 
 // src/meta/core/derive/index.ts
-import { dirname as dirname9, resolve as resolve15 } from "node:path";
+import { dirname as dirname9, resolve as resolve16 } from "node:path";
 
 // src/meta/core/derive/codeowners.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { readFile as readFile8 } from "node:fs/promises";
-import { dirname as dirname7, relative as relative11, resolve as resolve14, sep as sep6 } from "node:path";
+import { readFile as readFile7 } from "node:fs/promises";
+import { dirname as dirname7, relative as relative11, resolve as resolve15, sep as sep6 } from "node:path";
 import picomatch4 from "picomatch";
 var CODEOWNERS_LOCATIONS = [
   ".github/CODEOWNERS",
@@ -13804,11 +14432,11 @@ var CODEOWNERS_LOCATIONS = [
 ];
 function findCodeowners(root, explicit) {
   if (explicit !== void 0) {
-    const path = resolve14(root, explicit);
+    const path = resolve15(root, explicit);
     return existsSync3(path) ? path : null;
   }
   for (const loc of CODEOWNERS_LOCATIONS) {
-    const path = resolve14(root, ...loc.split("/"));
+    const path = resolve15(root, ...loc.split("/"));
     if (existsSync3(path)) return path;
   }
   return null;
@@ -13923,7 +14551,7 @@ function toGlobs(pattern) {
 var NOT_FOUND_REASON = `no CODEOWNERS file found (looked for ${CODEOWNERS_LOCATIONS.join(", ")})`;
 async function deriveFromCodeowners(inputs, opts) {
   const records = /* @__PURE__ */ new Map();
-  const explicitPath = opts.explicit === void 0 ? void 0 : resolve14(opts.configDir ?? process.cwd(), opts.explicit);
+  const explicitPath = opts.explicit === void 0 ? void 0 : resolve15(opts.configDir ?? process.cwd(), opts.explicit);
   if (explicitPath !== void 0 && !existsSync3(explicitPath)) {
     return {
       status: { available: false, reason: `CODEOWNERS not found at ${explicitPath}` },
@@ -13957,7 +14585,7 @@ async function deriveFromCodeowners(inputs, opts) {
     const key = `${path}\0${label}`;
     let file = parsed2.get(key);
     if (!file) {
-      file = readFile8(path, "utf8").then(
+      file = readFile7(path, "utf8").then(
         (text2) => parseCodeowners(text2, path, label)
       );
       parsed2.set(key, file);
@@ -15667,7 +16295,7 @@ async function deriveReviewsByRoot(inputs, git2, rootFor, ctx, requested) {
   if (byRoot.size === 0) {
     return unavailable3(requested, "no git repository contains the documents");
   }
-  const cacheDir = resolve15(ctx.configDir ?? ctx.cwd, REVIEW_CACHE_DIR);
+  const cacheDir = resolve16(ctx.configDir ?? ctx.cwd, REVIEW_CACHE_DIR);
   for (const [root, bucket] of byRoot) {
     const client = ctx.reviews ?? await createReviewClient(root, { cwd: ctx.cwd, cache: ctx.cache, cacheDir, requested });
     const identity = await client.detect();
@@ -15845,7 +16473,7 @@ async function deriveForTable(inputs, ctx, hint, fields) {
 }
 
 // src/meta/commands/validate.ts
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 
 // src/meta/core/page-marks.ts
 function pageMarks(opts) {
@@ -15881,17 +16509,20 @@ function lazyValidator(opts) {
   let built;
   return () => opts.validator instanceof Validator ? opts.validator : built ??= opts.validator();
 }
+function pageSchemaSet(opts, label, probe, memberOf2) {
+  return resolveSchemaSetWithSource({
+    filePath: label,
+    fileSchema: probe[FILE_SCHEMA_KEY],
+    ...opts.cliSchemas !== void 0 ? { cliSchemas: [...opts.cliSchemas] } : {},
+    config: opts.config,
+    memberOf: opts.memberOf?.(label) ?? memberOf2,
+    fileBase: opts.cwd,
+    trustRoot: opts.trustRoot
+  }).schemas;
+}
 function pageRefs(opts, label, probe, memberOf2) {
   try {
-    return resolveSchemaSetWithSource({
-      filePath: label,
-      fileSchema: probe[FILE_SCHEMA_KEY],
-      ...opts.cliSchemas !== void 0 ? { cliSchemas: [...opts.cliSchemas] } : {},
-      config: opts.config,
-      memberOf: opts.memberOf?.(label) ?? memberOf2,
-      fileBase: opts.cwd,
-      trustRoot: opts.trustRoot
-    }).schemas;
+    return pageSchemaSet(opts, label, probe, memberOf2);
   } catch (err) {
     if (err instanceof DocmetaError) return void 0;
     throw err;
@@ -15922,8 +16553,8 @@ async function configMarks(configPath, cwd) {
 }
 
 // src/meta/core/relocation.ts
-import { access, readFile as readFile9, stat as stat7, unlink } from "node:fs/promises";
-import { basename as basename5, extname as extname3, isAbsolute as isAbsolute8, join as join9, relative as relative13, resolve as resolve16, sep as sep8 } from "node:path";
+import { access, readFile as readFile8, stat as stat7, unlink } from "node:fs/promises";
+import { basename as basename5, extname as extname3, isAbsolute as isAbsolute8, join as join9, relative as relative13, resolve as resolve17, sep as sep8 } from "node:path";
 import picomatch6 from "picomatch";
 import {
   LineCounter as LineCounter5,
@@ -16327,7 +16958,7 @@ var Model = class {
       c.externalMetadata.forEach((m, index) => {
         const url = classifyRef(m.file).kind === "url";
         const perPage = !url && hasPagePlaceholder(m.file);
-        const absPath = url || perPage ? void 0 : isAbsolute8(m.file) ? m.file : resolve16(configDir, m.file);
+        const absPath = url || perPage ? void 0 : isAbsolute8(m.file) ? m.file : resolve17(configDir, m.file);
         this.manifests.push({
           collection: c.name,
           index,
@@ -16519,7 +17150,7 @@ var Model = class {
   /** A label relative to the config directory, posix; undefined outside it. */
   relative(label) {
     if (label === "<stdin>") return void 0;
-    const rel = toPosix3(relative13(this.configDir, resolve16(this.ctx.base, label)));
+    const rel = toPosix3(relative13(this.configDir, resolve17(this.ctx.base, label)));
     return isAbsolute8(rel) || rel.startsWith("../") ? void 0 : rel;
   }
 };
@@ -16534,11 +17165,11 @@ async function collectionPath(target, cwd, configDir) {
   const posix7 = target.replace(/\\/g, "/");
   const scanned = picomatch6.scan(posix7);
   if (scanned.isGlob) {
-    const rel2 = toPosix3(relative13(configDir, resolve16(cwd, scanned.base === "" ? "." : scanned.base)));
+    const rel2 = toPosix3(relative13(configDir, resolve17(cwd, scanned.base === "" ? "." : scanned.base)));
     if (isAbsolute8(rel2) || rel2 === ".." || rel2.startsWith("../")) return void 0;
     return rel2 === "" ? scanned.glob : `${rel2}/${scanned.glob}`;
   }
-  const abs = resolve16(cwd, posix7);
+  const abs = resolve17(cwd, posix7);
   const rel = toPosix3(relative13(configDir, abs));
   if (isAbsolute8(rel) || rel.startsWith("..")) return void 0;
   let directory = posix7.endsWith("/");
@@ -16562,7 +17193,7 @@ async function exists(absPath, file) {
   }
 }
 function plannedConfigDir(ctx) {
-  return ctx.configDir ?? findGitRoot(ctx.cwd) ?? resolve16(ctx.cwd);
+  return ctx.configDir ?? findGitRoot(ctx.cwd) ?? resolve17(ctx.cwd);
 }
 async function keyHome(ctx, label, data, key) {
   const model = new Model(ctx, plannedConfigDir(ctx));
@@ -16574,7 +17205,7 @@ async function keyHome(ctx, label, data, key) {
   ) : void 0;
   const owner = model.ownerOf(key, members, marked);
   if (owner !== void 0) {
-    const at2 = model.fileFor(owner, resolve16(ctx.base, label));
+    const at2 = model.fileFor(owner, resolve17(ctx.base, label));
     if (owner.url || at2.abs === void 0) {
       return { kind: "url", collection: owner.collection, file: owner.file };
     }
@@ -16600,7 +17231,7 @@ function marksOf(ctx) {
   });
 }
 function entryFor(m, label, data, configDir, base, key) {
-  if (m.join === PATH_JOIN2) return toPosix3(relative13(configDir, resolve16(base, label)));
+  if (m.join === PATH_JOIN2) return toPosix3(relative13(configDir, resolve17(base, label)));
   let raw = data[m.join];
   if (isEncryptedValue(raw)) {
     const k = key();
@@ -16618,7 +17249,7 @@ function entryFor(m, label, data, configDir, base, key) {
   return void 0;
 }
 async function relocationPages(ctx, request) {
-  const pages2 = new Set(request.files.map((label) => resolve16(ctx.base, label)));
+  const pages2 = new Set(request.files.map((label) => resolve17(ctx.base, label)));
   const root = ctx.configDir ?? ctx.cwd;
   for (const collection of ctx.declaredCollections) {
     const perPage = collection.externalMetadata.some(
@@ -16634,7 +17265,7 @@ async function relocationPages(ctx, request) {
         ...ctx.config?.respectGitignore !== void 0 ? { configured: ctx.config.respectGitignore } : {}
       })
     });
-    for (const file of walked.files) pages2.add(resolve16(root, file));
+    for (const file of walked.files) pages2.add(resolve17(root, file));
   }
   return [...pages2];
 }
@@ -16664,20 +17295,20 @@ async function planRelocation(ctx, request) {
       if (beyond) return void 0;
       throw new DocmetaError(`Unsupported file type "${extname3(label)}" for "${label}". Use --as to override.`);
     }
-    const absPath = resolve16(ctx.base, label);
+    const absPath = resolve17(ctx.base, label);
     const elements = resolveElements(label, ctx.config, currentMembers(label));
     let content = "";
     let own2 = {};
     let unreadable2;
     if (beyond) {
       try {
-        content = await readFile9(absPath, "utf8");
+        content = await readFile8(absPath, "utf8");
         own2 = extractor.extract(content, label, { elements }).data;
       } catch (err) {
         unreadable2 = (errorMessage(err).split("\n")[0] ?? "").replace(/:\s*$/, "");
       }
     } else {
-      content = await readFile9(absPath, "utf8");
+      content = await readFile8(absPath, "utf8");
       try {
         own2 = extractor.extract(content, label, { elements }).data;
       } catch (err) {
@@ -16883,7 +17514,7 @@ async function planRelocation(ctx, request) {
     });
     const labels = dedupe2([
       ...request.files,
-      ...walked.files.map((f) => reported2(resolve16(configDir, f), ctx.base))
+      ...walked.files.map((f) => reported2(resolve17(configDir, f), ctx.base))
     ]).filter((label) => model.members(label).includes(name2));
     for (const label of labels) {
       const page = await load(label, !runSet.has(label));
@@ -17118,7 +17749,7 @@ function assertNoStrandedEntries(m, index, pages2, configDir, fileOf) {
 }
 async function readManifestText(path, file, perPage) {
   try {
-    return await readFile9(path, "utf8");
+    return await readFile8(path, "utf8");
   } catch (err) {
     if (perPage && isMissing(err)) return null;
     throw new DocmetaError(`Manifest ${file} could not be read: ${errorMessage(err)}`);
@@ -17148,7 +17779,7 @@ function keyLines2(text2, join12) {
 async function configTarget(ctx, configDir) {
   if (ctx.configPath !== void 0) {
     try {
-      const text2 = await readFile9(ctx.configPath, "utf8");
+      const text2 = await readFile8(ctx.configPath, "utf8");
       return { path: ctx.configPath, text: text2, disk: text2 };
     } catch (err) {
       if (err.code !== "ENOENT") {
@@ -17159,10 +17790,10 @@ async function configTarget(ctx, configDir) {
       return { path: ctx.configPath, text: ctx.configFile?.text ?? null, disk: null };
     }
   }
-  for (const name2 of [...FAMILY_CONFIG_NAMES, ...MOOSE_CONFIG_NAMES]) {
+  for (const name2 of FAMILY_CONFIG_NAMES) {
     const path = join9(configDir, name2);
     try {
-      const text2 = await readFile9(path, "utf8");
+      const text2 = await readFile8(path, "utf8");
       return { path, text: text2, disk: text2 };
     } catch {
     }
@@ -17348,7 +17979,7 @@ async function applyRelocation(ctx, plan, io = {}) {
   for (const w of plan.writes) {
     let now;
     try {
-      now = await readFile9(w.path, "utf8");
+      now = await readFile8(w.path, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         throw new DocmetaError(`${label(w)} could not be read: ${errorMessage(err)}`);
@@ -17515,7 +18146,7 @@ function relocationOffers(plan) {
 }
 
 // src/meta/commands/validate.ts
-import { resolve as resolve18, extname as extname4 } from "node:path";
+import { resolve as resolve19, extname as extname4 } from "node:path";
 
 // src/meta/core/checks.ts
 var CHECK_KEYWORD = "check";
@@ -17653,7 +18284,7 @@ async function runChecks(checks, entries, ctx = {}) {
 }
 
 // src/meta/core/derive/provenance-place.ts
-import { isAbsolute as isAbsolute9, relative as relative14, resolve as resolve17, sep as sep9 } from "node:path";
+import { isAbsolute as isAbsolute9, relative as relative14, resolve as resolve18, sep as sep9 } from "node:path";
 var toPosix4 = (p) => p.split(sep9).join("/");
 function provenanceManifests(collections, configDir, base, field = PROVENANCE_FIELD) {
   const out = [];
@@ -17675,7 +18306,7 @@ function provenanceManifests(collections, configDir, base, field = PROVENANCE_FI
         });
         continue;
       }
-      const absPath = isAbsolute9(manifest.file) ? manifest.file : resolve17(configDir, manifest.file);
+      const absPath = isAbsolute9(manifest.file) ? manifest.file : resolve18(configDir, manifest.file);
       const perPage = hasPagePlaceholder(manifest.file);
       out.push({
         collection: collection.name,
@@ -17709,7 +18340,7 @@ function provenancePlace(label, data, manifests, collections, configDir, base, m
   if (declared.implied?.url === true) throw new DocmetaError(urlRefusal(declared.collection, field));
   const manifest = declared.perPage ? ownManifest(declared, label, collections, configDir, base) : declared;
   if (manifest.join === PATH_JOIN2) {
-    const entry = toPosix4(relative14(configDir, resolve17(base, label)));
+    const entry = toPosix4(relative14(configDir, resolve18(base, label)));
     return { manifest, absPath: manifest.absPath, entry, join: manifest.join };
   }
   const value = data[manifest.join];
@@ -17721,7 +18352,7 @@ function provenancePlace(label, data, manifests, collections, configDir, base, m
   return { manifest, absPath: manifest.absPath, entry: String(value), join: manifest.join };
 }
 function ownManifest(manifest, label, collections, configDir, base) {
-  const resolved = pageManifestPath(manifest.written, configDir, resolve17(base, label));
+  const resolved = pageManifestPath(manifest.written, configDir, resolve18(base, label));
   if ("outside" in resolved) {
     const declared = collections.find((c) => c.name === manifest.collection)?.externalMetadata.find((m) => m.file === manifest.written);
     throw new DocmetaError(
@@ -17757,6 +18388,36 @@ function stampManifests(label, data, collections, configDir, base, marked, field
   return out;
 }
 
+// src/shared/cli-options.ts
+import { basename as basename6, relative as relative15 } from "node:path";
+function collect(value, prev) {
+  return prev.concat([value]);
+}
+function splitList(value) {
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+var STDIN_REQUIRES_AS = "Reading from stdin (`-`) requires --as <format> to choose an extractor.";
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+function configOption(value) {
+  if (value === false) return { noConfig: true };
+  return typeof value === "string" ? { configPath: value } : {};
+}
+function explicitFalse(value) {
+  return value === false ? false : void 0;
+}
+function reportConfig(toStdout, cwd) {
+  return (info) => {
+    const where = (relative15(cwd, info.dir) || ".").replace(/\\/g, "/");
+    const line = `Using ${basename6(info.path)} (${where})
+`;
+    (toStdout ? process.stdout : process.stderr).write(line);
+  };
+}
+
 // src/meta/commands/validate.ts
 function parseErrorResult(file, format, message, keyword) {
   const err = {
@@ -17840,7 +18501,7 @@ async function runValidate(opts) {
     base,
     offline: opts.offline ?? config?.offline ?? false,
     // A `{page}` manifest (0058) is read for exactly the pages this run reads.
-    pages: files.map((file) => resolve18(base, file))
+    pages: files.map((file) => resolve19(base, file))
   });
   const validator = new Validator(
     schemaLoadOptions({
@@ -18011,7 +18672,7 @@ async function runValidate(opts) {
       const owned = declaredCollections.length === 0 ? {} : stampManifests(label, extracted.data, declaredCollections, configDir ?? cwd, base, merged.marked, STAMPED_DATE_FIELDS);
       deriveInputs.push({
         label,
-        absPath: resolve18(base, label),
+        absPath: resolve19(base, label),
         content,
         extracted,
         ...place !== void 0 ? { provenanceManifest: place } : {},
@@ -18145,13 +18806,13 @@ async function runValidate(opts) {
     const content = opts.stdinContent ?? "";
     if (!forcedExtractor) {
       throw new DocmetaError(
-        "Reading from stdin (`-`) requires --as <format> to choose an extractor."
+        STDIN_REQUIRES_AS
       );
     }
     await processOne(STDIN_LABEL, content, forcedExtractor.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile10(resolve18(base, file), "utf8");
+    const content = await readFile9(resolve19(base, file), "utf8");
     await processOne(file, content, extname4(file));
   }
   if (unverified > 0) opts.onNotice?.(unverifiedWarning(unverified));
@@ -18297,8 +18958,8 @@ async function runValidate(opts) {
 }
 
 // src/meta/commands/get.ts
-import { readFile as readFile11 } from "node:fs/promises";
-import { resolve as resolve19, extname as extname5 } from "node:path";
+import { readFile as readFile10 } from "node:fs/promises";
+import { resolve as resolve20, extname as extname5 } from "node:path";
 async function runGet(opts) {
   const cwd = opts.cwd ?? process.cwd();
   if (opts.fields.length === 0) {
@@ -18359,7 +19020,7 @@ async function runGet(opts) {
     base,
     offline: opts.offline ?? config?.offline ?? false,
     // A `{page}` manifest (0058) is read for exactly the pages this run reads.
-    pages: files.map((file) => resolve19(base, file))
+    pages: files.map((file) => resolve20(base, file))
   });
   const commands = commandsOf(config?.derive) ?? {};
   const deriving = opts.derived !== false;
@@ -18402,7 +19063,7 @@ async function runGet(opts) {
         const owned = declaredCollections.length === 0 ? {} : stampManifests(label, own2.data, declaredCollections, configDir ?? cwd, base, merged.marked, STAMPED_DATE_FIELDS);
         deriveInputs.push({
           label,
-          absPath: resolve19(base, label),
+          absPath: resolve20(base, label),
           content,
           extracted: own2,
           ...place !== void 0 ? { provenanceManifest: place } : {},
@@ -18437,13 +19098,13 @@ async function runGet(opts) {
   if (usingStdin) {
     if (!forced) {
       throw new DocmetaError(
-        "Reading from stdin (`-`) requires --as <format> to choose an extractor."
+        STDIN_REQUIRES_AS
       );
     }
     await readOne(STDIN_LABEL, opts.stdinContent ?? "", forced.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile11(resolve19(base, file), "utf8");
+    const content = await readFile10(resolve20(base, file), "utf8");
     await readOne(file, content, extname5(file));
   }
   if (deriving) {
@@ -18569,8 +19230,8 @@ function parseJsonPointer(pointer) {
 
 // src/meta/commands/schemas.ts
 import { existsSync as existsSync4 } from "node:fs";
-import { mkdir as mkdir3, readFile as readFile12 } from "node:fs/promises";
-import { dirname as dirname10, extname as extname6, isAbsolute as isAbsolute10, join as join10, relative as relative15, resolve as resolve20, sep as sep10 } from "node:path";
+import { mkdir as mkdir3, readFile as readFile11 } from "node:fs/promises";
+import { dirname as dirname10, extname as extname6, isAbsolute as isAbsolute10, join as join10, relative as relative16, resolve as resolve21, sep as sep10 } from "node:path";
 import { parseDocument as parseDocument8, parse as parseYaml6, stringify as stringify4 } from "yaml";
 function getSchemasInfo(registered2) {
   return {
@@ -18582,7 +19243,7 @@ function getSchemasInfo(registered2) {
 var DEFAULT_VENDOR_DIR = "./schema";
 var DEFAULT_CONFIG_NAME = "manni.config.yaml";
 function posixRelative(from, to) {
-  return relative15(from, to).split(sep10).join("/");
+  return relative16(from, to).split(sep10).join("/");
 }
 function vendorFileName(url) {
   let parsed2;
@@ -18668,9 +19329,9 @@ async function runVendorSchema(opts) {
     );
   }
   const loaded = await loadConfig(opts.configPath, cwd);
-  const configPath = loaded?.path ?? resolve20(cwd, DEFAULT_CONFIG_NAME);
+  const configPath = loaded?.path ?? resolve21(cwd, DEFAULT_CONFIG_NAME);
   const configDir = loaded?.dir ?? cwd;
-  const absDir = resolve20(cwd, opts.dir ?? DEFAULT_VENDOR_DIR);
+  const absDir = resolve21(cwd, opts.dir ?? DEFAULT_VENDOR_DIR);
   const absFile = join10(absDir, vendorFileName(url));
   await assertNotIgnored(absFile, absDir, cwd, opts.onNotice);
   const fromConfig = posixRelative(configDir, absFile);
@@ -18689,7 +19350,7 @@ async function runVendorSchema(opts) {
   }
   let unchanged = false;
   if (existsSync4(absFile)) {
-    const current = await readFile12(absFile);
+    const current = await readFile11(absFile);
     unchanged = bytes.equals(current);
     if (!unchanged && !folded.replaced) {
       throw new DocmetaError(
@@ -18699,7 +19360,7 @@ async function runVendorSchema(opts) {
   }
   await mkdir3(absDir, { recursive: true });
   await writeFileAtomic(absFile, bytes);
-  const existing = loaded ? await readFile12(configPath, "utf8") : null;
+  const existing = loaded ? await readFile11(configPath, "utf8") : null;
   const section = loaded ? loaded.section : META_SECTION;
   const text2 = renderConfig(existing, folded.entries, section);
   reparseConfig(text2, posixRelative(cwd, configPath) || DEFAULT_CONFIG_NAME, section);
@@ -18841,12 +19502,12 @@ async function runInferSchema(opts) {
   }
   if (usingStdin && !forced) {
     throw new DocmetaError(
-      "Reading from stdin (`-`) requires --as <format> to choose an extractor."
+      STDIN_REQUIRES_AS
     );
   }
   let absOut;
   if (opts.out !== void 0) {
-    absOut = resolve20(cwd, opts.out);
+    absOut = resolve21(cwd, opts.out);
     await assertNotIgnored(
       absOut,
       dirname10(absOut),
@@ -18892,7 +19553,7 @@ async function runInferSchema(opts) {
     configDir: configDir ?? cwd,
     base,
     offline: opts.offline ?? config?.offline ?? false,
-    pages: files.map((file) => resolve20(base, file))
+    pages: files.map((file) => resolve21(base, file))
   });
   const stats = /* @__PURE__ */ new Map();
   const unreadable2 = [];
@@ -18951,7 +19612,7 @@ async function runInferSchema(opts) {
     await scanOne(STDIN_LABEL, opts.stdinContent ?? "", forced.extensions[0] ?? "");
   }
   for (const file of files) {
-    const content = await readFile12(resolve20(base, file), "utf8");
+    const content = await readFile11(resolve21(base, file), "utf8");
     await scanOne(file, content, extname6(file));
   }
   for (const u of unreadable2) {
@@ -19012,8 +19673,8 @@ async function runInferSchema(opts) {
 // src/meta/commands/query.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
-import { mkdir as mkdir4, open as open2, readFile as readFile13, rename as rename3, rm as rm3 } from "node:fs/promises";
-import { dirname as dirname11, isAbsolute as isAbsolute11, resolve as resolve21, extname as extname7, sep as sep11 } from "node:path";
+import { mkdir as mkdir4, open as open2, readFile as readFile12, rename as rename3, rm as rm3 } from "node:fs/promises";
+import { dirname as dirname11, isAbsolute as isAbsolute11, resolve as resolve22, extname as extname7, sep as sep11 } from "node:path";
 
 // src/shared/prompt.ts
 import { createInterface } from "node:readline";
@@ -19272,7 +19933,7 @@ async function runQuery(opts) {
     base,
     offline: opts.offline ?? config?.offline ?? false,
     // A `{page}` manifest (0058) is read for exactly the pages this run reads.
-    pages: files.map((file) => resolve21(base, file))
+    pages: files.map((file) => resolve22(base, file))
   });
   const configuredKey = lazyKey(configFile, opts.env);
   let ensuredKey;
@@ -19358,7 +20019,7 @@ async function runQuery(opts) {
   if (usingStdin) {
     if (!forced) {
       throw new DocmetaError(
-        "Reading from stdin (`-`) requires --as <format> to choose an extractor."
+        STDIN_REQUIRES_AS
       );
     }
     const ext = forced.extensions[0];
@@ -19370,10 +20031,10 @@ async function runQuery(opts) {
     await readOne(STDIN_LABEL, opts.stdinContent ?? "", ext);
   }
   for (const file of files) {
-    const content = await readFile13(resolve21(base, file), "utf8");
+    const content = await readFile12(resolve22(base, file), "utf8");
     await readOne(file, content, extname7(file));
   }
-  const db = opts.db === void 0 ? void 0 : { resolved: resolve21(cwd, opts.db), display: opts.db };
+  const db = opts.db === void 0 ? void 0 : { resolved: resolve22(cwd, opts.db), display: opts.db };
   const run2 = await runSql(sql, entries, {
     target: db,
     params: boundParams,
@@ -19516,7 +20177,7 @@ async function runSql(sql, entries, ctx) {
         const owned = ctx.declaredCollections.length === 0 ? {} : stampManifests(e.label, e.own.data, ctx.declaredCollections, manifestRoot, ctx.base, e.marked, STAMPED_DATE_FIELDS);
         return {
           label: e.label,
-          absPath: resolve21(ctx.base, e.label),
+          absPath: resolve22(ctx.base, e.label),
           content: e.content,
           extracted: e.own,
           ...place !== void 0 ? { provenanceManifest: place } : {},
@@ -19988,14 +20649,14 @@ function assertSchemaWriteWithin(ctx, abs) {
   );
 }
 function foldPath(p) {
-  const abs = resolve21(p);
+  const abs = resolve22(p);
   return process.platform === "win32" ? abs.toLowerCase() : abs;
 }
 function filePinsByPath(ctx) {
   const byPath = /* @__PURE__ */ new Map();
   for (const [ref, pin] of collectSchemaPins(ctx.config)) {
     if (classifyRef(ref).kind !== "file") continue;
-    byPath.set(foldPath(resolve21(ctx.cwd, ref)), pin);
+    byPath.set(foldPath(resolve22(ctx.cwd, ref)), pin);
   }
   return byPath;
 }
@@ -20024,13 +20685,13 @@ async function loadSetMembers(refs, ctx) {
       });
       continue;
     }
-    const abs = registered2?.path ?? resolve21(ctx.cwd, ref);
+    const abs = registered2?.path ?? resolve22(ctx.cwd, ref);
     const canon = foldPath(abs);
     if (seenFiles.has(canon)) continue;
     seenFiles.add(canon);
     let text2;
     try {
-      text2 = await readFile13(abs, "utf8");
+      text2 = await readFile12(abs, "utf8");
     } catch {
       throw new DocmetaError(
         `Schema file not found: "${ref}" (looked at ${abs}).`
@@ -20231,7 +20892,7 @@ async function planSchemaMutation(ops, entries, ctx) {
     const [, name2, ver] = target.builtinId.split(":");
     const safe = (s) => s.replace(/[^A-Za-z0-9._-]/g, "-");
     const forkName = `${safe(name2 ?? "schema")}-${safe(ver ?? "0")}.local.json`;
-    schemaAbs = resolve21(ctx.configDir ?? ctx.cwd, "schemas", forkName);
+    schemaAbs = resolve22(ctx.configDir ?? ctx.cwd, "schemas", forkName);
     assertSchemaWriteWithin(ctx, schemaAbs);
     if (existsSync5(schemaAbs)) {
       throw new DocmetaError(
@@ -20387,7 +21048,7 @@ async function planConfigEdit(ctx, edit, runRefs) {
   if (configPath === void 0 || configDir === void 0) {
     return { changes: [], repointed: false };
   }
-  const text2 = await readFile13(configPath, "utf8");
+  const text2 = await readFile12(configPath, "utf8");
   const doc = parseDocument10(stripBom2(text2));
   const display = displayPath(ctx, configPath);
   const rawRefOf = (item) => {
@@ -20398,7 +21059,7 @@ async function planConfigEdit(ctx, edit, runRefs) {
     }
     return void 0;
   };
-  const rebaseRaw = (raw) => classifyRef(raw).kind === "file" && !isAbsolute11(raw) ? resolve21(configDir, raw) : raw;
+  const rebaseRaw = (raw) => classifyRef(raw).kind === "file" && !isAbsolute11(raw) ? resolve22(configDir, raw) : raw;
   const wantSet = runRefs.map(rebaseRaw).sort().join("\n");
   const seqResolvesToRunSet = (node) => {
     if (!isSeq5(node)) return false;
@@ -20443,7 +21104,7 @@ async function planConfigEdit(ctx, edit, runRefs) {
       if (!isMap10(item)) continue;
       const raw = rawRefOf(item);
       if (raw === void 0 || classifyRef(raw).kind !== "file") continue;
-      const abs = isAbsolute11(raw) ? raw : resolve21(configDir, raw);
+      const abs = isAbsolute11(raw) ? raw : resolve22(configDir, raw);
       if (foldPath(abs) !== wantPath) continue;
       pinFrom = item.get("integrity");
       item.set("integrity", edit.integrity.value);
@@ -20672,7 +21333,7 @@ function buildChanges(diff, entries, sentinel, ctx, renameHints = [], booleanAdd
         `"${file}": no writable format for that extension.`
       );
     }
-    if (existsSync5(resolve21(ctx.base, file))) {
+    if (existsSync5(resolve22(ctx.base, file))) {
       throw new DocmetaError(
         `"${file}" already exists; INSERT creates new files only.`
       );
@@ -20691,7 +21352,7 @@ function buildChanges(diff, entries, sentinel, ctx, renameHints = [], booleanAdd
         `"${from}" -> "${to}": a rename may not change the extension.`
       );
     }
-    if (existsSync5(resolve21(ctx.base, to))) {
+    if (existsSync5(resolve22(ctx.base, to))) {
       throw new DocmetaError(
         `"${to}" already exists; the rename would overwrite it.`
       );
@@ -20725,9 +21386,9 @@ function validateNewPath(p, base) {
   if (p.split(/[\\/]/).some((segment) => segment === "..")) {
     refuse("it traverses upward");
   }
-  const abs = resolve21(base, p);
-  if (abs === resolve21(base)) refuse("it points at the corpus root, not a file");
-  if (!abs.startsWith(resolve21(base) + sep11)) refuse("it escapes the corpus");
+  const abs = resolve22(base, p);
+  if (abs === resolve22(base)) refuse("it points at the corpus root, not a file");
+  if (!abs.startsWith(resolve22(base) + sep11)) refuse("it escapes the corpus");
 }
 function refuseJoinFieldChanges(changes, entries, ctx) {
   const index = ctx.externalMetadata;
@@ -20802,7 +21463,7 @@ function runPages(changes, entries, base) {
   const labels = new Set(entries.map((e) => e.label));
   for (const c of changes) if (!("schema" in c) && !("config" in c)) labels.add(c.file);
   labels.delete(STDIN_LABEL);
-  return [...labels].map((label) => resolve21(base, label));
+  return [...labels].map((label) => resolve22(base, label));
 }
 async function planManifestEdits(changes, entries, ctx, renameHints) {
   for (const c of changes) {
@@ -20854,7 +21515,7 @@ async function planManifestEdits(changes, entries, ctx, renameHints) {
       let text2;
       let expected;
       try {
-        text2 = await readFile13(home.absPath, "utf8");
+        text2 = await readFile12(home.absPath, "utf8");
         expected = text2;
       } catch (err) {
         if (!home.perPage || !isMissing(err)) {
@@ -20890,7 +21551,7 @@ async function planManifestEdits(changes, entries, ctx, renameHints) {
     );
     const index = await leftOut;
     if (index === null) return void 0;
-    const abs = resolve21(ctx.base, file);
+    const abs = resolve22(ctx.base, file);
     const named = index.entries.find(
       (e) => e.join === PATH_JOIN2 && e.abs === abs && excluded.includes(e.collection)
     );
@@ -20937,7 +21598,7 @@ async function planManifestEdits(changes, entries, ctx, renameHints) {
       continue;
     }
     if ("renamed" in c) {
-      const supplied = ctx.externalMetadata?.byPath.get(resolve21(ctx.base, c.file));
+      const supplied = ctx.externalMetadata?.byPath.get(resolve22(ctx.base, c.file));
       const seen = /* @__PURE__ */ new Set();
       for (const [key, sv] of supplied ?? []) {
         if (seen.has(sv.file) || !ctx.memberships(c.file).includes(sv.collection)) continue;
@@ -21245,14 +21906,14 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
   const pendingWrites = [];
   const pendingRenames = [];
   for (const [label, ops] of grouped) {
-    const path = resolve21(ctx.base, label);
+    const path = resolve22(ctx.base, label);
     if (ops.renamedTo !== void 0) {
       if (!existsSync5(path)) {
         throw new DocmetaError(
           `"${label}" is gone from disk since it was read; re-run the query.`
         );
       }
-      const toDisk = resolve21(ctx.base, ops.renamedTo);
+      const toDisk = resolve22(ctx.base, ops.renamedTo);
       if (existsSync5(toDisk)) {
         throw new DocmetaError(
           `"${ops.renamedTo}" appeared on disk since the plan; re-run the query.`
@@ -21290,7 +21951,7 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
     }
     const entry = byLabel.get(label);
     if (!entry) throw new DocmetaError(`No loaded entry for "${label}".`);
-    const content = await readFile13(path, "utf8");
+    const content = await readFile12(path, "utf8");
     const members = ctx.memberships(label);
     const current = (await mergeWithMarks(
       label,
@@ -21362,7 +22023,7 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
     }
     let now;
     try {
-      now = await readFile13(w.path, "utf8");
+      now = await readFile12(w.path, "utf8");
     } catch {
       now = void 0;
     }
@@ -21375,7 +22036,7 @@ async function applyChanges(changes, entries, ctx, schemaPlan, manifestWrites =
   for (const m of manifestWrites) {
     let now;
     try {
-      now = await readFile13(m.path, "utf8");
+      now = await readFile12(m.path, "utf8");
     } catch {
       now = null;
     }
@@ -21508,19 +22169,17 @@ function skipExpression(sql, from) {
 }
 
 // src/meta/commands/fill.ts
-import { readFile as readFile16 } from "node:fs/promises";
-import { resolve as resolve23, extname as extname9, join as join11 } from "node:path";
+import { readFile as readFile15 } from "node:fs/promises";
+import { resolve as resolve24, extname as extname9, join as join11 } from "node:path";
 import {
   completeValidatedJSON,
   makeProvider,
-  resolveProviderIdentityAsync,
-  DEFAULT_MODELS,
   JsonCache,
   buildCacheKey,
   sha256,
   pricingFor,
   costOfUsage,
-  InferenceError
+  InferenceError as InferenceError2
 } from "@hawkeyexl/inference";
 
 // src/meta/commands/fill-projection.ts
@@ -21930,8 +22589,8 @@ function single(alternatives2) {
 }
 
 // src/meta/commands/fill-hints.ts
-import { readFile as readFile14 } from "node:fs/promises";
-import { extname as extname8, resolve as resolve22 } from "node:path";
+import { readFile as readFile13 } from "node:fs/promises";
+import { extname as extname8, resolve as resolve23 } from "node:path";
 
 // src/shared/reference-fields.ts
 var CONCEPT_FIELDS = [["concepts"], ["graph", "concepts"]];
@@ -22017,7 +22676,7 @@ function pageIdReader(opts) {
     return held;
   };
   return async (file, names) => {
-    const self = resolve22(file);
+    const self = resolve23(file);
     const ids = /* @__PURE__ */ new Set();
     for (const name2 of names) {
       const collection = opts.collections.find((c) => c.name === name2);
@@ -22041,10 +22700,10 @@ async function readIds(collection, opts) {
     if (!isMember(collection, file)) continue;
     const extractor = extractorForExtension(extname8(file));
     if (extractor === void 0) continue;
-    const path = resolve22(opts.configDir, file);
+    const path = resolve23(opts.configDir, file);
     let id;
     try {
-      id = extractor.extract(await readFile14(path, "utf8"), file).data.id;
+      id = extractor.extract(await readFile13(path, "utf8"), file).data.id;
     } catch {
       continue;
     }
@@ -22063,7 +22722,7 @@ function termLabelSource() {
 }
 
 // src/meta/core/manifest-writes.ts
-import { readFile as readFile15 } from "node:fs/promises";
+import { readFile as readFile14 } from "node:fs/promises";
 var manifestCodec = {
   apply(text2, op) {
     const where = { entry: op.entry, key: op.key, join: op.join, file: op.file };
@@ -22079,7 +22738,7 @@ function applyManifestOp(text2, op) {
 async function holdManifestFile(path, file, perPage = false) {
   let before;
   try {
-    before = await readFile15(path, "utf8");
+    before = await readFile14(path, "utf8");
   } catch (err) {
     if (perPage && isMissing(err)) return heldManifest(path, file, "", true);
     throw new DocmetaError(`Manifest ${file} could not be read: ${errorMessage(err)}`);
@@ -22096,7 +22755,7 @@ async function settleManifest(held, io = {}) {
     codec: manifestCodec,
     // A per-page manifest (proposal 0058) may be the first file in its directory.
     write: io.write ?? ((at2, text2) => writeFileAtomic(at2, text2, { createParents: true })),
-    read: io.read ?? ((at2) => readFile15(at2, "utf8")),
+    read: io.read ?? ((at2) => readFile14(at2, "utf8")),
     toError: (message) => new DocmetaError(message)
   });
   rebaseline(held);
@@ -22253,12 +22912,56 @@ function buildUserPrompt(params, before = []) {
   ].join("\n");
 }
 
+// src/meta/core/meta-provenance.ts
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeMetaProvenance(held, model, key, proposed) {
+  if (held !== void 0 && !Array.isArray(held)) return void 0;
+  const list2 = held === void 0 ? [] : [...held];
+  const at2 = list2.findIndex((e) => isPlainRecord(e) && e["generated-by"] === model);
+  const prior = list2[at2];
+  const kept = isPlainRecord(prior) ? prior : {};
+  const priorNames = kept[key];
+  const names = Array.isArray(priorNames) ? priorNames.filter((p) => typeof p === "string") : [];
+  const confidence = {};
+  if (isPlainRecord(kept.confidence)) {
+    for (const [k, v] of Object.entries(kept.confidence)) {
+      if (typeof v === "number") confidence[k] = v;
+    }
+  }
+  for (const p of proposed) {
+    if (!names.includes(p.name)) names.push(p.name);
+    confidence[p.name] = p.confidence;
+  }
+  const entry = {
+    ...kept,
+    "generated-by": model,
+    [key]: names,
+    confidence
+  };
+  if (at2 === -1) list2.push(entry);
+  else list2[at2] = entry;
+  return { list: list2, entry, names };
+}
+function metaProvenanceEntries(value) {
+  if (!Array.isArray(value)) return [];
+  const strings = (list2) => Array.isArray(list2) ? list2.filter((s) => typeof s === "string") : [];
+  const out = [];
+  for (const item of value) {
+    if (!isPlainRecord(item)) continue;
+    const machine = item["generated-by"];
+    if (typeof machine !== "string" || machine === "") continue;
+    out.push({ "generated-by": machine, fields: strings(item.fields), evals: strings(item.evals) });
+  }
+  return out;
+}
+
 // src/meta/commands/fill.ts
 var META_PROVENANCE_KEY = "meta-provenance";
 var PROVENANCE_KEYS = /* @__PURE__ */ new Set(["provenance", META_PROVENANCE_KEY]);
 var DEFAULT_THRESHOLD = 0.7;
 var DEFAULT_CONCURRENCY = 4;
-var DEFAULT_PROVIDER = "auto";
 var CACHE_DIR = ".manni/meta/cache";
 function looksLikeOverflow(message) {
   return /context|too long|too large|token limit|maximum.*tokens|exceeds/i.test(
@@ -22310,7 +23013,7 @@ async function runFill(opts) {
   }
   if (usingStdin && !forcedExtractor) {
     throw new DocmetaError(
-      "Reading from stdin (`-`) requires --as <format> to choose an extractor."
+      STDIN_REQUIRES_AS
     );
   }
   const threshold = requireNumber(
@@ -22339,13 +23042,19 @@ async function runFill(opts) {
   const dryRun = Boolean(opts.dryRun);
   const only = opts.fields != null ? new Set(opts.fields) : void 0;
   const managed = new Set(managedFields(config?.derive));
-  const requestedProvider = opts.provider ?? config?.fill?.provider ?? DEFAULT_PROVIDER;
-  const providerName = opts.local === true && requestedProvider === "auto" ? "llama-cpp" : requestedProvider;
-  const model = opts.model ?? config?.fill?.model;
-  const spec = { provider: providerName, model: model ?? null };
-  assertKnownProvider(providerName);
-  assertModelHasProvider(providerName, model);
-  if (opts.local === true) assertLocalProvider(providerName);
+  const flags = { provider: opts.provider, model: opts.model, local: opts.local };
+  assertLocalFlag(flags, toDocmetaError);
+  const family = configFile?.providers ?? {};
+  const selection = selectProvider(flags, [
+    { provider: config?.fill?.provider, model: config?.fill?.model, origin: "fill.provider" },
+    { provider: family.provider, model: family.model, origin: "providers.provider" }
+  ]);
+  const { provider: providerName, model } = selection;
+  assertKnownProvider2(providerName);
+  assertModelHasProvider2(providerName, model);
+  const replaced = localNotice(selection);
+  if (replaced !== void 0) opts.onNotice?.(replaced);
+  const spec = providerSpecFor(family, { provider: providerName, model: model ?? null });
   const fileInputs = inputs.filter((i) => i !== STDIN_TOKEN);
   const allowEmpty = opts.allowEmpty ?? config?.allowEmpty;
   const fillExts = opts.exts ?? forcedExtractor?.extensions;
@@ -22381,14 +23090,9 @@ async function runFill(opts) {
     identity = { provider: injected.provider(), model: injected.modelName() };
     construct = () => injected;
   } else {
-    const resolved = await resolveIdentity(spec);
-    if (opts.local === true) assertLocalProvider(resolved.provider);
+    const resolved = await resolveIdentity2(spec);
     identity = resolved;
-    const concrete = {
-      ...spec,
-      provider: resolved.provider,
-      model: resolved.model
-    };
+    const concrete = providerSpecFor(family, resolved);
     construct = () => makeProvider(concrete);
   }
   let provider;
@@ -22398,7 +23102,7 @@ async function runFill(opts) {
         provider = construct();
       } catch (err) {
         throw new DocmetaError(
-          err instanceof InferenceError ? err.message : `Could not construct the "${providerName}" provider: ${errorMessage(err)}`
+          err instanceof InferenceError2 ? err.message : `Could not construct the "${providerName}" provider: ${errorMessage(err)}`
         );
       }
     }
@@ -22432,7 +23136,7 @@ async function runFill(opts) {
     base,
     offline: opts.offline ?? config?.offline ?? false,
     // A `{page}` manifest (0058) is read for exactly the pages this run fills.
-    pages: files.map((file) => resolve23(base, file))
+    pages: files.map((file) => resolve24(base, file))
   });
   const mergeMembersFor = (label) => memberOf(runConfig.declaredCollections, configDir ?? cwd, base, label);
   let externalMetadata = await loadManifests();
@@ -22465,17 +23169,17 @@ async function runFill(opts) {
     const keys = new Set(candidates.map((c) => c.key));
     const wants = (fields) => fields.some(([key]) => key !== void 0 && keys.has(key));
     const termIndex = wants(TERM_FIELDS) ? await (termbase ??= readTermbase()) : void 0;
-    const pages2 = wants(PAGE_FIELDS) ? await pageIds(resolve23(base, label), mergeMembersFor(label)) : [];
+    const pages2 = wants(PAGE_FIELDS) ? await pageIds(resolve24(base, label), mergeMembersFor(label)) : [];
     const hints = fieldHints(candidates, {
       terms: termIndex === void 0 ? void 0 : offered(termIndex.labels),
       pages: offered(pages2)
     });
     return { hints, termIndex };
   };
-  const noticed = /* @__PURE__ */ new Set();
-  const noticeOnce = opts.onNotice === void 0 ? void 0 : (message) => {
-    if (noticed.has(message)) return;
-    noticed.add(message);
+  const noticed2 = /* @__PURE__ */ new Set();
+  const noticeOnce2 = opts.onNotice === void 0 ? void 0 : (message) => {
+    if (noticed2.has(message)) return;
+    noticed2.add(message);
     opts.onNotice?.(message);
   };
   const ctx = relocationContext(runConfig, {
@@ -22487,7 +23191,7 @@ async function runFill(opts) {
     ...opts.as !== void 0 ? { as: opts.as } : {},
     ...opts.respectGitignore !== void 0 ? { respectGitignore: opts.respectGitignore } : {},
     ...opts.env !== void 0 ? { env: opts.env } : {},
-    ...noticeOnce !== void 0 ? { onNotice: noticeOnce } : {}
+    ...noticeOnce2 !== void 0 ? { onNotice: noticeOnce2 } : {}
   });
   const heldManifests = /* @__PURE__ */ new Map();
   const holding = /* @__PURE__ */ new Map();
@@ -22505,7 +23209,7 @@ async function runFill(opts) {
   };
   const restorePage = async (label, before) => {
     try {
-      await writeFileAtomic(resolve23(base, label), before);
+      await writeFileAtomic(resolve24(base, label), before);
       return `${label} was restored.`;
     } catch (err) {
       return `${label} could not be restored: ${errorMessage(err)}. Restore it from version control.`;
@@ -22599,7 +23303,7 @@ async function runFill(opts) {
         // gets written — if anything, a stronger reason to guard it.
         fileBase: cwd,
         trustRoot,
-        onNotice: noticeOnce
+        onNotice: noticeOnce2
       });
     } catch (err) {
       return errorResult(label, extractor.name, errorMessage(err));
@@ -22655,7 +23359,7 @@ async function runFill(opts) {
     }));
     const candidates = proposed.filter((c) => !managedHere.has(c.key));
     const destinations = /* @__PURE__ */ new Map();
-    const flags = [];
+    const flags2 = [];
     let metaHome;
     if (label !== "<stdin>" && candidates.length > 0) {
       const located = { ...view.data };
@@ -22685,7 +23389,7 @@ async function runFill(opts) {
           if (!meta) destinations.set(key, { ...home, entry: home.entry });
           continue;
         }
-        if (prefs.get(key)?.location === "external") flags.push({ label, key, home: home.home });
+        if (prefs.get(key)?.location === "external") flags2.push({ label, key, home: home.home });
       }
     }
     const inPlace = view.plain.flatMap((pointer) => {
@@ -22739,7 +23443,7 @@ async function runFill(opts) {
       sealedCandidates,
       destinations,
       metaHome,
-      flags
+      flags: flags2
     };
   };
   const finishOne = async (ready) => {
@@ -23039,7 +23743,12 @@ async function runFill(opts) {
     if (writable.length > 0) {
       const metaManifest = metaHome?.kind === "manifest" ? metaHome : void 0;
       const metaEntry = metaManifest?.entry;
-      const mergedProvenance = metaHome?.kind === "url" || metaManifest !== void 0 && metaEntry === void 0 ? void 0 : mergeMetaProvenance(extracted.data[META_PROVENANCE_KEY], identity.model, writable);
+      const mergedProvenance = metaHome?.kind === "url" || metaManifest !== void 0 && metaEntry === void 0 ? void 0 : mergeMetaProvenance(
+        extracted.data[META_PROVENANCE_KEY],
+        identity.model,
+        "fields",
+        writable.map((f) => ({ name: f.field, confidence: f.confidence }))
+      );
       if (metaHome?.kind === "url") {
         metaProvenance = { written: false, skipReason: "manifest-owned", manifest: metaHome.file };
       } else if (metaManifest !== void 0 && metaEntry === void 0) {
@@ -23054,12 +23763,12 @@ async function runFill(opts) {
         metaWrite = { value: mergedProvenance.list, home: { ...metaManifest, entry: metaEntry } };
         metaProvenance = {
           written: true,
-          entry: mergedProvenance.entry,
+          entry: { ...mergedProvenance.entry, fields: mergedProvenance.names },
           destination: metaManifest.file
         };
       } else {
         patch[META_PROVENANCE_KEY] = mergedProvenance.list;
-        metaProvenance = { written: true, entry: mergedProvenance.entry };
+        metaProvenance = { written: true, entry: { ...mergedProvenance.entry, fields: mergedProvenance.names } };
       }
     }
     const entryWrites = [];
@@ -23128,7 +23837,7 @@ async function runFill(opts) {
     const changed = next !== content || manifestChanged;
     const pageWritten = next !== content && !dryRun && label !== "<stdin>";
     if (pageWritten) {
-      await writeFileAtomic(resolve23(base, label), next);
+      await writeFileAtomic(resolve24(base, label), next);
     }
     if (manifestChanged) {
       const perManifest = /* @__PURE__ */ new Map();
@@ -23160,7 +23869,7 @@ async function runFill(opts) {
   const prepareAll = async () => ({
     stdin: usingStdin ? await prepareOne("<stdin>", opts.stdinContent ?? "", forcedExtractor?.extensions[0] ?? "") : void 0,
     files: await mapConcurrent(files, concurrency, async (file) => {
-      const content = await readFile16(resolve23(base, file), "utf8");
+      const content = await readFile15(resolve24(base, file), "utf8");
       return prepareOne(file, content, extname9(file));
     })
   });
@@ -23213,31 +23922,6 @@ function topKey(instancePath) {
   return seg.replace(/~1/g, "/").replace(/~0/g, "~");
 }
 var keyOf = (f) => topKey(f.field);
-function isPlainRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function mergeMetaProvenance(held, model, written) {
-  if (held !== void 0 && !Array.isArray(held)) return void 0;
-  const list2 = held === void 0 ? [] : [...held];
-  const at2 = list2.findIndex((e) => isPlainRecord(e) && e["generated-by"] === model);
-  const prior = list2[at2];
-  const kept = isPlainRecord(prior) ? prior : {};
-  const fields = Array.isArray(kept.fields) ? kept.fields.filter((p) => typeof p === "string") : [];
-  const confidence = {};
-  if (isPlainRecord(kept.confidence)) {
-    for (const [k, v] of Object.entries(kept.confidence)) {
-      if (typeof v === "number") confidence[k] = v;
-    }
-  }
-  for (const f of written) {
-    if (!fields.includes(f.field)) fields.push(f.field);
-    confidence[f.field] = f.confidence;
-  }
-  const entry = { ...kept, "generated-by": model, fields, confidence };
-  if (at2 === -1) list2.push(entry);
-  else list2[at2] = entry;
-  return { list: list2, entry };
-}
 async function addsFindings(validate, without, list2) {
   const identity = (e) => JSON.stringify([e.schema, e.instancePath, e.keyword, e.subject ?? null, e.message]);
   const before = /* @__PURE__ */ new Map();
@@ -23550,34 +24234,15 @@ function requireNumber(value, name2, bounds) {
   }
   return value;
 }
-var PROVIDERS = /* @__PURE__ */ new Set([...Object.keys(DEFAULT_MODELS), "auto"]);
-function assertLocalProvider(name2) {
-  if (name2 === "llama-cpp" || name2 === "mock") return;
-  if (name2 === "auto") return;
-  throw new DocmetaError(
-    name2 === "claude-cli" ? `--local cannot use "claude-cli": the CLI runs on this machine but its inference does not. Use --provider llama-cpp.` : `--local cannot use "${name2}", which sends document content to a hosted API. Use --provider llama-cpp, or drop --local.`
-  );
-}
-function assertKnownProvider(name2) {
-  if (PROVIDERS.has(name2)) return;
-  throw new DocmetaError(
-    `Unknown provider "${name2}". Available: ${[...PROVIDERS].join(", ")}.`
-  );
+var toDocmetaError = (message) => new DocmetaError(message);
+function assertKnownProvider2(name2) {
+  assertKnownProvider(name2, toDocmetaError);
 }
-function assertModelHasProvider(name2, model) {
-  if (name2 !== "auto" || model == null) return;
-  throw new DocmetaError(
-    `Model "${model}" was given without a provider: a model name does not say which provider owns it. Set --provider or fill.provider to one of ${Object.keys(DEFAULT_MODELS).join(", ")}, or drop the model to take the detected provider's default.`
-  );
+function assertModelHasProvider2(name2, model) {
+  assertModelHasProvider(name2, model, "fill.provider", toDocmetaError);
 }
-async function resolveIdentity(spec) {
-  try {
-    return await resolveProviderIdentityAsync(spec);
-  } catch (err) {
-    throw new DocmetaError(
-      err instanceof InferenceError ? err.message : `Could not resolve provider "${spec.provider}": ${errorMessage(err)}`
-    );
-  }
+function resolveIdentity2(spec) {
+  return resolveIdentity(spec, toDocmetaError);
 }
 function summarize(results, costUsd, cached) {
   let written = 0;
@@ -23622,8 +24287,8 @@ async function mapConcurrent(items2, limit, fn) {
 }
 
 // src/meta/commands/derive.ts
-import { readFile as readFile17 } from "node:fs/promises";
-import { extname as extname10, relative as relative16, resolve as resolve24, sep as sep12 } from "node:path";
+import { readFile as readFile16 } from "node:fs/promises";
+import { extname as extname10, relative as relative17, resolve as resolve25, sep as sep12 } from "node:path";
 var GENERATED_BY_ENV = "MANNI_GENERATED_BY";
 var SOURCE_HINT = "narrow --sources or --fields";
 async function runDerive(opts) {
@@ -23741,7 +24406,7 @@ async function runDerive(opts) {
   const files = fromCollections ? retainMembers(walked, membersFor) : walked;
   const rangesByPage = /* @__PURE__ */ new Map();
   for (const t of targets) {
-    const label = relative16(base, resolve24(base, t.page)).split(sep12).join("/");
+    const label = relative17(base, resolve25(base, t.page)).split(sep12).join("/");
     if (!files.includes(label)) {
       throw new DocmetaError(
         `${t.target} does not name one file that derive reads; a range names lines of one file.`
@@ -23766,7 +24431,7 @@ async function runDerive(opts) {
     const loaded2 = /* @__PURE__ */ new Map();
     const errors2 = /* @__PURE__ */ new Map();
     for (const label of files) {
-      const absPath = resolve24(base, label);
+      const absPath = resolve25(base, label);
       const extractor = forcedExtractor ?? extractorForExtension(extname10(label));
       if (!extractor) {
         errors2.set(label, {
@@ -23775,7 +24440,7 @@ async function runDerive(opts) {
         });
         continue;
       }
-      const content = await readFile17(absPath, "utf8");
+      const content = await readFile16(absPath, "utf8");
       const elements = resolveElements(label, config, membersFor(label));
       try {
         loaded2.set(label, {
@@ -23818,7 +24483,7 @@ async function runDerive(opts) {
       runFields = union2;
     }
     const provenanceRoot = configDir ?? cwd;
-    const pages2 = files.map((label) => resolve24(base, label));
+    const pages2 = files.map((label) => resolve25(base, label));
     const manifests = runFields.includes(PROVENANCE_FIELD) ? provenanceManifests(declaredCollections, provenanceRoot, base) : [];
     const provenanceCollections = declaredCollections.map((c) => ({
       ...c,
@@ -23910,10 +24575,10 @@ async function runDerive(opts) {
     const members = memberOf(prepared.provenanceCollections, root, base, doc.label);
     return (await mergeWithMarks(doc.label, doc.extracted, prepared.provenanceIndex, members, base, { marks })).extracted.data[PROVENANCE_FIELD];
   };
-  const noticed = /* @__PURE__ */ new Set();
-  const noticeOnce = opts.onNotice === void 0 ? void 0 : (message) => {
-    if (noticed.has(message)) return;
-    noticed.add(message);
+  const noticed2 = /* @__PURE__ */ new Set();
+  const noticeOnce2 = opts.onNotice === void 0 ? void 0 : (message) => {
+    if (noticed2.has(message)) return;
+    noticed2.add(message);
     opts.onNotice?.(message);
   };
   const markFields = async (doc, record) => {
@@ -23944,7 +24609,7 @@ async function runDerive(opts) {
         // `$schema`, since that schema decides what gets encrypted.
         fileBase: cwd,
         trustRoot,
-        onNotice: noticeOnce
+        onNotice: noticeOnce2
       });
     } catch (err) {
       return { error: errorMessage(err) };
@@ -24005,7 +24670,7 @@ async function runDerive(opts) {
     validator,
     ...opts.noConfig === true ? { noConfig: true } : {},
     ...opts.env !== void 0 ? { env: opts.env } : {},
-    ...noticeOnce !== void 0 ? { onNotice: noticeOnce } : {}
+    ...noticeOnce2 !== void 0 ? { onNotice: noticeOnce2 } : {}
   });
   const externalWrites = async () => {
     const out = [];
@@ -24988,15 +25653,28 @@ export {
   generateEncryptionKey,
   encryptValue,
   decryptValue,
+  ToolError,
+  errorMessage,
+  assertKnownProvider,
+  assertModelHasProvider,
+  PROVIDERS_KEY,
+  parseProviders,
+  LOCAL_FLAG_HELP,
+  assertLocalFlag,
+  selectProvider,
+  localNotice,
+  providerSpecFor,
+  resolveIdentity,
   findGitRoot,
   valeConfigPath,
   ditaOtHome,
   programName,
   warn,
   notice,
-  ToolError,
-  errorMessage,
+  noticeOnce,
   FAMILY_CONFIG_NAMES,
+  findConfigFileSync,
+  readConfigFileSync,
   findConfigFile,
   readConfigFile,
   findFamilyConfigFile,
@@ -25005,6 +25683,13 @@ export {
   runIfMain,
   escapeWorkflowCommandMessage,
   escapeWorkflowCommandProperty,
+  collect,
+  splitList,
+  STDIN_REQUIRES_AS,
+  readStdin,
+  configOption,
+  explicitFalse,
+  reportConfig,
   INTEGRITY_SHAPE,
   integrityOf,
   isIntegrity,
@@ -25058,7 +25743,9 @@ export {
   DEFAULT_TTL_HOURS,
   schemaCacheDir,
   SchemaCache,
-  __default34 as __default,
+  __default31 as __default,
+  __default33 as __default2,
+  __default34 as __default3,
   listBuiltins,
   classifyRef,
   fetchSchemaBytes,
@@ -25082,7 +25769,10 @@ export {
   staleFindings,
   LEGACY_CONFIG_NAMES,
   parseConfig,
+  urlManifestMessage,
+  schemaTrustRoot,
   loadConfig,
+  loadMetaSection,
   resolveRunConfig,
   renderSarif,
   renderJunit,
@@ -25108,6 +25798,7 @@ export {
   EXTERNAL_METADATA_FETCH_MAX_BYTES,
   fetchExternalMetadata,
   META_CONTEXT,
+  lazyKey,
   withValueAt,
   EXTERNAL_OWNED_SCHEMA,
   EXTERNAL_DUPLICATE_SCHEMA,
@@ -25124,19 +25815,28 @@ export {
   spliceManifestValue,
   readManifestValue,
   removeManifestKey,
+  isParamName,
+  memberOf,
   LOCATION_KEYWORD,
   LOCATION_EXTERNAL_SCHEMA,
   LOCATION_PAGE_SCHEMA,
+  GRAPH_OUTPUT_KEYWORD,
   Validator,
+  pageMarks,
+  pageSchemaSet,
+  marksValidator,
   configMarks,
-  isParamName,
-  memberOf,
   relocateFailed,
   relocationContext,
   keyHome,
   planRelocation,
   applyRelocation,
   offerPrompt,
+  offerExternalHomes,
+  externalWriteWarnings,
+  mergeMetaProvenance,
+  metaProvenanceEntries,
+  provenanceEntries,
   REVIEW_CACHE_DIR,
   REVIEW_CACHE_VERSION,
   ReviewCache,
@@ -25195,4 +25895,4 @@ export {
   renderQuery,
   renderQueryCsv
 };
-//# sourceMappingURL=chunk-TQG3WCJY.js.map
+//# sourceMappingURL=chunk-TH565O2N.js.map