@hawkeyexl/manni 4.10.0 → 4.12.0

package/dist/chunk-2UJZXVHR.js

@@ -0,0 +1,1868 @@
+#!/usr/bin/env node
+import {
+  parserByName,
+  parserForExtension,
+  supportedExtensions,
+  unsupportedFormatMessage
+} from "./chunk-IZXN3WI6.js";
+import {
+  metaPageView
+} from "./chunk-JSSM7VVV.js";
+import {
+  DEFAULT_CHUNK_CHARS
+} from "./chunk-PS257NIU.js";
+import {
+  STDIN_REQUIRES_AS,
+  parseLines
+} from "./chunk-SMHAYK6I.js";
+import {
+  extractFrontmatter,
+  extractorForExtension
+} from "./chunk-RGLFV4KO.js";
+import {
+  findConfigFileSync,
+  parseCollections,
+  readConfigFileSync,
+  selectCollections
+} from "./chunk-OTJOBZJ5.js";
+import {
+  warn
+} from "./chunk-HX44GB4Z.js";
+import {
+  PROVIDERS_KEY,
+  assertKnownProvider,
+  parseProviders
+} from "./chunk-VM7VAFJW.js";
+import {
+  ToolError,
+  errorMessage
+} from "./chunk-G3T47CFV.js";
+
+// src/graph/types.ts
+var GraphError = class extends ToolError {
+  constructor(message) {
+    super(message);
+    this.name = "GraphError";
+  }
+};
+
+// src/graph/core/iri.ts
+import { slug as githubSlug } from "github-slugger";
+var DEFAULT_BASE_IRI = "urn:manni:graph:";
+function resolveBaseIri(base) {
+  if (!base) return DEFAULT_BASE_IRI;
+  if (base.endsWith("/") || base.endsWith(":")) return base;
+  return `${base}/`;
+}
+function normalizeDocPath(p) {
+  let out = p.replace(/\\/g, "/");
+  while (out.startsWith("./")) out = out.slice(2);
+  return out;
+}
+function encodeSegment(segment) {
+  return encodeURIComponent(segment).replace(
+    /[!'()*]/g,
+    (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+var STDIN_PATH = "<stdin>";
+function mintDocIri(base, relPath) {
+  if (relPath === STDIN_PATH) return `${base}stdin`;
+  const path = normalizeDocPath(relPath).split("/").map(encodeSegment).join("/");
+  return `${base}doc/${path}`;
+}
+function mintSectionIri(docIri, slugValue) {
+  return `${docIri}#${slugValue}`;
+}
+function conceptSlug(label) {
+  return githubSlug(label);
+}
+function mintConceptIri(base, label) {
+  return `${base}concept/${encodeSegment(conceptSlug(label))}`;
+}
+function mintTermConceptIri(base, id) {
+  return `${base}concept/${encodeSegment(id)}`;
+}
+function mintProductIri(base, label) {
+  return `${base}product/${encodeSegment(conceptSlug(label))}`;
+}
+function mintSchemeIri(base) {
+  return `${base}scheme`;
+}
+function mintAgentIri(base, kind, name) {
+  return `${base}agent/${kind}/${encodeSegment(conceptSlug(name))}`;
+}
+function mintGraphIri(base) {
+  return `${base}graph`;
+}
+function mintBuildActivityIri(base) {
+  return `${base}activity/build`;
+}
+
+// src/graph/core/vocab.ts
+var NS = {
+  dcterms: "http://purl.org/dc/terms/",
+  foaf: "http://xmlns.com/foaf/0.1/",
+  graph: "https://hawkeyexl.github.io/manni/graph/ns#",
+  iirds: "http://iirds.tekom.de/iirds#",
+  iirdsSft: "http://iirds.tekom.de/iirds/domain/software#",
+  prov: "http://www.w3.org/ns/prov#",
+  rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+  schema: "https://schema.org/",
+  skos: "http://www.w3.org/2004/02/skos/core#",
+  xsd: "http://www.w3.org/2001/XMLSchema#"
+};
+var PREFIXES = Object.entries(NS).sort(([a], [b]) => a < b ? -1 : 1);
+var RDF_TYPE = `${NS.rdf}type`;
+var ROLE = {
+  author: `${NS.graph}authorRole`,
+  generator: `${NS.graph}generatorRole`,
+  tool: `${NS.graph}toolRole`
+};
+
+// src/graph/core/config.ts
+import { dirname, resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { Ajv2020 } from "ajv/dist/2020.js";
+
+// src/graph/core/config-schema.json
+var config_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "manni:graph:config",
+  title: "manni graph configuration",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    provider: {
+      type: "string",
+      minLength: 1,
+      description: "Which provider `manni graph fill` sends pages to: auto | anthropic | openai | claude-cli | llama-cpp. Unset, the family's top-level providers.provider decides, then auto, detected exactly as manni meta fill detects: an Anthropic key, then an OpenAI key, then the Claude CLI, then a local model. --provider wins over it, and --local overrides both. Connection settings live in the family's top-level providers: map."
+    },
+    model: {
+      type: "string",
+      minLength: 1,
+      description: "The model, within the provider named beside it. A model is carried only to the provider its own level names: a differing --provider or providers.provider takes its own default instead. With no provider here, it goes to whichever provider is in force, which must not be auto, because a model name does not say which provider owns it. Unset (the default) takes the provider's default model from the inference library; manni pins none. --model wins over it. This is not `embed.model`, which is a local embedding model id."
+    },
+    baseIri: {
+      type: "string",
+      minLength: 1
+    },
+    out: {
+      type: "string",
+      minLength: 1
+    },
+    questionFiles: {
+      type: "array",
+      items: {
+        type: "string",
+        minLength: 1
+      },
+      description: "Golden-set files, relative to the config file. They hold questions that span pages or that the docs don't answer, and `check` asks them beside each page's sample-questions. Default none."
+    },
+    routes: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["root"],
+        properties: {
+          basePath: {
+            type: "string"
+          },
+          root: {
+            type: "string"
+          },
+          extensions: {
+            type: "array",
+            items: {
+              type: "string",
+              pattern: "^\\."
+            }
+          },
+          language: {
+            type: "string",
+            pattern: "^[A-Za-z]{2,3}(-[A-Za-z]{4})?(-([A-Za-z]{2}|[0-9]{3}))?(-([A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*$"
+          },
+          indexFiles: {
+            type: "array",
+            items: {
+              type: "string",
+              minLength: 1
+            }
+          }
+        }
+      }
+    },
+    build: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        derive: {
+          type: "array",
+          uniqueItems: true,
+          items: {
+            enum: [
+              "frontmatter",
+              "sections",
+              "links",
+              "tags",
+              "images",
+              "code",
+              "provenance",
+              "terms"
+            ]
+          }
+        }
+      }
+    },
+    check: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        shapes: {
+          type: "array",
+          items: {
+            type: "string",
+            minLength: 1
+          }
+        },
+        questions: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            top: {
+              type: "integer",
+              minimum: 1
+            },
+            severity: {
+              enum: ["notice", "warning", "error", "off"]
+            },
+            foundThreshold: {
+              anyOf: [
+                { type: "number", minimum: 0, maximum: 100 },
+                { type: "null" }
+              ],
+              description: "`check` exits 1 when the percentage of reviewed questions found in the top `top` falls below this, 0-100. The same scale as stats.coverageThreshold. Null (the default) sets no rate gate. questions.severity does not touch it."
+            }
+          }
+        }
+      }
+    },
+    provenance: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        qualified: {
+          type: "boolean"
+        }
+      }
+    },
+    stats: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        coverageThreshold: {
+          anyOf: [
+            {
+              type: "number",
+              minimum: 0,
+              maximum: 100
+            },
+            {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                title: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                description: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                creator: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                created: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                modified: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                subject: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                label: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                language: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                type: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                "applies-to": {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                "about-product-lifecycle": {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                "about-product-aspect": {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                "sample-questions": {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                }
+              }
+            }
+          ]
+        }
+      }
+    },
+    fill: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        temperature: {
+          type: "number",
+          minimum: 0,
+          maximum: 2
+        },
+        maxTurns: {
+          type: ["integer", "null"],
+          minimum: 1,
+          description: "Stop after this many inference calls. One page is one turn, and a cached proposal spends none. Null (the default) is unbounded. Replaces the maxCostUsd ceiling, which read as zero for every model outside the library's price table \u2014 see graph ADR 01027 and docevals ADR 01019."
+        },
+        cacheDir: {
+          type: "string",
+          minLength: 1
+        },
+        confidenceThreshold: {
+          type: "number",
+          minimum: 0,
+          maximum: 1,
+          description: "Minimum model self-confidence (0..1) to write a proposed field; below it the field is reported and not written. Default 0.7. `--confidence` wins over it."
+        },
+        writeProvenance: {
+          type: "boolean"
+        },
+        validateGraph: {
+          type: "boolean"
+        },
+        fields: {
+          type: "array",
+          uniqueItems: true,
+          items: {
+            enum: [
+              "label",
+              "alt-labels",
+              "broader",
+              "narrower",
+              "related-concepts",
+              "concepts",
+              "type",
+              "applies-to",
+              "about-product-lifecycle",
+              "about-product-aspect",
+              "not-applicable-to",
+              "not-about-product-aspect",
+              "sample-questions"
+            ]
+          }
+        },
+        sections: {
+          type: "boolean"
+        },
+        chunkChars: {
+          type: "integer",
+          minimum: 1,
+          description: "The largest body piece one question request sends. Default 12000, as meta fill's. `--chunk-chars` wins over it."
+        },
+        offline: {
+          type: "boolean",
+          description: "Send nothing off this machine: use only a local model that is already downloaded. Default false. `--offline` wins over it."
+        },
+        questions: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            perPage: {
+              type: "integer",
+              minimum: 1,
+              description: "Draft until a page has this many sample questions, reviewed or drafted. Default 3."
+            }
+          }
+        }
+      }
+    },
+    embed: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        model: {
+          type: "string",
+          minLength: 1
+        },
+        dtype: {
+          type: "string",
+          minLength: 1
+        },
+        out: {
+          type: "string",
+          minLength: 1
+        },
+        cacheDir: {
+          type: "string",
+          minLength: 1
+        },
+        byLanguage: {
+          type: "object",
+          additionalProperties: false,
+          patternProperties: {
+            "^[A-Za-z]{2,3}(-[A-Za-z]{4})?(-([A-Za-z]{2}|[0-9]{3}))?(-([A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*$": {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                model: {
+                  type: "string",
+                  minLength: 1
+                },
+                dtype: {
+                  type: "string",
+                  minLength: 1
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    export: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        iirds: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            title: {
+              type: "string",
+              minLength: 1
+            },
+            creator: {
+              type: "string",
+              minLength: 1
+            },
+            version: {
+              enum: ["1.2", "1.3"]
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/graph/core/iirds.ts
+var IIRDS_HAS_TOPIC_TYPE = `${NS.iirds}has-topic-type`;
+var IIRDS_RELATES_TO_PRODUCT_VARIANT = `${NS.iirds}relates-to-product-variant`;
+var IIRDS_RELATES_TO_LIFECYCLE_PHASE = `${NS.iirds}relates-to-product-lifecycle-phase`;
+var IIRDS_HAS_SUBJECT = `${NS.iirds}has-subject`;
+var IIRDS_PRODUCT_VARIANT = `${NS.iirds}ProductVariant`;
+var IIRDS_PACKAGE = `${NS.iirds}Package`;
+var IIRDS_IIRDS_VERSION = `${NS.iirds}iiRDSVersion`;
+var IIRDS_TOPIC = `${NS.iirds}Topic`;
+var IIRDS_IS_PART_OF_PACKAGE = `${NS.iirds}is-part-of-package`;
+var IIRDS_HAS_RENDITION = `${NS.iirds}has-rendition`;
+var IIRDS_RENDITION = `${NS.iirds}Rendition`;
+var IIRDS_SOURCE = `${NS.iirds}source`;
+var IIRDS_FORMAT = `${NS.iirds}format`;
+var IIRDS_TITLE = `${NS.iirds}title`;
+var IIRDS_LANGUAGE = `${NS.iirds}language`;
+var IIRDS_PARTY = `${NS.iirds}Party`;
+var IIRDS_HAS_PARTY_ROLE = `${NS.iirds}has-party-role`;
+var IIRDS_CREATOR = `${NS.iirds}Creator`;
+var IIRDS_RELATES_TO_PARTY = `${NS.iirds}relates-to-party`;
+var IIRDS_RELATES_TO_VCARD = `${NS.iirds}relates-to-vcard`;
+var VCARD_NS = "http://www.w3.org/2006/vcard/ns#";
+var VCARD_ORGANIZATION = `${VCARD_NS}Organization`;
+var VCARD_ORGANIZATION_NAME = `${VCARD_NS}organization-name`;
+var GRAPH_NOT_APPLICABLE_TO_VARIANT = `${NS.graph}notApplicableToVariant`;
+var GRAPH_NOT_SOFTWARE_SUBJECT = `${NS.graph}notSoftwareSubject`;
+var PAGE_TYPE_TO_TOPIC_TYPE = {
+  "how-to": "task",
+  tutorial: "learning",
+  explanation: "concept",
+  reference: "reference",
+  troubleshooting: "troubleshooting"
+};
+var TOPIC_TYPE_IRIS = {
+  task: `${NS.iirds}GenericTask`,
+  concept: `${NS.iirds}GenericConcept`,
+  reference: `${NS.iirds}GenericReference`,
+  learning: `${NS.iirds}GenericLearning`,
+  troubleshooting: `${NS.iirds}GenericTroubleshooting`,
+  form: `${NS.iirds}GenericForm`
+};
+var SOFTWARE_LIFECYCLE_IRIS = {
+  administration: `${NS.iirdsSft}Administration`,
+  customization: `${NS.iirdsSft}Customization`,
+  update: `${NS.iirdsSft}Update`,
+  deployment: `${NS.iirdsSft}Deployment`,
+  integration: `${NS.iirdsSft}Integration`,
+  deinstallation: `${NS.iirdsSft}Deinstallation`
+};
+var SOFTWARE_SUBJECT_IRIS = {
+  architecture: `${NS.iirdsSft}Architecture`,
+  interface: `${NS.iirdsSft}Interface`,
+  "system-requirement": `${NS.iirdsSft}SystemRequirement`
+};
+
+// src/graph/core/coverage.ts
+var COVERAGE_FIELDS = [
+  { field: "title", iri: `${NS.dcterms}title` },
+  { field: "description", iri: `${NS.dcterms}description` },
+  { field: "creator", iri: `${NS.dcterms}creator` },
+  { field: "created", iri: `${NS.dcterms}created` },
+  { field: "modified", iri: `${NS.dcterms}modified` },
+  { field: "subject", iri: `${NS.dcterms}subject` },
+  { field: "label", iri: `${NS.foaf}primaryTopic` },
+  // Dropped by ADR 01011 as "near-universally 0% noise", which was true on the
+  // monolingual corpora it was measured against and false the moment language
+  // means something. Restored by ADR 01037, which made it a scope dimension:
+  // an unlabelled document in a translated corpus cannot be filtered, indexed
+  // per locale, or counted against the right audience.
+  { field: "language", iri: `${NS.dcterms}language` },
+  // The iiRDS typing added in Phases 2–4. Coverage predates all of it, so the
+  // measure of "what a graph-side consumer can see" was silent about the
+  // vocabulary the project spent four phases adding (ADR 01029).
+  { field: "type", iri: IIRDS_HAS_TOPIC_TYPE },
+  { field: "applies-to", iri: IIRDS_RELATES_TO_PRODUCT_VARIANT },
+  {
+    field: "about-product-lifecycle",
+    iri: IIRDS_RELATES_TO_LIFECYCLE_PHASE
+  },
+  { field: "about-product-aspect", iri: IIRDS_HAS_SUBJECT },
+  // Pages with a reader question (proposal 0087). Gated only by name.
+  { field: "sample-questions", iri: `${NS.graph}sampleQuestion`, namedOnly: true }
+];
+var SECTION_FIELD_NAMES = [
+  "type",
+  "applies-to",
+  "about-product-lifecycle",
+  "about-product-aspect",
+  "subject"
+];
+var SECTION_COVERAGE_FIELDS = SECTION_FIELD_NAMES.map((name) => {
+  const field = COVERAGE_FIELDS.find((f) => f.field === name);
+  if (field === void 0) {
+    throw new Error(
+      `SECTION_FIELD_NAMES names ${name}, which COVERAGE_FIELDS does not define`
+    );
+  }
+  return field;
+});
+var COVERAGE_FIELD_NAMES = COVERAGE_FIELDS.map(
+  (f) => f.field
+);
+var UNIFORM_COVERAGE_FIELD_NAMES = COVERAGE_FIELDS.flatMap(
+  (f) => f.namedOnly ? [] : [f.field]
+);
+
+// src/graph/embed/types.ts
+var DEFAULT_PROFILE = {
+  id: "onnx-community/granite-embedding-small-english-r2-ONNX",
+  note: "Default. 384-d, 8192-token context so sections are never truncated; no prefixes."
+};
+var MODEL_PROFILES = [
+  DEFAULT_PROFILE,
+  {
+    id: "Xenova/gte-small",
+    note: "Lighter (~34 MB). 384-d, 512-token context; no prefixes."
+  },
+  {
+    id: "Xenova/bge-small-en-v1.5",
+    queryPrefix: "Represent this sentence for searching relevant passages: ",
+    note: "384-d. Needs a query prefix \u2014 applied automatically here, since omitting it degrades retrieval silently."
+  },
+  {
+    id: "Xenova/all-MiniLM-L6-v2",
+    note: "Smallest (~23 MB) but truncates at 256 wordpieces (~190 words), so long sections lose their tail."
+  }
+];
+var DEFAULT_MODEL = DEFAULT_PROFILE.id;
+function profileFor(id) {
+  return MODEL_PROFILES.find((p) => p.id === id) ?? { id };
+}
+function withPrefix(profile, role, text) {
+  const prefix = role === "query" ? profile.queryPrefix : profile.passagePrefix;
+  return prefix ? `${prefix}${text}` : text;
+}
+
+// src/graph/core/config.ts
+var ALL_FILL_FIELDS = [
+  "label",
+  "alt-labels",
+  "broader",
+  "narrower",
+  "related-concepts",
+  "concepts",
+  "type",
+  "applies-to",
+  "about-product-lifecycle",
+  "about-product-aspect",
+  "not-applicable-to",
+  "not-about-product-aspect",
+  "sample-questions"
+];
+var DEFAULT_CONFIG_FILENAME = "manni.config.yaml";
+var CONFIG_SECTION = "graph";
+var COLLECTIONS_KEY = "collections";
+var CONFIG_REF = "https://hawkeyexl.github.io/manni/meta/reference/configuration/";
+var MOVED_KEYS = ["inputs", "exclude"];
+var ALL_DERIVE_SOURCES = [
+  "frontmatter",
+  "sections",
+  "links",
+  "tags",
+  "images",
+  "code",
+  "provenance",
+  "terms"
+];
+var DEFAULT_LINK_EXTENSIONS = [
+  ".md",
+  ".mdx",
+  ".markdown",
+  ".html",
+  ".htm",
+  ".adoc",
+  ".asciidoc",
+  ".rst",
+  ".dita",
+  ".ditamap"
+];
+var DEFAULT_INDEX_FILES = ["index", "README"];
+function normalizeBasePath(basePath) {
+  let out = basePath.trim();
+  if (!out.startsWith("/")) out = `/${out}`;
+  out = out.replace(/\/+$/, "");
+  return out;
+}
+var ajv = new Ajv2020({ allErrors: true, allowUnionTypes: true });
+var validateConfig = ajv.compile(config_schema_default);
+function configErrorLine(e) {
+  const extra = e.keyword === "additionalProperties" ? e.params.additionalProperty : void 0;
+  const where = `/${CONFIG_SECTION}${e.instancePath}`;
+  return extra === void 0 ? `  ${where}: ${e.message ?? "is invalid"}` : `  ${where}: unknown key "${extra}"`;
+}
+function resolveCoverageThreshold(raw) {
+  if (raw == null) return {};
+  if (typeof raw === "number")
+    return Object.fromEntries(UNIFORM_COVERAGE_FIELD_NAMES.map((f) => [f, raw]));
+  return { ...raw };
+}
+function parseConfig(text, configPath) {
+  let raw;
+  try {
+    raw = parseYaml(text);
+  } catch (e) {
+    throw new GraphError(
+      `Invalid YAML in ${configPath}: ${errorMessage(e)}`
+    );
+  }
+  if (raw == null) return parseConfigSection(null, configPath);
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new GraphError(`Invalid config in ${configPath}: root must be an object`);
+  }
+  const doc = raw;
+  const wrapped = Object.hasOwn(doc, CONFIG_SECTION);
+  const toError = (message) => new GraphError(message);
+  const collections = Object.hasOwn(doc, COLLECTIONS_KEY) ? parseCollections(doc[COLLECTIONS_KEY], configPath, toError) : [];
+  const providers = Object.hasOwn(doc, PROVIDERS_KEY) ? parseProviders(
+    doc[PROVIDERS_KEY],
+    configPath,
+    dirname(resolve(configPath)),
+    toError
+  ) : {};
+  return parseConfigSection(wrapped ? doc[CONFIG_SECTION] : doc, configPath, {
+    source: configPath,
+    collections,
+    providers
+  });
+}
+function parseConfigSection(raw, configPath, file = { source: configPath, collections: [] }) {
+  if (raw == null) raw = {};
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new GraphError(
+      `Invalid config in ${configPath}: root must be an object`
+    );
+  }
+  for (const key of MOVED_KEYS) {
+    if (Object.hasOwn(raw, key)) {
+      throw new GraphError(
+        `${file.source}: "${key}" is no longer a graph key. Document sets are declared once for every tool, under a top-level collections: list. See ${CONFIG_REF}#${COLLECTIONS_KEY}`
+      );
+    }
+  }
+  if (!validateConfig(raw)) {
+    const details = (validateConfig.errors ?? []).map((e) => configErrorLine(e)).join("\n");
+    throw new GraphError(`Invalid config in ${configPath}:
+${details}`);
+  }
+  const r = raw;
+  const abs = resolve(configPath);
+  const dir = dirname(abs);
+  const provider = r.provider ?? null;
+  if (provider !== null) {
+    assertKnownProvider(provider, (message) => new GraphError(message));
+  }
+  return {
+    collections: file.collections,
+    configSource: file.source,
+    provider,
+    model: r.model ?? null,
+    providers: file.providers ?? {},
+    baseIri: resolveBaseIri(r.baseIri),
+    out: r.out ?? "graph/graph.ttl",
+    routes: (r.routes ?? []).map((m) => ({
+      basePath: normalizeBasePath(m.basePath ?? "/"),
+      root: m.root.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, ""),
+      extensions: m.extensions ?? [...DEFAULT_LINK_EXTENSIONS],
+      indexFiles: m.indexFiles ?? [...DEFAULT_INDEX_FILES],
+      ...m.language === void 0 ? {} : { language: m.language }
+    })),
+    questionFiles: r.questionFiles ?? [],
+    build: {
+      derive: r.build?.derive ?? [...ALL_DERIVE_SOURCES]
+    },
+    check: {
+      // Empty means: use the shapes bundled with manni (see bundledShapesPath).
+      shapes: r.check?.shapes ?? [],
+      questions: {
+        top: r.check?.questions?.top ?? 5,
+        severity: r.check?.questions?.severity ?? "warning",
+        foundThreshold: r.check?.questions?.foundThreshold ?? null
+      }
+    },
+    provenance: {
+      qualified: r.provenance?.qualified ?? true
+    },
+    stats: {
+      coverageThreshold: resolveCoverageThreshold(r.stats?.coverageThreshold)
+    },
+    fill: {
+      temperature: r.fill?.temperature ?? 0,
+      maxTurns: r.fill?.maxTurns ?? null,
+      cacheDir: r.fill?.cacheDir ?? ".manni/graph/cache",
+      fields: r.fill?.fields ?? [...ALL_FILL_FIELDS],
+      confidenceThreshold: r.fill?.confidenceThreshold ?? 0.7,
+      writeProvenance: r.fill?.writeProvenance ?? true,
+      validateGraph: r.fill?.validateGraph ?? true,
+      sections: r.fill?.sections ?? false,
+      chunkChars: r.fill?.chunkChars ?? DEFAULT_CHUNK_CHARS,
+      offline: r.fill?.offline ?? false,
+      questions: { perPage: r.fill?.questions?.perPage ?? 3 }
+    },
+    embed: {
+      model: r.embed?.model ?? DEFAULT_MODEL,
+      dtype: r.embed?.dtype ?? "q8",
+      out: r.embed?.out,
+      cacheDir: r.embed?.cacheDir ?? ".manni/graph/embed-cache",
+      byLanguage: r.embed?.byLanguage ?? {}
+    },
+    export: {
+      iirds: {
+        title: r.export?.iirds?.title,
+        creator: r.export?.iirds?.creator,
+        version: r.export?.iirds?.version ?? "1.3"
+      }
+    },
+    configPath: abs,
+    configDir: dir
+  };
+}
+var CONFIG_FILE = {
+  section: CONFIG_SECTION,
+  // The tool was `dockg` before it joined the family (proposal 0051 §7), but
+  // it published no config file under that old name, so — like cite, a11y and
+  // docevals — there is no pre-family filename to read (proposal 0051 §2).
+  legacyNames: [],
+  toError: (message) => new GraphError(message)
+};
+function loadConfig(path, cwd = process.cwd()) {
+  const file = path ? readConfigFileSync(path, cwd, CONFIG_FILE) : findConfigFileSync(cwd, CONFIG_FILE);
+  if (file === null) return defaultConfig(cwd);
+  return parseConfigSection(file.value, file.path, {
+    source: file.source,
+    collections: file.collections,
+    ...file.providers === void 0 ? {} : { providers: file.providers }
+  });
+}
+function defaultConfig(cwd = process.cwd()) {
+  return {
+    ...parseConfigSection(null, resolve(cwd, DEFAULT_CONFIG_FILENAME)),
+    configSource: null
+  };
+}
+function loadRunConfig(opts, cwd = process.cwd()) {
+  assertCollectionWithoutPaths(opts.collection, opts.paths);
+  return opts.noConfig ? defaultConfig(cwd) : loadConfig(opts.configPath, cwd);
+}
+function assertCollectionWithoutPaths(collection, paths) {
+  if ((collection ?? []).length > 0 && (paths ?? []).length > 0) {
+    throw new GraphError(
+      "--collection selects a configured collection; it cannot be combined with paths."
+    );
+  }
+}
+
+// src/graph/core/analyze.ts
+import { createHash } from "node:crypto";
+import { extname } from "node:path";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkGfm from "remark-gfm";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkMdx from "remark-mdx";
+import { toString as mdastToString } from "mdast-util-to-string";
+import GithubSlugger from "github-slugger";
+var DOC_FORMATS = [
+  "asciidoc",
+  "html",
+  "markdown",
+  "mdx",
+  "rst",
+  "xml"
+];
+function isTreeFormat(format) {
+  return format !== "markdown" && format !== "mdx";
+}
+function isDocFormat(name) {
+  return DOC_FORMATS.includes(name);
+}
+function formatOf(path, format) {
+  if (format !== void 0) return format;
+  const name = parserForExtension(extname(path))?.name;
+  return name !== void 0 && isDocFormat(name) ? name : "markdown";
+}
+var processor = unified().use(remarkParse).use(remarkGfm).use(remarkFrontmatter, ["yaml", "toml"]);
+var mdxProcessor = unified().use(remarkParse).use(remarkGfm).use(remarkFrontmatter, ["yaml", "toml"]).use(remarkMdx);
+var IMAGE_ELEMENTS = /* @__PURE__ */ new Set(["img", "image"]);
+function jsxAttributeValue(node, attributeName) {
+  const attributes = node.attributes;
+  if (!Array.isArray(attributes)) return void 0;
+  for (const attribute of attributes) {
+    if (attribute.type !== "mdxJsxAttribute") continue;
+    if (attribute.name !== attributeName) continue;
+    return typeof attribute.value === "string" ? attribute.value : void 0;
+  }
+  return void 0;
+}
+function hasScheme(target) {
+  return /^[a-z][a-z0-9+.-]*:/i.test(target);
+}
+function resolveRelative(docPath, target) {
+  const baseSegments = normalizeDocPath(docPath).split("/").slice(0, -1);
+  const segments = [...baseSegments];
+  for (const part of target.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      if (segments.length === 0) return null;
+      if (segments[segments.length - 1] === "..") segments.push("..");
+      else segments.pop();
+    } else {
+      segments.push(part);
+    }
+  }
+  return segments.join("/");
+}
+var HAS_EXTENSION = /\.[a-z0-9]+$/i;
+function addressesDocument(target, extensions) {
+  if (target === "" || !HAS_EXTENSION.test(target)) return true;
+  if (extensions.length === 0) return true;
+  const ext = target.slice(target.lastIndexOf(".")).toLowerCase();
+  return extensions.some((e) => e.toLowerCase() === ext);
+}
+function slugNorm(path) {
+  return path.toLowerCase().replace(/[-_]/g, "");
+}
+var PathIndex = class {
+  constructor(exact) {
+    this.exact = exact;
+    for (const path of exact) {
+      const lower = path.toLowerCase();
+      this.lower.set(lower, this.lower.has(lower) ? null : path);
+      const slug = slugNorm(path);
+      this.slugged.set(slug, this.slugged.has(slug) ? null : path);
+    }
+  }
+  exact;
+  lower = /* @__PURE__ */ new Map();
+  slugged = /* @__PURE__ */ new Map();
+  resolve(candidate) {
+    if (this.exact.has(candidate)) return candidate;
+    return this.lower.get(candidate.toLowerCase()) ?? this.slugged.get(slugNorm(candidate)) ?? void 0;
+  }
+};
+function safeDecode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function targetCandidates(target, isDirectory, extensions, indexFiles) {
+  if (target !== "" && HAS_EXTENSION.test(target)) return [target];
+  const extensionCandidates = target === "" ? [] : extensions.map((ext) => `${target}${ext}`);
+  const dir = target === "" ? "" : `${target}/`;
+  const indexCandidates = [];
+  for (const indexFile of indexFiles) {
+    for (const ext of extensions)
+      indexCandidates.push(`${dir}${indexFile}${ext}`);
+  }
+  return isDirectory ? [...indexCandidates, ...extensionCandidates] : [...extensionCandidates, ...indexCandidates];
+}
+function routeLanguageFor(path, routes) {
+  let best;
+  for (const mapping of routes) {
+    if (mapping.language === void 0) continue;
+    const root = mapping.root;
+    const covers = root === "" || path === root || path.startsWith(`${root}/`);
+    if (!covers) continue;
+    if (best === void 0 || root.length > best.root.length) {
+      best = { root, language: mapping.language };
+    }
+  }
+  return best?.language;
+}
+function resolveRoute(pathPart, routes, index) {
+  const isDirectory = /\/+$/.test(pathPart);
+  const clean = safeDecode(pathPart).replace(/\/+$/, "");
+  let anyMatched = false;
+  for (const mapping of routes) {
+    if (clean !== mapping.basePath && !clean.startsWith(`${mapping.basePath}/`)) {
+      continue;
+    }
+    const rest = clean.slice(mapping.basePath.length).replace(/^\/+/, "");
+    if (!addressesDocument(rest, mapping.extensions)) continue;
+    anyMatched = true;
+    const prefix = mapping.root ? `${mapping.root}/` : "";
+    const stem = rest === "" ? mapping.root : `${prefix}${rest}`;
+    const candidates = targetCandidates(
+      stem,
+      isDirectory || rest === "",
+      mapping.extensions,
+      mapping.indexFiles
+    );
+    for (const candidate of candidates) {
+      const resolved = index.resolve(candidate);
+      if (resolved) return resolved;
+    }
+  }
+  return anyMatched ? "broken" : null;
+}
+var indexCache = /* @__PURE__ */ new WeakMap();
+function pathIndexFor(allPaths) {
+  let index = indexCache.get(allPaths);
+  if (!index) {
+    index = new PathIndex(allPaths);
+    indexCache.set(allPaths, index);
+  }
+  return index;
+}
+function classifyLink(docPath, rawTarget, allPaths, routes) {
+  const raw = rawTarget;
+  if (hasScheme(raw)) {
+    try {
+      return { raw, kind: "external", url: new URL(raw).href };
+    } catch {
+      return null;
+    }
+  }
+  const hashAt = raw.indexOf("#");
+  const pathPart = hashAt === -1 ? raw : raw.slice(0, hashAt);
+  const anchor = hashAt === -1 ? void 0 : raw.slice(hashAt + 1);
+  if (pathPart === "") return null;
+  if (pathPart.startsWith("/")) {
+    const resolved2 = resolveRoute(pathPart, routes, pathIndexFor(allPaths));
+    if (resolved2 === null) return null;
+    if (resolved2 === "broken") return { raw, kind: "broken" };
+    const link = { raw, kind: "internal", resolvedPath: resolved2 };
+    if (anchor) link.anchor = anchor;
+    return link;
+  }
+  const resolved = resolveRelative(docPath, safeDecode(pathPart));
+  if (resolved !== null) {
+    const index = pathIndexFor(allPaths);
+    let candidates;
+    if (allPaths.has(resolved)) {
+      candidates = [resolved];
+    } else if (HAS_EXTENSION.test(resolved)) {
+      if (!addressesDocument(resolved, DEFAULT_LINK_EXTENSIONS)) return null;
+      candidates = [];
+    } else {
+      candidates = targetCandidates(
+        resolved,
+        pathPart.endsWith("/"),
+        DEFAULT_LINK_EXTENSIONS,
+        DEFAULT_INDEX_FILES
+      );
+    }
+    for (const candidate of candidates) {
+      const hit = index.resolve(candidate);
+      if (hit) {
+        const link = { raw, kind: "internal", resolvedPath: hit };
+        if (anchor) link.anchor = anchor;
+        return link;
+      }
+    }
+  }
+  return { raw, kind: "broken" };
+}
+function classifyImage(docPath, rawTarget) {
+  if (hasScheme(rawTarget)) {
+    return { raw: rawTarget, target: rawTarget, external: true };
+  }
+  const resolved = resolveRelative(docPath, rawTarget);
+  return { raw: rawTarget, target: resolved ?? rawTarget, external: false };
+}
+function extractorFor(format) {
+  return extractorForExtension(parserByName(format)?.extensions[0] ?? "");
+}
+function metadataOf(content, path, format) {
+  try {
+    const meta = format === "markdown" || format === "mdx" ? extractFrontmatter(content, "markdown") : extractorFor(format)?.extract(content, path);
+    return meta === void 0 ? { data: {}, present: false } : { data: meta.data, present: meta.present };
+  } catch (error) {
+    throw new GraphError(`${path}: ${errorMessage(error)}`);
+  }
+}
+function analyzeDoc(content, relPath, allPaths, options = {}) {
+  const routes = options.routes ?? [];
+  const path = normalizeDocPath(relPath);
+  const format = formatOf(path, options.format);
+  const parse = options.parse ?? parseBody;
+  let body = isTreeFormat(format) ? parse(content, path, format) : void 0;
+  const meta = metadataOf(content, path, format);
+  body ??= parse(content, path, format);
+  const links = [];
+  for (const target of body.linkTargets) {
+    const link = classifyLink(path, target, allPaths, routes);
+    if (link) links.push(link);
+  }
+  const routeLanguage = routeLanguageFor(path, routes);
+  return {
+    path,
+    frontmatter: meta.data,
+    frontmatterPresent: meta.present,
+    format,
+    firstH1: body.firstH1,
+    sections: body.sections,
+    links,
+    images: body.imageTargets.map((target) => classifyImage(path, target)),
+    codeLanguages: body.codeLanguages,
+    // Omitted rather than set to undefined, so a doc under no localized route
+    // carries no key at all — `routeLanguage` in JSON output means something.
+    ...routeLanguage === void 0 ? {} : { routeLanguage },
+    // Over the content as read — line endings included, so the digest is
+    // byte-faithful and equals `sha256sum <file>` for any valid-UTF-8 file
+    // (ADR 01036). The CRLF corpus fixture depends on this not normalizing.
+    contentHash: createHash("sha256").update(content, "utf8").digest("hex")
+  };
+}
+function parseBody(content, path, format) {
+  if (isTreeFormat(format)) return parseTreeBody(content, path, format);
+  const isMdx = format === "mdx";
+  let tree;
+  try {
+    tree = (isMdx ? mdxProcessor : processor).parse(content);
+  } catch (error) {
+    if (!isMdx) throw error;
+    const reason = errorMessage(error);
+    throw new GraphError(`Could not parse MDX in ${path}: ${reason}`);
+  }
+  const sections = [];
+  const linkTargets = [];
+  const imageTargets = [];
+  const codeLanguages = /* @__PURE__ */ new Set();
+  const definitions = /* @__PURE__ */ new Map();
+  let firstH1;
+  visit(tree, (node) => {
+    if (node.type === "definition") {
+      const def = node;
+      definitions.set(def.identifier, def);
+    }
+  });
+  const slugger = new GithubSlugger();
+  const stack = [];
+  const childCount = /* @__PURE__ */ new Map();
+  visit(tree, (node) => {
+    switch (node.type) {
+      case "heading": {
+        const level = node.depth;
+        const title = mdastToString(node);
+        const slug = slugger.slug(title);
+        if (level === 1 && firstH1 === void 0) firstH1 = title;
+        for (let top = stack.at(-1); top !== void 0 && top.level >= level; top = stack.at(-1)) {
+          stack.pop();
+        }
+        const parentSlug = stack.at(-1)?.slug ?? null;
+        const parentKey = parentSlug ?? "";
+        const order = (childCount.get(parentKey) ?? 0) + 1;
+        childCount.set(parentKey, order);
+        sections.push({ slug, title, level, order, parentSlug });
+        stack.push({ level, slug });
+        break;
+      }
+      case "link": {
+        linkTargets.push(node.url);
+        break;
+      }
+      case "linkReference": {
+        const def = definitions.get(
+          node.identifier
+        );
+        if (def) linkTargets.push(def.url);
+        break;
+      }
+      case "image": {
+        imageTargets.push(node.url);
+        break;
+      }
+      case "imageReference": {
+        const def = definitions.get(
+          node.identifier
+        );
+        if (def) imageTargets.push(def.url);
+        break;
+      }
+      case "code": {
+        const lang = node.lang;
+        if (lang) codeLanguages.add(lang);
+        break;
+      }
+      // A JSX element's `href` is a link and its `src` is an image, on any
+      // element (ADR 01022). Those are HTML's own names for the relationships,
+      // so this stays structural — dockg never learns what `<LinkCard>` means.
+      case "mdxJsxFlowElement":
+      case "mdxJsxTextElement": {
+        const href = jsxAttributeValue(node, "href");
+        if (href !== void 0) linkTargets.push(href);
+        const name = node.name ?? "";
+        if (IMAGE_ELEMENTS.has(name.toLowerCase())) {
+          const src = jsxAttributeValue(node, "src");
+          if (src !== void 0) imageTargets.push(src);
+        }
+        break;
+      }
+    }
+  });
+  return {
+    firstH1,
+    sections,
+    linkTargets,
+    imageTargets,
+    codeLanguages: [...codeLanguages].sort()
+  };
+}
+function parseTree(content, path, format) {
+  const parser = parserByName(format);
+  if (parser === void 0) {
+    throw new GraphError(`No parser reads ${format}.`);
+  }
+  try {
+    return parser.parse(content, path);
+  } catch (error) {
+    throw new GraphError(
+      `Could not parse ${format} in ${path}: ${errorMessage(error)}`
+    );
+  }
+}
+var IRI_SAFE_ID = /^[A-Za-z_][A-Za-z0-9_.:-]*$/;
+function mintTreeSections(roots) {
+  const out = {
+    sections: [],
+    owned: [],
+    nodes: [],
+    unowned: [],
+    firstH1: void 0
+  };
+  const slugger = new GithubSlugger();
+  const taken = /* @__PURE__ */ new Set();
+  const childCount = /* @__PURE__ */ new Map();
+  const anchorFor = (node) => {
+    const id = node.id;
+    if (id !== void 0 && IRI_SAFE_ID.test(id) && !id.startsWith("prov.")) {
+      let anchor2 = id;
+      for (let n = 1; taken.has(anchor2); n++) anchor2 = `${id}-${String(n)}`;
+      taken.add(anchor2);
+      return anchor2;
+    }
+    let anchor = slugger.slug(node.title);
+    while (taken.has(anchor)) anchor = slugger.slug(node.title);
+    taken.add(anchor);
+    return anchor;
+  };
+  const walk = (nodes, parentSlug) => {
+    for (const node of nodes) {
+      if (node.level === 0 || node.synthetic || node.title.trim() === "") {
+        out.unowned.push(...node.children);
+        walk(node.sections, parentSlug);
+        continue;
+      }
+      const slug = anchorFor(node);
+      if (node.level === 1 && out.firstH1 === void 0) {
+        out.firstH1 = node.title;
+      }
+      const parentKey = parentSlug ?? "";
+      const order = (childCount.get(parentKey) ?? 0) + 1;
+      childCount.set(parentKey, order);
+      out.sections.push({
+        slug,
+        title: node.title,
+        level: node.level,
+        order,
+        parentSlug
+      });
+      out.owned.push(node.children);
+      out.nodes.push(node);
+      walk(node.sections, slug);
+    }
+  };
+  walk(roots, null);
+  return out;
+}
+function eachContent(nodes, fn) {
+  for (const node of nodes) {
+    fn(node);
+    switch (node.kind) {
+      case "list":
+        for (const item of node.items) eachContent(item.children, fn);
+        break;
+      case "table":
+        for (const row of node.children) {
+          for (const cell of row.children) eachContent(cell.children, fn);
+        }
+        break;
+      case "definitionList":
+        for (const item of node.children) eachContent(item.definition, fn);
+        break;
+      case "admonition":
+      case "blockquote":
+      case "element":
+        eachContent(node.children, fn);
+        break;
+      default:
+        break;
+    }
+  }
+}
+function treeContent(sections) {
+  return sections.flatMap((s) => [...s.children, ...treeContent(s.sections)]);
+}
+function parseTreeBody(content, path, format) {
+  const tree = parseTree(content, path, format);
+  const minted = mintTreeSections(tree.sections);
+  const imageTargets = [];
+  const codeLanguages = /* @__PURE__ */ new Set();
+  eachContent(treeContent(tree.sections), (node) => {
+    if (node.kind === "image") imageTargets.push(node.url);
+    else if (node.kind === "codeBlock" && node.language) {
+      codeLanguages.add(node.language);
+    }
+  });
+  return {
+    ...minted.firstH1 === void 0 ? {} : { firstH1: minted.firstH1 },
+    sections: minted.sections,
+    linkTargets: tree.links.map((l) => l.target),
+    imageTargets,
+    codeLanguages: [...codeLanguages].sort()
+  };
+}
+function visit(node, fn) {
+  const children = node.children;
+  if (!children) return;
+  for (const child of children) {
+    fn(child);
+    visit(child, fn);
+  }
+}
+
+// src/graph/core/discover.ts
+import { statSync } from "node:fs";
+import { extname as extname2, relative, resolve as resolve2 } from "node:path";
+import fg from "fast-glob";
+
+// src/graph/core/sort.ts
+function byCodeUnit(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// src/graph/core/discover.ts
+function discoverFiles(inputs, exclude, cwd) {
+  const matches = fg.sync(inputs, {
+    cwd,
+    ignore: exclude,
+    onlyFiles: true,
+    dot: false,
+    unique: true
+  });
+  return [...new Set(matches.map((m) => m.replace(/\\/g, "/")))].sort(
+    byCodeUnit
+  );
+}
+var FAMILY_EXCLUDE = ["**/node_modules/**", "**/.git/**"];
+var DEFAULT_EXTENSIONS = supportedExtensions();
+var STDIN = "-";
+function assertInputFormat(paths, as) {
+  if (as === void 0) {
+    if (paths.includes(STDIN)) throw new GraphError(STDIN_REQUIRES_AS);
+    return void 0;
+  }
+  if (!isDocFormat(as)) {
+    throw new GraphError(
+      `Unknown format "${as}". Known formats: ${DOC_FORMATS.join(", ")}.`
+    );
+  }
+  return as;
+}
+function expandInputs(inputs, base, ignore) {
+  const named = [];
+  const patterns = [];
+  for (const input of inputs) {
+    if (fg.isDynamicPattern(input)) {
+      patterns.push(input.replace(/\\/g, "/"));
+      continue;
+    }
+    let isDirectory;
+    try {
+      isDirectory = statSync(resolve2(base, input)).isDirectory();
+    } catch {
+      patterns.push(input.replace(/\\/g, "/"));
+      continue;
+    }
+    const literal = fg.convertPathToPattern(input);
+    if (isDirectory) patterns.push(`${literal.replace(/\/$/, "")}/**/*`);
+    else named.push(...glob([literal], base, ignore));
+  }
+  return { named, walked: glob(patterns, base, ignore) };
+}
+function glob(patterns, base, ignore) {
+  if (patterns.length === 0) return [];
+  return fg.sync(patterns, {
+    cwd: base,
+    ignore,
+    absolute: true,
+    dot: false,
+    onlyFiles: true
+  });
+}
+function normalizeExtensions(exts) {
+  return new Set(
+    exts.map((e) => {
+      const lower = e.toLowerCase();
+      return lower.startsWith(".") ? lower : `.${lower}`;
+    })
+  );
+}
+function resolveDocumentSet(config, options = {}, verb = "build", cwd = process.cwd(), base = documentBase(config, options, cwd)) {
+  const paths = options.paths ?? [];
+  const wanted = options.collection ?? [];
+  assertCollectionWithoutPaths(wanted, paths);
+  const format = assertInputFormat(paths, options.as);
+  if (wanted.length > 0 && config.configSource === null) {
+    throw new GraphError("--collection needs a config file to select from.");
+  }
+  const collections = selectCollections(
+    config.collections,
+    wanted,
+    config.configSource ?? DEFAULT_CONFIG_FILENAME,
+    (message) => new GraphError(message)
+  );
+  const exclude = [...FAMILY_EXCLUDE, ...options.exclude ?? []];
+  let named = [];
+  let walked;
+  if (paths.length > 0) {
+    ({ named, walked } = expandInputs(
+      paths.filter((p) => p !== STDIN),
+      cwd,
+      exclude
+    ));
+  } else {
+    const patterns = collections.flatMap((c) => c.paths);
+    if (patterns.length === 0) {
+      throw new GraphError(
+        `No files to ${verb}. Pass paths/globs, or declare a collection under \`collections:\` in manni.config.yaml.`
+      );
+    }
+    walked = collections.flatMap((c) => {
+      const found = expandInputs(c.paths, config.configDir, [
+        ...exclude,
+        ...c.exclude
+      ]);
+      return [...found.named, ...found.walked];
+    });
+  }
+  const exts = normalizeExtensions(options.ext ?? DEFAULT_EXTENSIONS);
+  const keepNamed = (p) => {
+    const ext = extname2(p);
+    if (format !== void 0 || parserForExtension(ext) !== void 0) {
+      return true;
+    }
+    const label = relative(base, p).replace(/\\/g, "/");
+    warn(`skipped ${label}: ${unsupportedFormatMessage(ext || label)}`);
+    return false;
+  };
+  const keepWalked = (p) => exts.has(extname2(p).toLowerCase());
+  return [
+    ...new Set(
+      [...named.filter(keepNamed), ...walked.filter(keepWalked)].map(
+        (p) => relative(base, p).replace(/\\/g, "/")
+      )
+    )
+  ].sort(byCodeUnit);
+}
+function documentBase(config, options = {}, cwd = process.cwd()) {
+  const typed = (options.paths ?? []).length > 0;
+  return typed || config.collections.length === 0 ? cwd : config.configDir;
+}
+function routesFrom(config, base) {
+  return config.routes.map((m) => ({
+    ...m,
+    root: relative(base, resolve2(config.configDir, m.root)).replace(/\\/g, "/")
+  }));
+}
+function documentSetPatterns(config, options = {}) {
+  const paths = options.paths ?? [];
+  if (paths.length > 0) return paths;
+  return selectCollections(
+    config.collections,
+    options.collection ?? [],
+    config.configSource ?? DEFAULT_CONFIG_FILENAME,
+    (message) => new GraphError(message)
+  ).flatMap((c) => c.paths);
+}
+
+// src/graph/core/external.ts
+import { resolve as resolve3 } from "node:path";
+async function openMetaView(source, cwd, paths, base = cwd) {
+  try {
+    return await metaPageView({
+      cwd: base,
+      ...source.configPath === void 0 ? {} : { configPath: resolve3(cwd, source.configPath) },
+      ...source.noConfig === void 0 ? {} : { noConfig: source.noConfig },
+      pages: paths.filter((p) => p !== STDIN_PATH).map((p) => resolve3(base, p))
+    });
+  } catch (e) {
+    throw new GraphError(errorMessage(e));
+  }
+}
+function pointerOf(key) {
+  return `/${key.replace(/~/g, "~0").replace(/\//g, "~1")}`;
+}
+async function mergePage(view, path, frontmatter, present, format) {
+  let merged;
+  try {
+    merged = await view.merge(path, {
+      data: frontmatter,
+      present,
+      format,
+      lineFor: () => void 0
+    });
+  } catch (e) {
+    throw new GraphError(errorMessage(e));
+  }
+  const data = merged.extracted.data;
+  const supplied = {};
+  for (const key of Object.keys(data)) {
+    if (merged.locate(pointerOf(key)) !== void 0) supplied[key] = data[key];
+  }
+  return { data, supplied };
+}
+async function withExternalMetadata(docs, view) {
+  const out = [];
+  for (const doc of docs) {
+    const { data } = await mergePage(
+      view,
+      doc.path,
+      doc.frontmatter,
+      doc.frontmatterPresent,
+      doc.format
+    );
+    out.push(data === doc.frontmatter ? doc : { ...doc, frontmatter: data });
+  }
+  return out;
+}
+
+// src/graph/core/localizations.ts
+var LOCALIZATIONS_FILENAME = "localizations.json";
+var UNDETERMINED = "und";
+var LANGUAGE_TAG = /^[A-Za-z]{2,3}(-[A-Za-z]{4})?(-([A-Za-z]{2}|[0-9]{3}))?(-([A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*$/;
+function isLanguageTag(value) {
+  return LANGUAGE_TAG.test(value);
+}
+function canonicalLanguageTag(tag) {
+  try {
+    return Intl.getCanonicalLocales(tag)[0] ?? tag;
+  } catch {
+    return tag;
+  }
+}
+function searchIndexFilename(language) {
+  return `search.${language}.json`;
+}
+function vectorIndexFilename(language) {
+  return `vectors.${language}.bin`;
+}
+function emitLocalizations(doc) {
+  const languages = [...doc.languages].sort(
+    (a, b) => byCodeUnit(a.language, b.language)
+  );
+  return `${JSON.stringify({ version: doc.version, languages }, null, 2)}
+`;
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function parseLocalizations(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed)) return void 0;
+  if (parsed["version"] !== 1 || !Array.isArray(parsed["languages"])) {
+    return void 0;
+  }
+  for (const entry of parsed["languages"]) {
+    if (!isRecord(entry)) return void 0;
+    const language = entry["language"];
+    const search = entry["search"];
+    if (typeof language !== "string" || !isLanguageTag(language) || typeof entry["documents"] !== "number" || !isRecord(search) || typeof search["path"] !== "string" || typeof search["entries"] !== "number" || typeof search["digest"] !== "string" || !ownsFilename(search["path"], searchIndexFilename(language))) {
+      return void 0;
+    }
+    const v = entry["vectors"];
+    if (v !== void 0) {
+      if (!isRecord(v) || typeof v["path"] !== "string" || typeof v["model"] !== "string" || typeof v["dtype"] !== "string" || typeof v["dims"] !== "number" || typeof v["count"] !== "number" || // Same constraint `search.path` gets: the last segment must be the
+      // filename this language's sidecar would be given. Without it,
+      // `isSafeRelativePath` alone leaves `vectors.path` far more reachable
+      // than `search.path` — and `search --mode vector` opens it.
+      !ownsFilename(v["path"], vectorIndexFilename(language))) {
+        return void 0;
+      }
+    }
+  }
+  return parsed;
+}
+function isSafeRelativePath(path) {
+  if (path === "" || path.startsWith("/") || /^[A-Za-z]:/.test(path)) {
+    return false;
+  }
+  if (path.includes("\\")) return false;
+  const segments = path.split("/");
+  let leading = true;
+  for (const segment of segments) {
+    if (segment === "" || segment === ".") return false;
+    if (segment === "..") {
+      if (!leading) return false;
+      continue;
+    }
+    leading = false;
+  }
+  return true;
+}
+function ownsFilename(path, expected) {
+  if (!isSafeRelativePath(path)) return false;
+  return path.slice(path.lastIndexOf("/") + 1) === expected;
+}
+
+// src/graph/core/questions.ts
+import { existsSync, readFileSync } from "node:fs";
+import { Ajv2020 as Ajv20202 } from "ajv/dist/2020.js";
+import { isNode, isSeq, LineCounter, parseDocument } from "yaml";
+
+// src/graph/core/questions-schema.json
+var questions_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "manni:graph:questions",
+  title: "manni graph golden-set file",
+  description: "A list of reader questions that span pages or that the docs don't answer (proposal 0087). Each item is a page sample question's object form, plus `answers[].file` and `language`. `graph.questionFiles` names the files, and `manni graph check` asks their questions.",
+  type: "array",
+  items: {
+    type: "object",
+    additionalProperties: false,
+    required: ["question", "answers"],
+    properties: {
+      question: {
+        type: "string",
+        minLength: 1,
+        description: "The question, as a reader would ask it."
+      },
+      answers: {
+        type: "array",
+        items: {
+          type: "object",
+          additionalProperties: false,
+          required: ["file", "lines"],
+          properties: {
+            file: {
+              type: "string",
+              minLength: 1,
+              description: "The page that holds this answer, relative to the config file."
+            },
+            lines: {
+              oneOf: [
+                { type: "integer", minimum: 1 },
+                { type: "string", pattern: "^[1-9][0-9]*-[1-9][0-9]*$" }
+              ],
+              description: "Body lines of that page, counted as for a citation's claim."
+            },
+            integrity: {
+              type: "string",
+              pattern: "^sha256-[0-9a-f]{64}$",
+              description: "The pin over those lines, under cite's hashing rule. Without it, the lines are not checked for change."
+            },
+            reviewed: {
+              type: "boolean",
+              description: "`false` marks a pin nobody has confirmed. Absent means `true`."
+            }
+          }
+        },
+        description: "The lines that answer the question, on one page or several. An empty list marks a known gap: a question the docs don't answer."
+      },
+      language: {
+        type: "string",
+        pattern: "^[A-Za-z]{2,3}(-[A-Za-z]{4})?(-([A-Za-z]{2}|[0-9]{3}))?(-([A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*$",
+        description: "The question's language, as a BCP-47 tag. Absent, it is the first answer's page language."
+      },
+      "generated-by": {
+        type: "string",
+        minLength: 1,
+        description: "The model that drafted the question or any of its pins, as `provider/model`."
+      },
+      confidence: {
+        type: "number",
+        minimum: 0,
+        maximum: 1,
+        description: "The drafting model's confidence, 0..1."
+      },
+      reviewed: {
+        type: "boolean",
+        description: "`false` marks a drafted question, and its pins are drafts with it. Absent means `true`."
+      },
+      "reviewed-by": {
+        type: "string",
+        minLength: 1,
+        description: "Who confirmed the question. An optional record."
+      }
+    }
+  }
+};
+
+// src/graph/core/questions.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readPin(value) {
+  if (!isRecord2(value)) return void 0;
+  const spec = value.lines;
+  const lines = typeof spec === "number" || typeof spec === "string" ? parseLines(spec) : void 0;
+  if (lines === void 0) return void 0;
+  const integrity = value.integrity;
+  return {
+    lines,
+    ...typeof integrity === "string" ? { integrity } : {},
+    reviewed: value.reviewed !== false
+  };
+}
+function readItem(item) {
+  if (typeof item === "string") {
+    return item === "" ? void 0 : { question: item, answers: [], reviewed: true };
+  }
+  if (!isRecord2(item) || typeof item.question !== "string") return void 0;
+  const question = item.question;
+  if (question === "") return void 0;
+  const answers = Array.isArray(item.answers) ? item.answers.flatMap((a) => readPin(a) ?? []) : [];
+  return { question, answers, reviewed: item.reviewed !== false };
+}
+function readSampleQuestions(value) {
+  const items = Array.isArray(value) ? value : value === void 0 ? [] : [value];
+  return items.flatMap((item) => readItem(item) ?? []);
+}
+var validateFile;
+function readQuestionFile(abs, label, text) {
+  if (text === void 0 && !existsSync(abs)) {
+    throw new GraphError(`graph.questionFiles names ${label}, which does not exist.`);
+  }
+  const counter = new LineCounter();
+  const doc = parseDocument(text ?? readFileSync(abs, "utf8"), { lineCounter: counter });
+  const [error] = doc.errors;
+  if (error) throw new GraphError(`${label}: ${error.message}`);
+  const value = doc.toJS() ?? [];
+  validateFile ??= new Ajv20202({ allowUnionTypes: true }).compile(questions_schema_default);
+  if (!validateFile(value) || !Array.isArray(value)) {
+    const [first] = validateFile.errors ?? [];
+    const where = [first?.instancePath, first?.message ?? "is invalid"].filter(Boolean).join(" ");
+    throw new GraphError(`${label}: ${where}.`);
+  }
+  const nodes = isSeq(doc.contents) ? doc.contents.items : [];
+  return value.flatMap((item, n) => {
+    if (!isRecord2(item) || typeof item.question !== "string") return [];
+    const node = nodes[n];
+    const offset = isNode(node) ? node.range[0] : void 0;
+    const answers = Array.isArray(item.answers) ? item.answers.flatMap((a) => {
+      const pin = readPin(a);
+      return pin && isRecord2(a) && typeof a.file === "string" ? [{ ...pin, file: a.file }] : [];
+    }) : [];
+    return [
+      {
+        question: item.question,
+        answers,
+        reviewed: item.reviewed !== false,
+        ...typeof item.language === "string" ? { language: item.language } : {},
+        line: offset === void 0 ? 1 : counter.linePos(offset).line
+      }
+    ];
+  });
+}
+function questionKey(question) {
+  return question.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, "").replace(/\s+/gu, " ").trim();
+}
+var COPIED_SHARE = 0.5;
+function copiedPairs(question, ...answers) {
+  const words = (text) => text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+  const pairs = (list) => list.slice(1).map((w, i) => `${list[i] ?? ""} ${w}`);
+  const asked = pairs(words(question));
+  if (asked.length === 0) return void 0;
+  const said = new Set(answers.flatMap((a) => pairs(words(a))));
+  return { copied: asked.filter((p) => said.has(p)).length, of: asked.length };
+}
+
+export {
+  GraphError,
+  resolveBaseIri,
+  normalizeDocPath,
+  encodeSegment,
+  STDIN_PATH,
+  mintDocIri,
+  mintSectionIri,
+  conceptSlug,
+  mintConceptIri,
+  mintTermConceptIri,
+  mintProductIri,
+  mintSchemeIri,
+  mintAgentIri,
+  mintGraphIri,
+  mintBuildActivityIri,
+  NS,
+  PREFIXES,
+  RDF_TYPE,
+  ROLE,
+  IIRDS_HAS_TOPIC_TYPE,
+  IIRDS_RELATES_TO_PRODUCT_VARIANT,
+  IIRDS_RELATES_TO_LIFECYCLE_PHASE,
+  IIRDS_HAS_SUBJECT,
+  IIRDS_PRODUCT_VARIANT,
+  IIRDS_PACKAGE,
+  IIRDS_IIRDS_VERSION,
+  IIRDS_TOPIC,
+  IIRDS_IS_PART_OF_PACKAGE,
+  IIRDS_HAS_RENDITION,
+  IIRDS_RENDITION,
+  IIRDS_SOURCE,
+  IIRDS_FORMAT,
+  IIRDS_TITLE,
+  IIRDS_LANGUAGE,
+  IIRDS_PARTY,
+  IIRDS_HAS_PARTY_ROLE,
+  IIRDS_CREATOR,
+  IIRDS_RELATES_TO_PARTY,
+  IIRDS_RELATES_TO_VCARD,
+  VCARD_NS,
+  VCARD_ORGANIZATION,
+  VCARD_ORGANIZATION_NAME,
+  GRAPH_NOT_APPLICABLE_TO_VARIANT,
+  GRAPH_NOT_SOFTWARE_SUBJECT,
+  PAGE_TYPE_TO_TOPIC_TYPE,
+  TOPIC_TYPE_IRIS,
+  SOFTWARE_LIFECYCLE_IRIS,
+  SOFTWARE_SUBJECT_IRIS,
+  COVERAGE_FIELDS,
+  SECTION_COVERAGE_FIELDS,
+  COVERAGE_FIELD_NAMES,
+  UNIFORM_COVERAGE_FIELD_NAMES,
+  MODEL_PROFILES,
+  DEFAULT_MODEL,
+  profileFor,
+  withPrefix,
+  ALL_FILL_FIELDS,
+  DEFAULT_CONFIG_FILENAME,
+  CONFIG_SECTION,
+  parseConfig,
+  loadConfig,
+  defaultConfig,
+  loadRunConfig,
+  isTreeFormat,
+  formatOf,
+  hasScheme,
+  resolveRelative,
+  extractorFor,
+  metadataOf,
+  analyzeDoc,
+  parseBody,
+  parseTree,
+  mintTreeSections,
+  byCodeUnit,
+  discoverFiles,
+  DEFAULT_EXTENSIONS,
+  STDIN,
+  assertInputFormat,
+  resolveDocumentSet,
+  documentBase,
+  routesFrom,
+  documentSetPatterns,
+  LOCALIZATIONS_FILENAME,
+  UNDETERMINED,
+  isLanguageTag,
+  canonicalLanguageTag,
+  searchIndexFilename,
+  vectorIndexFilename,
+  emitLocalizations,
+  parseLocalizations,
+  isSafeRelativePath,
+  readSampleQuestions,
+  readQuestionFile,
+  questionKey,
+  COPIED_SHARE,
+  copiedPairs,
+  openMetaView,
+  mergePage,
+  withExternalMetadata
+};
+//# sourceMappingURL=chunk-2UJZXVHR.js.map