@hawkeyexl/manni 4.1.0 → 4.2.0

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

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 // package.json
 var package_default = {
   name: "@hawkeyexl/manni",
-  version: "4.1.0",
+  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",
@@ -64,6 +74,7 @@ var package_default = {
     "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",
@@ -94,6 +105,7 @@ var package_default = {
     "@asciidoctor/core": "^3.0.4",
     "@axe-core/playwright": "^4.13.0",
     "@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",
@@ -102,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",
@@ -118,31 +133,42 @@ 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
     }
@@ -8353,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],
@@ -8401,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];
@@ -8494,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])
@@ -8850,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",
@@ -8858,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;
 }
@@ -8969,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;
@@ -10709,6 +11015,14 @@ function schemaTrustRoot(cwd, configDir) {
 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);
@@ -11050,8 +11364,9 @@ function canonicalSchemaRef(ref, ctx) {
   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 ?? ""
@@ -12992,6 +13307,9 @@ 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";
@@ -13023,6 +13341,7 @@ function buildAjv(dialect, coerceTypes = false) {
   if (dialect === "draft7") ajv.addMetaSchema(draft06MetaSchema);
   registerEncryptKeyword(ajv);
   registerLocationKeyword(ajv);
+  registerGraphOutputKeyword(ajv);
   registerBuiltins(ajv, dialect);
   return ajv;
 }
@@ -13071,6 +13390,28 @@ function registerLocationKeyword(ajv) {
 function isLocationShapeError(err) {
   return err instanceof Error && err.message.includes(`"${LOCATION_KEYWORD}"`);
 }
+var graphOutputRecorder;
+function registerGraphOutputKeyword(ajv) {
+  ajv.addKeyword({
+    keyword: GRAPH_OUTPUT_KEYWORD,
+    metaSchema: { type: "boolean" },
+    errors: false,
+    validate: (schema, _data, _parent, cxt) => {
+      if (graphOutputRecorder !== void 0 && typeof schema === "boolean") {
+        const key = topLevelKey(cxt?.instancePath ?? "");
+        if (key !== void 0) {
+          const seen = graphOutputRecorder.get(key);
+          if (seen) seen.add(schema);
+          else graphOutputRecorder.set(key, /* @__PURE__ */ new Set([schema]));
+        }
+      }
+      return true;
+    }
+  });
+}
+function isGraphOutputShapeError(err) {
+  return err instanceof Error && err.message.includes(`"${GRAPH_OUTPUT_KEYWORD}"`);
+}
 function marksSchemaExternal(schema) {
   const properties = schema["properties"];
   if (typeof properties !== "object" || properties === null) return false;
@@ -13081,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"];
@@ -13109,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]));
@@ -13240,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;
@@ -13267,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)}`
       );
@@ -13356,6 +13712,45 @@ var Validator = class {
     }
     return claimed;
   }
+  /**
+   * Whether each top-level key of `data` belongs in a published graph under
+   * `refs`, as its `x-manni-graph-output` mark says. A key no schema marks has no
+   * entry, which the caller reads as `true`: absent means harvested.
+   *
+   * A first pass with the recording keyword, as `locationPreferences` runs, so
+   * a mark counts exactly where validation would evaluate it, and a mark nested
+   * inside `graph` is ignored. Only present values are marked: Ajv applies a
+   * property's subschema to a property that exists. `$schema` is stripped
+   * first, as validation does.
+   *
+   * Refs are evaluated in order and a later ref's mark wins, so a house schema
+   * listed after a vocabulary refines it. A schema that says both on paths
+   * every document takes is refused when it compiles. A ref whose conditional
+   * branches say both `true` and `false` gives that key no preference: with
+   * `allErrors`, Ajv evaluates failing branches too, so neither value is that
+   * ref's answer and an earlier ref's stands.
+   */
+  async graphOutputPreferences(data, refs) {
+    const { [FILE_SCHEMA_KEY]: _omit, ...subject } = data;
+    void _omit;
+    const preferences = /* @__PURE__ */ new Map();
+    for (const ref of refs) {
+      const fn = await this.compile(ref);
+      const seen = /* @__PURE__ */ new Map();
+      graphOutputRecorder = seen;
+      try {
+        fn(subject);
+      } finally {
+        graphOutputRecorder = void 0;
+      }
+      for (const [key, values] of seen) {
+        const [value, ...others] = [...values];
+        if (value === void 0 || others.length > 0) continue;
+        preferences.set(key, value);
+      }
+    }
+    return preferences;
+  }
   /**
    * Validate `data` against every schema in `refs`. Returns all violations,
    * each tagged with the schema that produced it and a source line via
@@ -16114,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;
@@ -17990,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 = {
@@ -18378,7 +18806,7 @@ 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] ?? "");
@@ -18670,7 +19098,7 @@ 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] ?? "");
@@ -18803,7 +19231,7 @@ function parseJsonPointer(pointer) {
 // src/meta/commands/schemas.ts
 import { existsSync as existsSync4 } from "node:fs";
 import { mkdir as mkdir3, readFile as readFile11 } from "node:fs/promises";
-import { dirname as dirname10, extname as extname6, isAbsolute as isAbsolute10, join as join10, relative as relative15, resolve as resolve21, sep as sep10 } from "node:path";
+import { 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 {
@@ -18815,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;
@@ -19074,7 +19502,7 @@ 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;
@@ -19591,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];
@@ -22585,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(
@@ -23860,7 +24288,7 @@ async function mapConcurrent(items2, limit, fn) {
 
 // src/meta/commands/derive.ts
 import { readFile as readFile16 } from "node:fs/promises";
-import { extname as extname10, relative as relative16, resolve as resolve25, sep as sep12 } from "node:path";
+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) {
@@ -23978,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, resolve25(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.`
@@ -25255,6 +25683,13 @@ export {
   runIfMain,
   escapeWorkflowCommandMessage,
   escapeWorkflowCommandProperty,
+  collect,
+  splitList,
+  STDIN_REQUIRES_AS,
+  readStdin,
+  configOption,
+  explicitFalse,
+  reportConfig,
   INTEGRITY_SHAPE,
   integrityOf,
   isIntegrity,
@@ -25309,7 +25744,8 @@ export {
   schemaCacheDir,
   SchemaCache,
   __default31 as __default,
-  __default34 as __default2,
+  __default33 as __default2,
+  __default34 as __default3,
   listBuiltins,
   classifyRef,
   fetchSchemaBytes,
@@ -25333,8 +25769,10 @@ export {
   staleFindings,
   LEGACY_CONFIG_NAMES,
   parseConfig,
+  urlManifestMessage,
   schemaTrustRoot,
   loadConfig,
+  loadMetaSection,
   resolveRunConfig,
   renderSarif,
   renderJunit,
@@ -25360,6 +25798,7 @@ export {
   EXTERNAL_METADATA_FETCH_MAX_BYTES,
   fetchExternalMetadata,
   META_CONTEXT,
+  lazyKey,
   withValueAt,
   EXTERNAL_OWNED_SCHEMA,
   EXTERNAL_DUPLICATE_SCHEMA,
@@ -25381,8 +25820,10 @@ export {
   LOCATION_KEYWORD,
   LOCATION_EXTERNAL_SCHEMA,
   LOCATION_PAGE_SCHEMA,
+  GRAPH_OUTPUT_KEYWORD,
   Validator,
   pageMarks,
+  pageSchemaSet,
   marksValidator,
   configMarks,
   relocateFailed,
@@ -25454,4 +25895,4 @@ export {
   renderQuery,
   renderQueryCsv
 };
-//# sourceMappingURL=chunk-I57KBF45.js.map
+//# sourceMappingURL=chunk-TH565O2N.js.map