@hawkeyexl/manni 4.3.0 → 4.4.0

package/dist/chunk-644JVKJ4.js

@@ -0,0 +1,3872 @@
+#!/usr/bin/env node
+import {
+  LOCALIZATIONS_FILENAME,
+  STDIN,
+  UNDETERMINED,
+  analyzeDoc,
+  assertInputFormat,
+  canonicalLanguageTag,
+  deriveGraph,
+  documentBase,
+  documentSetPatterns,
+  emitLocalizations,
+  formatOf,
+  isLanguageTag,
+  isSafeRelativePath,
+  mergePage,
+  openMetaView,
+  ownMetadata,
+  parseLocalizations,
+  resolveDocumentSet,
+  routesFrom,
+  searchIndexFilename,
+  vectorIndexFilename
+} from "./chunk-YIL4XLLJ.js";
+import {
+  bundledShapesPath,
+  compactIri,
+  expandTerm,
+  loadGraph,
+  storeToQuads,
+  validateGraph
+} from "./chunk-MYMBCTDE.js";
+import {
+  COVERAGE_FIELDS,
+  DEFAULT_MODEL,
+  GRAPH_NOT_APPLICABLE_TO_VARIANT,
+  GRAPH_NOT_SOFTWARE_SUBJECT,
+  GraphError,
+  IIRDS_CREATOR,
+  IIRDS_FORMAT,
+  IIRDS_HAS_PARTY_ROLE,
+  IIRDS_HAS_RENDITION,
+  IIRDS_HAS_SUBJECT,
+  IIRDS_HAS_TOPIC_TYPE,
+  IIRDS_IIRDS_VERSION,
+  IIRDS_IS_PART_OF_PACKAGE,
+  IIRDS_LANGUAGE,
+  IIRDS_PACKAGE,
+  IIRDS_PARTY,
+  IIRDS_PRODUCT_VARIANT,
+  IIRDS_RELATES_TO_LIFECYCLE_PHASE,
+  IIRDS_RELATES_TO_PARTY,
+  IIRDS_RELATES_TO_PRODUCT_VARIANT,
+  IIRDS_RELATES_TO_VCARD,
+  IIRDS_RENDITION,
+  IIRDS_SOURCE,
+  IIRDS_TITLE,
+  IIRDS_TOPIC,
+  NS,
+  PREFIXES,
+  RDF_TYPE,
+  SECTION_COVERAGE_FIELDS,
+  SOFTWARE_SUBJECT_IRIS,
+  STDIN_PATH,
+  VCARD_NS,
+  VCARD_ORGANIZATION,
+  VCARD_ORGANIZATION_NAME,
+  byCodeUnit,
+  loadRunConfig,
+  profileFor,
+  withPrefix
+} from "./chunk-M2JCK5F6.js";
+import {
+  mergeMetaProvenance
+} from "./chunk-K3D6FPV6.js";
+import {
+  isMissing,
+  spliceManifestValue
+} from "./chunk-RLR4TKUZ.js";
+import {
+  urlManifestMessage,
+  writeFileAtomic
+} from "./chunk-JVTNMVYU.js";
+import {
+  assertKnownProvider,
+  assertLocalFlag,
+  assertModelHasProvider,
+  localNotice,
+  noticeOnce,
+  providerSpecFor,
+  resolveIdentity,
+  selectProvider,
+  warn
+} from "./chunk-Q35YIDBV.js";
+import {
+  errorMessage
+} from "./chunk-G3T47CFV.js";
+
+// src/graph/commands/export.ts
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname, join, resolve as resolve3 } from "node:path";
+
+// src/graph/core/emit-jsonld.ts
+var XSD_STRING = `${NS.xsd}string`;
+function renderValue(term) {
+  if (term.kind === "iri") {
+    return {
+      value: { "@id": term.value },
+      kind: 0,
+      primary: term.value,
+      datatype: ""
+    };
+  }
+  if (term.datatype && term.datatype !== XSD_STRING) {
+    return {
+      value: { "@value": term.value, "@type": compactIri(term.datatype) },
+      kind: 1,
+      primary: term.value,
+      datatype: term.datatype
+    };
+  }
+  return { value: term.value, kind: 1, primary: term.value, datatype: "" };
+}
+function compareRendered(a, b) {
+  if (a.kind !== b.kind) return a.kind - b.kind;
+  const p = byCodeUnit(a.primary, b.primary);
+  if (p !== 0) return p;
+  return byCodeUnit(a.datatype, b.datatype);
+}
+function collapse(values) {
+  const rendered = [...values].sort(compareRendered).map((v) => v.value);
+  return rendered.length === 1 ? rendered[0] : rendered;
+}
+function emitJsonLd(quads) {
+  const context = {};
+  for (const [prefix, ns] of PREFIXES) context[prefix] = ns;
+  const subjects = /* @__PURE__ */ new Map();
+  for (const quad of quads) {
+    let preds = subjects.get(quad.s);
+    if (!preds) {
+      preds = /* @__PURE__ */ new Map();
+      subjects.set(quad.s, preds);
+    }
+    let terms = preds.get(quad.p);
+    if (!terms) {
+      terms = [];
+      preds.set(quad.p, terms);
+    }
+    terms.push(quad.o);
+  }
+  const graph = [...subjects.entries()].sort(([a], [b]) => byCodeUnit(a, b)).map(([subject, preds]) => {
+    const node = { "@id": subject };
+    const types = preds.get(RDF_TYPE);
+    if (types) {
+      const compacted = types.map((t) => compactIri(t.value)).sort(byCodeUnit);
+      node["@type"] = compacted.length === 1 ? compacted[0] : compacted;
+    }
+    const predEntries = [...preds.entries()].filter(([p]) => p !== RDF_TYPE).sort(([a], [b]) => byCodeUnit(a, b));
+    for (const [p, terms] of predEntries) {
+      node[compactIri(p)] = collapse(terms.map(renderValue));
+    }
+    return node;
+  });
+  return `${JSON.stringify({ "@context": context, "@graph": graph }, null, 2)}
+`;
+}
+
+// src/graph/core/emit-rdfxml.ts
+var XSD_STRING2 = `${NS.xsd}string`;
+function escapeText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(value) {
+  return escapeText(value).replace(/"/g, "&quot;");
+}
+function toQName(iri2, prefixes) {
+  let best;
+  let bestNs = "";
+  for (const [prefix, ns] of prefixes) {
+    if (iri2.startsWith(ns) && iri2.length > ns.length && ns.length > bestNs.length) {
+      best = `${prefix}:${iri2.slice(ns.length)}`;
+      bestNs = ns;
+    }
+  }
+  if (best === void 0) {
+    throw new Error(`emitRdfXml: no prefix covers the IRI ${iri2}`);
+  }
+  return best;
+}
+function compareTerms(a, b) {
+  if (a.kind !== b.kind) return a.kind === "iri" ? -1 : 1;
+  const v = byCodeUnit(a.value, b.value);
+  if (v !== 0) return v;
+  const da = a.kind === "literal" ? a.datatype ?? "" : "";
+  const db = b.kind === "literal" ? b.datatype ?? "" : "";
+  return byCodeUnit(da, db);
+}
+function emitRdfXml(quads, prefixes) {
+  const sortedPrefixes = Object.entries(prefixes).sort(
+    ([a], [b]) => byCodeUnit(a, b)
+  );
+  const lines = ['<?xml version="1.0" encoding="UTF-8"?>'];
+  lines.push("<rdf:RDF");
+  sortedPrefixes.forEach(([prefix, ns], i) => {
+    const tail = i === sortedPrefixes.length - 1 ? ">" : "";
+    lines.push(`  xmlns:${prefix}="${escapeAttr(ns)}"${tail}`);
+  });
+  const subjects = /* @__PURE__ */ new Map();
+  for (const quad of quads) {
+    let preds = subjects.get(quad.s);
+    if (!preds) {
+      preds = /* @__PURE__ */ new Map();
+      subjects.set(quad.s, preds);
+    }
+    let terms = preds.get(quad.p);
+    if (!terms) {
+      terms = [];
+      preds.set(quad.p, terms);
+    }
+    terms.push(quad.o);
+  }
+  const sortedSubjects = [...subjects.entries()].sort(
+    ([a], [b]) => byCodeUnit(a, b)
+  );
+  for (const [subject, preds] of sortedSubjects) {
+    lines.push(`  <rdf:Description rdf:about="${escapeAttr(subject)}">`);
+    const sortedPreds = [...preds.entries()].sort(
+      ([a], [b]) => byCodeUnit(a, b)
+    );
+    for (const [p, terms] of sortedPreds) {
+      const qname = toQName(p, sortedPrefixes);
+      for (const term of [...terms].sort(compareTerms)) {
+        if (term.kind === "iri") {
+          lines.push(
+            `    <${qname} rdf:resource="${escapeAttr(term.value)}"/>`
+          );
+        } else if (term.datatype && term.datatype !== XSD_STRING2) {
+          lines.push(
+            `    <${qname} rdf:datatype="${escapeAttr(term.datatype)}">${escapeText(term.value)}</${qname}>`
+          );
+        } else {
+          lines.push(`    <${qname}>${escapeText(term.value)}</${qname}>`);
+        }
+      }
+    }
+    lines.push("  </rdf:Description>");
+  }
+  lines.push("</rdf:RDF>");
+  return `${lines.join("\n")}
+`;
+}
+
+// src/graph/core/iirds-package.ts
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { DataFactory } from "n3";
+
+// src/graph/core/zip.ts
+import { crc32, deflateRawSync } from "node:zlib";
+function escapesArchiveRoot(name) {
+  const segments = name.split(/[/\\]/);
+  return name.startsWith("/") || name.startsWith("\\") || /^[A-Za-z]:/.test(name) || segments.includes("..");
+}
+var DOS_DATE = 33;
+var DOS_TIME = 0;
+var VERSION = 20;
+function writeZip(entries) {
+  const locals = [];
+  const centrals = [];
+  let offset = 0;
+  for (const entry2 of entries) {
+    if (escapesArchiveRoot(entry2.name)) {
+      throw new GraphError(
+        `Refusing ZIP entry "${entry2.name}": an archive entry may not be absolute or climb above the archive root.`
+      );
+    }
+    const name = Buffer.from(entry2.name, "utf8");
+    const flags = name.some((b) => b > 127) ? 2048 : 0;
+    const method = entry2.store ? 0 : 8;
+    const stored = entry2.store ? entry2.data : deflateRawSync(entry2.data);
+    const crc = crc32(entry2.data) >>> 0;
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(67324752, 0);
+    local.writeUInt16LE(VERSION, 4);
+    local.writeUInt16LE(flags, 6);
+    local.writeUInt16LE(method, 8);
+    local.writeUInt16LE(DOS_TIME, 10);
+    local.writeUInt16LE(DOS_DATE, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(stored.length, 18);
+    local.writeUInt32LE(entry2.data.length, 22);
+    local.writeUInt16LE(name.length, 26);
+    local.writeUInt16LE(0, 28);
+    locals.push(local, name, stored);
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(33639248, 0);
+    central.writeUInt16LE(VERSION, 4);
+    central.writeUInt16LE(VERSION, 6);
+    central.writeUInt16LE(flags, 8);
+    central.writeUInt16LE(method, 10);
+    central.writeUInt16LE(DOS_TIME, 12);
+    central.writeUInt16LE(DOS_DATE, 14);
+    central.writeUInt32LE(crc, 16);
+    central.writeUInt32LE(stored.length, 20);
+    central.writeUInt32LE(entry2.data.length, 24);
+    central.writeUInt16LE(name.length, 28);
+    central.writeUInt16LE(0, 30);
+    central.writeUInt16LE(0, 32);
+    central.writeUInt16LE(0, 34);
+    central.writeUInt16LE(0, 36);
+    central.writeUInt32LE(0, 38);
+    central.writeUInt32LE(offset, 42);
+    centrals.push(central, name);
+    offset += local.length + name.length + stored.length;
+  }
+  const centralBuf = Buffer.concat(centrals);
+  const eocd = Buffer.alloc(22);
+  eocd.writeUInt32LE(101010256, 0);
+  eocd.writeUInt16LE(0, 4);
+  eocd.writeUInt16LE(0, 6);
+  eocd.writeUInt16LE(entries.length, 8);
+  eocd.writeUInt16LE(entries.length, 10);
+  eocd.writeUInt32LE(centralBuf.length, 12);
+  eocd.writeUInt32LE(offset, 16);
+  eocd.writeUInt16LE(0, 20);
+  return Buffer.concat([...locals, centralBuf, eocd]);
+}
+
+// src/graph/core/iirds-package.ts
+var GRAPH_DOCUMENT = `${NS.graph}Document`;
+var XSD_STRING3 = `${NS.xsd}string`;
+var CARRIED = [
+  IIRDS_HAS_TOPIC_TYPE,
+  IIRDS_HAS_SUBJECT,
+  IIRDS_RELATES_TO_PRODUCT_VARIANT,
+  IIRDS_RELATES_TO_LIFECYCLE_PHASE
+];
+var iri = (value) => ({ kind: "iri", value });
+var lit = (value, datatype) => datatype ? { kind: "literal", value, datatype } : { kind: "literal", value };
+function firstObject(store, s, p) {
+  const q = store.getQuads(DataFactory.namedNode(s), DataFactory.namedNode(p), null, null)[0];
+  return q?.object.value;
+}
+function projectPackage(store, opts, cwd) {
+  const quads = [];
+  const contentFiles = [];
+  const warnings = [];
+  const add = (s, p, o) => {
+    quads.push({ s, p, o });
+  };
+  const pkg = `${opts.baseIri}package`;
+  add(pkg, RDF_TYPE, iri(IIRDS_PACKAGE));
+  add(pkg, IIRDS_IIRDS_VERSION, lit(opts.version));
+  add(pkg, IIRDS_TITLE, lit(opts.title ?? "manni graph export"));
+  if (opts.creator) {
+    const party = `${opts.baseIri}party/creator`;
+    const org = `${opts.baseIri}vcard/creator`;
+    add(pkg, IIRDS_RELATES_TO_PARTY, iri(party));
+    add(party, RDF_TYPE, iri(IIRDS_PARTY));
+    add(party, IIRDS_HAS_PARTY_ROLE, iri(IIRDS_CREATOR));
+    add(party, IIRDS_RELATES_TO_VCARD, iri(org));
+    add(org, RDF_TYPE, iri(VCARD_ORGANIZATION));
+    add(org, VCARD_ORGANIZATION_NAME, lit(opts.creator));
+  }
+  const docs = store.getQuads(null, DataFactory.namedNode(RDF_TYPE), DataFactory.namedNode(GRAPH_DOCUMENT), null).map((q) => q.subject.value).sort(byCodeUnit);
+  const variants = /* @__PURE__ */ new Set();
+  for (const doc of docs) {
+    add(doc, RDF_TYPE, iri(IIRDS_TOPIC));
+    add(doc, IIRDS_IS_PART_OF_PACKAGE, iri(pkg));
+    const title = firstObject(store, doc, `${NS.dcterms}title`);
+    if (title) add(doc, IIRDS_TITLE, lit(title));
+    const language = firstObject(store, doc, `${NS.dcterms}language`);
+    if (language) add(doc, IIRDS_LANGUAGE, lit(language));
+    const path2 = firstObject(store, doc, `${NS.graph}path`);
+    if (path2) {
+      if (escapesArchiveRoot(path2)) {
+        throw new GraphError(
+          `Cannot package "${path2}": an iiRDS package has one root, and a path that climbs above it has no place inside it. Re-run \`manni graph build\` from a directory that contains every document, then export again.`
+        );
+      }
+      const absPath = resolve(cwd, path2);
+      if (!existsSync(absPath)) {
+        throw new GraphError(
+          `Content file for ${path2} not found at ${absPath} \u2014 re-run \`manni graph build\`, or the source moved.`
+        );
+      }
+      const zipPath = `content/${path2}`;
+      const rendition = `${doc}/rendition`;
+      add(doc, IIRDS_HAS_RENDITION, iri(rendition));
+      add(rendition, RDF_TYPE, iri(IIRDS_RENDITION));
+      add(rendition, IIRDS_SOURCE, lit(zipPath));
+      add(rendition, IIRDS_FORMAT, lit("text/markdown"));
+      contentFiles.push({ zipPath, absPath });
+    } else {
+      warnings.push(
+        `Document ${doc} has no graph:path \u2014 no rendition emitted.`
+      );
+    }
+    for (const pred of CARRIED) {
+      for (const q of store.getQuads(
+        DataFactory.namedNode(doc),
+        DataFactory.namedNode(pred),
+        null,
+        null
+      )) {
+        const o = q.object;
+        if (o.termType === "Literal") {
+          const dt = o.datatype.value;
+          add(doc, pred, lit(o.value, dt !== XSD_STRING3 ? dt : void 0));
+        } else {
+          add(doc, pred, iri(o.value));
+          if (pred === IIRDS_RELATES_TO_PRODUCT_VARIANT) variants.add(o.value);
+        }
+      }
+    }
+  }
+  for (const v of [...variants].sort(byCodeUnit)) {
+    add(v, RDF_TYPE, iri(IIRDS_PRODUCT_VARIANT));
+    const label = firstObject(store, v, `${NS.dcterms}title`);
+    if (label) add(v, `${NS.dcterms}title`, lit(label));
+  }
+  const prefixes = {
+    dcterms: NS.dcterms,
+    iirds: NS.iirds,
+    iirdsSft: NS.iirdsSft,
+    rdf: NS.rdf,
+    vcard: VCARD_NS
+  };
+  return { quads, prefixes, contentFiles, warnings };
+}
+
+// src/graph/core/search-index.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+
+// src/graph/runtime/resolve.ts
+var GRAPH_PATH = `${NS.graph}path`;
+var DCTERMS_TITLE = `${NS.dcterms}title`;
+var DCTERMS_HAS_PART = `${NS.dcterms}hasPart`;
+var GRAPH_LEVEL = `${NS.graph}level`;
+var GRAPH_ORDER = `${NS.graph}order`;
+function splitFragment(iri2) {
+  const hash = iri2.indexOf("#");
+  return hash < 0 ? { doc: iri2 } : { doc: iri2.slice(0, hash), fragment: iri2.slice(hash + 1) };
+}
+function fencedLines(lines) {
+  const mask = new Array(lines.length).fill(false);
+  let open;
+  for (const [i, line] of lines.entries()) {
+    const m = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+    const delimiter = m?.[1];
+    const info = m?.[2];
+    const isFence = delimiter !== void 0 && info !== void 0;
+    if (open === void 0) {
+      if (isFence && !(delimiter.startsWith("`") && info.includes("`"))) {
+        open = delimiter;
+        mask[i] = true;
+      }
+      continue;
+    }
+    mask[i] = true;
+    if (isFence && delimiter[0] === open[0] && delimiter.length >= open.length && info.trim() === "") {
+      open = void 0;
+    }
+  }
+  return mask;
+}
+var ATX = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?[ \t]*$/;
+var SETEXT_UNDERLINE = /^ {0,3}(=+|-+)[ \t]*$/;
+function isParagraphLine(line) {
+  if (line.trim() === "") return false;
+  if (ATX.test(line)) return false;
+  if (/^ {0,3}([-+*]|\d{1,9}[.)])([ \t]|$)/.test(line)) return false;
+  if (/^ {0,3}>/.test(line)) return false;
+  if (/^ {0,3}([-*_])([ \t]*\1){2,}[ \t]*$/.test(line)) return false;
+  return !/^ {4}/.test(line);
+}
+function frontmatterLength(lines) {
+  if (lines[0]?.trim() !== "---") return 0;
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i]?.trim();
+    if (line === "---" || line === "...") return i + 1;
+  }
+  return 0;
+}
+function sourceHeadings(lines) {
+  const fenced = fencedLines(lines);
+  const skip = frontmatterLength(lines);
+  const headings = [];
+  let paragraph = -1;
+  for (const [i, line] of lines.entries()) {
+    if (i < skip || fenced[i]) {
+      paragraph = -1;
+      continue;
+    }
+    const atx = ATX.exec(line);
+    const hashes = atx?.[1];
+    if (hashes !== void 0) {
+      const text = (atx?.[2] ?? "").replace(/(^|[ \t]+)#+$/, "");
+      headings.push({ start: i, level: hashes.length, text });
+      paragraph = -1;
+      continue;
+    }
+    const underline = SETEXT_UNDERLINE.exec(line)?.[1];
+    if (underline !== void 0 && paragraph >= 0) {
+      headings.push({
+        start: paragraph,
+        level: underline.startsWith("=") ? 1 : 2,
+        text: lines.slice(paragraph, i).join("\n")
+      });
+      paragraph = -1;
+      continue;
+    }
+    if (isParagraphLine(line)) {
+      if (paragraph < 0) paragraph = i;
+    } else {
+      paragraph = -1;
+    }
+  }
+  return headings;
+}
+var ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0"
+};
+function decodeEntities(text) {
+  return text.replace(
+    /&(#x[0-9a-f]+|#[0-9]+|[a-z]+);/gi,
+    (whole, name) => {
+      if (name.startsWith("#")) {
+        const hex = name[1] === "x" || name[1] === "X";
+        const code = Number.parseInt(name.slice(hex ? 2 : 1), hex ? 16 : 10);
+        return Number.isNaN(code) || code > 1114111 ? whole : String.fromCodePoint(code);
+      }
+      return ENTITIES[name.toLowerCase()] ?? whole;
+    }
+  );
+}
+function headingKey(text) {
+  return text.replace(/[`*_~\\[\]]/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function stripInline(raw) {
+  return decodeEntities(
+    raw.replace(/!?\[([^\]]*)\]\((?:[^()]|\([^()]*\))*\)/g, "$1").replace(/!?\[([^\]]*)\]\[[^\]]*\]/g, "$1").replace(/<((?:https?|mailto):[^>\s]+)>/gi, "$1")
+  );
+}
+function documentSectionOrder(graph, docIri) {
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const childrenOf = (iri2) => graph.out(iri2, DCTERMS_HAS_PART).map((e) => e.target).sort((a, b) => {
+    const oa = Number.parseInt(graph.literal(a, GRAPH_ORDER) ?? "", 10);
+    const ob = Number.parseInt(graph.literal(b, GRAPH_ORDER) ?? "", 10);
+    if (Number.isNaN(oa) || Number.isNaN(ob) || oa === ob) {
+      return a < b ? -1 : a > b ? 1 : 0;
+    }
+    return oa - ob;
+  });
+  const walk = (iri2) => {
+    for (const child of childrenOf(iri2)) {
+      if (seen.has(child)) continue;
+      seen.add(child);
+      ordered.push(child);
+      walk(child);
+    }
+  };
+  walk(docIri);
+  return ordered;
+}
+function sectionOccurrences(graph, docIri) {
+  const occurrences = /* @__PURE__ */ new Map();
+  const counts = /* @__PURE__ */ new Map();
+  for (const section of documentSectionOrder(graph, docIri)) {
+    const rawTitle = graph.literal(section, DCTERMS_TITLE);
+    if (rawTitle === void 0) {
+      occurrences.set(section, 0);
+      continue;
+    }
+    const title = headingKey(rawTitle);
+    const level = graph.literal(section, GRAPH_LEVEL) ?? "";
+    let byLevel = counts.get(title);
+    if (!byLevel) {
+      byLevel = /* @__PURE__ */ new Map();
+      counts.set(title, byLevel);
+    }
+    const seen = byLevel.get(level) ?? 0;
+    occurrences.set(section, seen);
+    byLevel.set(level, seen + 1);
+  }
+  return occurrences;
+}
+function sectionOccurrence(graph, sectionIri) {
+  const { doc } = splitFragment(sectionIri);
+  return sectionOccurrences(graph, doc).get(sectionIri) ?? 0;
+}
+function documentPreamble(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  const end = sourceHeadings(lines)[0]?.start ?? lines.length;
+  const text = lines.slice(0, end).join("\n").trim();
+  return text === "" ? void 0 : text;
+}
+function sliceSection(markdown, title, level, occurrence = 0) {
+  return slice(markdown, title, level, occurrence, false);
+}
+function sectionOwnText(markdown, title, level, occurrence = 0) {
+  return slice(markdown, title, level, occurrence, true);
+}
+function slice(markdown, title, level, occurrence, ownTextOnly) {
+  const lines = markdown.split(/\r?\n/);
+  const headings = sourceHeadings(lines);
+  const wanted = headingKey(title);
+  let remaining = occurrence;
+  let found = -1;
+  for (const [n, heading] of headings.entries()) {
+    if (level !== void 0 && heading.level !== level) continue;
+    if (headingKey(stripInline(heading.text)) !== wanted) continue;
+    if (remaining > 0) {
+      remaining -= 1;
+      continue;
+    }
+    found = n;
+    break;
+  }
+  const match = headings[found];
+  if (match === void 0) return void 0;
+  const next = headings.slice(found + 1).find((h) => ownTextOnly || h.level <= match.level);
+  const end = next?.start ?? lines.length;
+  return lines.slice(match.start, end).join("\n").trimEnd();
+}
+function createFetchResolver(graph, options = {}) {
+  const doFetch = options.fetch ?? ((url) => globalThis.fetch(url));
+  const toUrl = options.pathToUrl ?? ((path2) => `${options.baseUrl ?? ""}${path2}`);
+  const cache = /* @__PURE__ */ new Map();
+  const occurrenceCache = /* @__PURE__ */ new Map();
+  const occurrenceOf = (docIri, sectionIri) => {
+    let map = occurrenceCache.get(docIri);
+    if (!map) {
+      map = sectionOccurrences(graph, docIri);
+      occurrenceCache.set(docIri, map);
+    }
+    return map.get(sectionIri) ?? 0;
+  };
+  const fetchDoc = (url) => {
+    let pending = cache.get(url);
+    if (!pending) {
+      pending = doFetch(url).then((r) => r.ok ? r.text() : void 0).catch(() => void 0);
+      cache.set(url, pending);
+    }
+    return pending;
+  };
+  return {
+    async resolve(iri2) {
+      const { doc, fragment } = splitFragment(iri2);
+      const path2 = graph.literal(doc, GRAPH_PATH);
+      if (!path2) return void 0;
+      const sourceUrl = toUrl(path2);
+      const body = await fetchDoc(sourceUrl);
+      const title = graph.literal(iri2, DCTERMS_TITLE);
+      if (body === void 0) {
+        options.trace?.resolutions.push({
+          iri: iri2,
+          sourceUrl,
+          ok: false,
+          error: "fetch failed"
+        });
+        return void 0;
+      }
+      let text = body;
+      if (fragment) {
+        const levelText = graph.literal(iri2, GRAPH_LEVEL);
+        const level = levelText ? Number.parseInt(levelText, 10) : void 0;
+        const slice2 = title === void 0 ? void 0 : sliceSection(
+          body,
+          title,
+          Number.isNaN(level) ? void 0 : level,
+          occurrenceOf(doc, iri2)
+        );
+        if (slice2 === void 0) {
+          options.trace?.resolutions.push({
+            iri: iri2,
+            sourceUrl,
+            ok: false,
+            error: "section heading not found"
+          });
+          return void 0;
+        }
+        text = slice2;
+      }
+      options.trace?.resolutions.push({ iri: iri2, sourceUrl, ok: true });
+      return { iri: iri2, text, sourceUrl, title };
+    }
+  };
+}
+
+// src/graph/core/search-index.ts
+var GRAPH_DOCUMENT2 = `${NS.graph}Document`;
+var GRAPH_SECTION = `${NS.graph}Section`;
+var SKOS_CONCEPT = `${NS.skos}Concept`;
+var GRAPH_PATH2 = `${NS.graph}path`;
+var GRAPH_LEVEL2 = `${NS.graph}level`;
+var DCTERMS_TITLE2 = `${NS.dcterms}title`;
+var DCTERMS_DESCRIPTION = `${NS.dcterms}description`;
+var SKOS_PREF_LABEL = `${NS.skos}prefLabel`;
+var SKOS_ALT_LABEL = `${NS.skos}altLabel`;
+var DCTERMS_LANGUAGE = `${NS.dcterms}language`;
+function joinLabels(values) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const v of values) {
+    const key = v.trim().toLowerCase();
+    if (key && !seen.has(key)) seen.set(key, v.trim());
+  }
+  const out = [...seen.values()].sort(byCodeUnit);
+  return out.length > 0 ? out.join(" ") : void 0;
+}
+var FRONTMATTER = /^---[ \t]*\r?\n(?:[\s\S]*?\r?\n)?(?:---|\.\.\.)[ \t]*(?:\r?\n|$)(?:\r?\n)*/;
+function stripFrontmatter(markdown) {
+  return markdown.replace(FRONTMATTER, "");
+}
+function entry(id, type, fields) {
+  const out = { id, type };
+  if (fields.title !== void 0) out.title = fields.title;
+  if (fields.labels !== void 0) out.labels = fields.labels;
+  if (fields.description !== void 0) out.description = fields.description;
+  if (fields.text !== void 0) out.text = fields.text;
+  return out;
+}
+function buildSearchIndex(graph, cwd, options = {}) {
+  const warnings = options.warnings ?? [];
+  const readDoc = options.readDoc ?? ((path2) => {
+    const abs = resolve2(cwd, path2);
+    return existsSync2(abs) ? readFileSync(abs, "utf8") : void 0;
+  });
+  const entries = [];
+  const sourceOf = /* @__PURE__ */ new Map();
+  const allSections = graph.instancesOf(GRAPH_SECTION);
+  const sectionsOf = /* @__PURE__ */ new Map();
+  for (const section of allSections) {
+    const hash = section.indexOf("#");
+    if (hash < 0) continue;
+    const doc = section.slice(0, hash);
+    const siblings = sectionsOf.get(doc);
+    if (siblings) siblings.push(section);
+    else sectionsOf.set(doc, [section]);
+  }
+  for (const doc of graph.instancesOf(GRAPH_DOCUMENT2)) {
+    const path2 = graph.literal(doc, GRAPH_PATH2);
+    const source = path2 === void 0 ? void 0 : readDoc(path2);
+    sourceOf.set(doc, source);
+    if (path2 !== void 0 && source === void 0) {
+      warnings.push(
+        `Source not found for ${path2} \u2014 indexed without body text.`
+      );
+    }
+    const body = source === void 0 ? void 0 : stripFrontmatter(source).replace(/\r\n/g, "\n");
+    const text = body === void 0 ? void 0 : (sectionsOf.get(doc)?.length ?? 0) > 0 ? documentPreamble(body) : body;
+    entries.push(
+      entry(doc, compactIri(GRAPH_DOCUMENT2), {
+        title: graph.literal(doc, DCTERMS_TITLE2),
+        description: graph.literal(doc, DCTERMS_DESCRIPTION),
+        text
+      })
+    );
+  }
+  const occurrencesOf = /* @__PURE__ */ new Map();
+  for (const section of allSections) {
+    const hash = section.indexOf("#");
+    const doc = hash < 0 ? section : section.slice(0, hash);
+    const title = graph.literal(section, DCTERMS_TITLE2);
+    const source = sourceOf.get(doc);
+    const levelText = graph.literal(section, GRAPH_LEVEL2);
+    const parsed = levelText === void 0 ? NaN : Number.parseInt(levelText, 10);
+    const level = Number.isNaN(parsed) ? void 0 : parsed;
+    let occurrences = occurrencesOf.get(doc);
+    if (!occurrences) {
+      occurrences = sectionOccurrences(graph, doc);
+      occurrencesOf.set(doc, occurrences);
+    }
+    const text = source !== void 0 && title !== void 0 ? sectionOwnText(source, title, level, occurrences.get(section) ?? 0) : void 0;
+    entries.push(entry(section, compactIri(GRAPH_SECTION), { title, text }));
+  }
+  for (const concept of graph.instancesOf(SKOS_CONCEPT)) {
+    const pref = graph.literals(concept, SKOS_PREF_LABEL);
+    const alt = graph.literals(concept, SKOS_ALT_LABEL);
+    entries.push(
+      entry(concept, compactIri(SKOS_CONCEPT), {
+        title: pref[0],
+        labels: joinLabels([...pref, ...alt])
+      })
+    );
+  }
+  entries.sort((a, b) => byCodeUnit(a.id, b.id));
+  return { version: 1, entries };
+}
+function emitSearchIndex(doc) {
+  return `${JSON.stringify(doc, null, 2)}
+`;
+}
+function partitionByLanguage(graph, index) {
+  const documentType = compactIri(GRAPH_DOCUMENT2);
+  const sectionType = compactIri(GRAPH_SECTION);
+  const languageOf = (entry2) => {
+    if (entry2.type !== documentType && entry2.type !== sectionType) {
+      return void 0;
+    }
+    const hash = entry2.id.indexOf("#");
+    const doc = hash === -1 ? entry2.id : entry2.id.slice(0, hash);
+    return languageOfDocument(graph, doc);
+  };
+  const out = /* @__PURE__ */ new Map();
+  const shared = [];
+  for (const entry2 of index.entries) {
+    const language = languageOf(entry2);
+    if (language === void 0) {
+      shared.push(entry2);
+      continue;
+    }
+    const bucket = out.get(language);
+    if (bucket) bucket.entries.push(entry2);
+    else out.set(language, { version: 1, entries: [entry2] });
+  }
+  if (out.size === 0 && shared.length > 0) {
+    out.set(UNDETERMINED, { version: 1, entries: [] });
+  }
+  for (const bucket of out.values()) {
+    bucket.entries.push(...shared);
+    bucket.entries.sort((a, b) => byCodeUnit(a.id, b.id));
+  }
+  return out;
+}
+function languageOfDocument(graph, doc) {
+  const tag = graph.literal(doc, DCTERMS_LANGUAGE);
+  return tag === void 0 ? UNDETERMINED : canonicalLanguageTag(tag);
+}
+function documentsByLanguage(graph) {
+  const out = /* @__PURE__ */ new Map();
+  for (const doc of graph.instancesOf(GRAPH_DOCUMENT2)) {
+    const language = languageOfDocument(graph, doc);
+    out.set(language, (out.get(language) ?? 0) + 1);
+  }
+  return out;
+}
+
+// src/graph/runtime/graph.ts
+var XSD_STRING4 = "http://www.w3.org/2001/XMLSchema#string";
+function compareValues(a, b) {
+  if (a.kind !== b.kind) return a.kind === "iri" ? -1 : 1;
+  const v = byCodeUnit(a.value, b.value);
+  if (v !== 0) return v;
+  const da = a.kind === "literal" ? a.datatype ?? "" : "";
+  const db = b.kind === "literal" ? b.datatype ?? "" : "";
+  return byCodeUnit(da, db);
+}
+var GraphIndex = class _GraphIndex {
+  nodes = /* @__PURE__ */ new Map();
+  /** subject → predicate → object IRIs (sorted). */
+  outbound = /* @__PURE__ */ new Map();
+  /** object → predicate → subject IRIs (sorted). */
+  inbound = /* @__PURE__ */ new Map();
+  /** class IRI → instance IRIs (sorted). */
+  byType = /* @__PURE__ */ new Map();
+  /** prefix → namespace, from the artifact's own `@context`. */
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  /**
+   * Build from a `graph.jsonld` document — a JSON string or the parsed object.
+   * CURIE keys and `@type` values are expanded using the document's own
+   * `@context`, so the index is self-describing.
+   */
+  static fromJsonLd(input) {
+    const doc = typeof input === "string" ? JSON.parse(input) : input;
+    const context = doc["@context"] ?? {};
+    const index = new _GraphIndex({ ...context });
+    for (const raw of doc["@graph"] ?? []) {
+      index.addJsonLdNode(raw);
+    }
+    index.finalize();
+    return index;
+  }
+  /** Build from dockg's internal quad shape (the Node/CLI path). */
+  static fromQuads(quads, context = {}) {
+    const index = new _GraphIndex({ ...context });
+    for (const q of quads) {
+      const o = q.o;
+      const value = o.kind === "iri" ? { kind: "iri", value: o.value } : o.datatype && o.datatype !== XSD_STRING4 ? { kind: "literal", value: o.value, datatype: o.datatype } : { kind: "literal", value: o.value };
+      index.addTriple(q.s, q.p, value);
+    }
+    index.finalize();
+    return index;
+  }
+  /** Expand a CURIE (`dcterms:title`) to a full IRI using `@context`. */
+  expand(term) {
+    const colon = term.indexOf(":");
+    if (colon <= 0) return term;
+    const ns = this.context[term.slice(0, colon)];
+    return ns ? `${ns}${term.slice(colon + 1)}` : term;
+  }
+  /** Compact a full IRI to a CURIE when a context namespace matches. */
+  compact(iri2) {
+    let best = iri2;
+    let bestNs = "";
+    for (const [prefix, ns] of Object.entries(this.context)) {
+      if (iri2.startsWith(ns) && iri2.length > ns.length && ns.length > bestNs.length) {
+        best = `${prefix}:${iri2.slice(ns.length)}`;
+        bestNs = ns;
+      }
+    }
+    return best;
+  }
+  addJsonLdNode(raw) {
+    const id = typeof raw["@id"] === "string" ? this.expand(raw["@id"]) : "";
+    if (!id) return;
+    this.ensureNode(id);
+    const rawTypes = raw["@type"];
+    for (const t of toArray(rawTypes)) {
+      if (typeof t === "string") {
+        this.addTriple(id, RDF_TYPE, { kind: "iri", value: this.expand(t) });
+      }
+    }
+    for (const [key, rawValue] of Object.entries(raw)) {
+      if (key === "@id" || key === "@type") continue;
+      const predicate = this.expand(key);
+      for (const v of toArray(rawValue)) {
+        const value = this.toValue(v);
+        if (value) this.addTriple(id, predicate, value);
+      }
+    }
+  }
+  toValue(v) {
+    if (typeof v === "string") return { kind: "literal", value: v };
+    if (typeof v === "number" || typeof v === "boolean") {
+      return { kind: "literal", value: String(v) };
+    }
+    if (v && typeof v === "object") {
+      const o = v;
+      if (typeof o["@id"] === "string") {
+        return { kind: "iri", value: this.expand(o["@id"]) };
+      }
+      if (o["@value"] !== void 0) {
+        const raw = o["@value"];
+        const lexical = typeof raw === "string" ? raw : JSON.stringify(raw);
+        const dt = typeof o["@type"] === "string" ? this.expand(o["@type"]) : void 0;
+        return dt && dt !== XSD_STRING4 ? { kind: "literal", value: lexical, datatype: dt } : { kind: "literal", value: lexical };
+      }
+    }
+    return void 0;
+  }
+  ensureNode(id) {
+    let node = this.nodes.get(id);
+    if (!node) {
+      node = { id, types: [], props: /* @__PURE__ */ new Map() };
+      this.nodes.set(id, node);
+    }
+    return node;
+  }
+  addTriple(s, p, o) {
+    const node = this.ensureNode(s);
+    let values = node.props.get(p);
+    if (!values) {
+      values = [];
+      node.props.set(p, values);
+    }
+    values.push(o);
+    if (p === RDF_TYPE && o.kind === "iri") {
+      node.types.push(o.value);
+      const instances = this.byType.get(o.value);
+      if (instances) instances.push(s);
+      else this.byType.set(o.value, [s]);
+    }
+    if (o.kind === "iri") {
+      addEdge(this.outbound, s, p, o.value);
+      addEdge(this.inbound, o.value, p, s);
+      this.ensureNode(o.value);
+    }
+  }
+  /** Sort every collection so traversal order is deterministic. */
+  finalize() {
+    for (const node of this.nodes.values()) {
+      node.types.sort(byCodeUnit);
+      for (const values of node.props.values()) values.sort(compareValues);
+    }
+    for (const instances of this.byType.values()) instances.sort(byCodeUnit);
+    for (const map of [this.outbound, this.inbound]) {
+      for (const preds of map.values()) {
+        for (const targets of preds.values()) targets.sort(byCodeUnit);
+      }
+    }
+  }
+  /** Every node IRI, sorted. */
+  ids() {
+    return [...this.nodes.keys()].sort(byCodeUnit);
+  }
+  size() {
+    return this.nodes.size;
+  }
+  node(iri2) {
+    return this.nodes.get(iri2);
+  }
+  has(iri2) {
+    return this.nodes.has(iri2);
+  }
+  /** Class IRIs of a node, sorted. */
+  types(iri2) {
+    return this.nodes.get(iri2)?.types ?? [];
+  }
+  /** Instances of a class, sorted. */
+  instancesOf(classIri) {
+    return this.byType.get(classIri) ?? [];
+  }
+  /** All values for a predicate, sorted. */
+  values(iri2, predicate) {
+    return this.nodes.get(iri2)?.props.get(predicate) ?? [];
+  }
+  /** Literal lexical forms for a predicate, sorted. */
+  literals(iri2, predicate) {
+    return this.values(iri2, predicate).filter((v) => v.kind === "literal").map((v) => v.value);
+  }
+  /** The first literal for a predicate, if any. */
+  literal(iri2, predicate) {
+    return this.literals(iri2, predicate)[0];
+  }
+  /** Outbound IRI targets: all predicates, or one. Sorted. */
+  out(iri2, predicate) {
+    return edges(this.outbound, iri2, predicate);
+  }
+  /** Inbound IRI sources (who points at this node). Sorted. */
+  in(iri2, predicate) {
+    return edges(this.inbound, iri2, predicate);
+  }
+};
+function addEdge(map, key, predicate, target) {
+  let preds = map.get(key);
+  if (!preds) {
+    preds = /* @__PURE__ */ new Map();
+    map.set(key, preds);
+  }
+  const targets = preds.get(predicate);
+  if (targets) targets.push(target);
+  else preds.set(predicate, [target]);
+}
+function edges(map, iri2, predicate) {
+  const preds = map.get(iri2);
+  if (!preds) return [];
+  const out = [];
+  const keys = predicate ? [predicate] : [...preds.keys()].sort(byCodeUnit);
+  for (const p of keys) {
+    for (const target of preds.get(p) ?? []) out.push({ predicate: p, target });
+  }
+  return out;
+}
+function toArray(v) {
+  if (v === void 0 || v === null) return [];
+  return Array.isArray(v) ? v : [v];
+}
+
+// src/graph/commands/export.ts
+var EXPORT_TARGETS = ["jsonld", "iirds", "search"];
+var EXTENSION = {
+  jsonld: ".jsonld",
+  iirds: ".iirds"
+};
+function withExtension(path2, ext) {
+  return path2.replace(/\.[^./\\]*$/, "") + ext;
+}
+function runJsonLd(cwd, graphPath, out) {
+  const store = loadGraph(graphPath);
+  const quads = storeToQuads(store);
+  const serialized = emitJsonLd(quads);
+  const nodes = new Set(quads.map((q) => q.s)).size;
+  const outPath = out ? resolve3(cwd, out) : withExtension(graphPath, EXTENSION.jsonld);
+  mkdirSync(dirname(outPath), { recursive: true });
+  writeFileSync(outPath, serialized, "utf8");
+  return { outPath, format: "jsonld", nodes, warnings: [] };
+}
+function runIirds(cwd, sources, graphPath, iirds, baseIri, out) {
+  const store = loadGraph(graphPath);
+  const projection = projectPackage(
+    store,
+    {
+      baseIri,
+      version: iirds.version,
+      title: iirds.title,
+      creator: iirds.creator
+    },
+    sources
+  );
+  const metadata = emitRdfXml(projection.quads, projection.prefixes);
+  const content = [...projection.contentFiles].sort((a, b) => byCodeUnit(a.zipPath, b.zipPath)).map((f) => ({ name: f.zipPath, data: readFileSync2(f.absPath) }));
+  const entries = [
+    {
+      name: "mimetype",
+      data: Buffer.from("application/iirds+zip"),
+      store: true
+    },
+    { name: "META-INF/metadata.rdf", data: Buffer.from(metadata, "utf8") },
+    ...content
+  ];
+  const outPath = out ? resolve3(cwd, out) : withExtension(graphPath, EXTENSION.iirds);
+  mkdirSync(dirname(outPath), { recursive: true });
+  writeFileSync(outPath, writeZip(entries));
+  const nodes = new Set(projection.quads.map((q) => q.s)).size;
+  return { outPath, format: "iirds", nodes, warnings: projection.warnings };
+}
+function searchIndexDigest(raw) {
+  return `sha256:${createHash("sha256").update(raw, "utf8").digest("hex")}`;
+}
+function runSearchIndex(cwd, sources, graphPath, out) {
+  const store = loadGraph(graphPath);
+  const graph = GraphIndex.fromQuads(
+    storeToQuads(store),
+    Object.fromEntries(PREFIXES)
+  );
+  const warnings = [];
+  const index = buildSearchIndex(graph, sources, { warnings });
+  const byLanguage = partitionByLanguage(graph, index);
+  const docCounts = documentsByLanguage(graph);
+  const outDir = out ? resolve3(cwd, out) : dirname(graphPath);
+  mkdirSync(outDir, { recursive: true });
+  const languages = [];
+  for (const [language, doc] of byLanguage) {
+    if (!isLanguageTag(language)) {
+      throw new GraphError(
+        `Cannot write an index for language "${language}": not a BCP-47 tag. Fix the \`lang\`/\`language\` frontmatter, or the route's \`language\`, and rebuild \u2014 \`manni graph check\` reports which document carries it.`
+      );
+    }
+    const filename = searchIndexFilename(language);
+    const serialized = emitSearchIndex(doc);
+    writeFileSync(join(outDir, filename), serialized, "utf8");
+    languages.push({
+      language,
+      documents: docCounts.get(language) ?? 0,
+      search: {
+        path: filename,
+        entries: doc.entries.length,
+        digest: searchIndexDigest(serialized)
+      }
+    });
+  }
+  const manifestPath = join(outDir, LOCALIZATIONS_FILENAME);
+  writeFileSync(
+    manifestPath,
+    emitLocalizations({ version: 1, languages }),
+    "utf8"
+  );
+  return {
+    outPath: manifestPath,
+    format: "search",
+    nodes: index.entries.length,
+    warnings
+  };
+}
+function runExport(opts) {
+  return new Promise((ok) => {
+    ok(exportOnce(opts));
+  });
+}
+function exportOnce(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  if (!EXPORT_TARGETS.includes(opts.format)) {
+    throw new GraphError(
+      `Unknown export target "${opts.format}". Use ${EXPORT_TARGETS.join(" | ")}.`
+    );
+  }
+  const config = loadRunConfig(
+    {
+      ...opts.config === void 0 ? {} : { configPath: opts.config },
+      ...opts.noConfig === void 0 ? {} : { noConfig: opts.noConfig }
+    },
+    cwd
+  );
+  const graphPath = resolve3(cwd, opts.graph ?? config.out);
+  const sources = documentBase(config, {}, cwd);
+  if (opts.format === "jsonld") return runJsonLd(cwd, graphPath, opts.out);
+  if (opts.format === "search") {
+    return runSearchIndex(cwd, sources, graphPath, opts.out);
+  }
+  return runIirds(
+    cwd,
+    sources,
+    graphPath,
+    config.export.iirds,
+    config.baseIri,
+    opts.out
+  );
+}
+
+// src/graph/commands/query.ts
+import { resolve as resolve4 } from "node:path";
+import { DataFactory as DataFactory2 } from "n3";
+function runQuery(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const config = loadRunConfig(
+    {
+      ...opts.config === void 0 ? {} : { configPath: opts.config },
+      ...opts.noConfig === void 0 ? {} : { noConfig: opts.noConfig }
+    },
+    cwd
+  );
+  const store = loadGraph(resolve4(cwd, opts.graph ?? config.out));
+  const s = opts.s ? DataFactory2.namedNode(expandTerm(opts.s)) : null;
+  const p = opts.p ? DataFactory2.namedNode(expandTerm(opts.p)) : null;
+  const oValue = opts.o ? expandTerm(opts.o) : null;
+  const matches = [];
+  for (const quad of store.getQuads(s, p, null, null)) {
+    const obj = quad.object;
+    if (oValue !== null && obj.value !== oValue) continue;
+    matches.push({
+      s: quad.subject.value,
+      p: quad.predicate.value,
+      o: obj.termType === "Literal" ? {
+        kind: "literal",
+        value: obj.value,
+        ...obj.datatype.value !== "http://www.w3.org/2001/XMLSchema#string" ? { datatype: obj.datatype.value } : {}
+      } : { kind: "iri", value: obj.value }
+    });
+  }
+  matches.sort(
+    (a, b) => byCodeUnit(a.s, b.s) || byCodeUnit(a.p, b.p) || byCodeUnit(a.o.kind, b.o.kind) || byCodeUnit(a.o.value, b.o.value)
+  );
+  return { matches };
+}
+function renderQuery(result, format) {
+  if (format === "json") return JSON.stringify(result, null, 2);
+  if (result.matches.length === 0) return "No matches.";
+  const lines = result.matches.map((m) => {
+    const o = m.o.kind === "iri" ? `<${m.o.value}>` : `"${m.o.value}"${m.o.datatype ? `^^${compactIri(m.o.datatype)}` : ""}`;
+    return `<${m.s}> ${compactIri(m.p)} ${o}`;
+  });
+  lines.push(`
+${result.matches.length} match(es)`);
+  return lines.join("\n");
+}
+
+// src/graph/commands/fill.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve as resolve6 } from "node:path";
+
+// src/graph/core/frontmatter-edit.ts
+import { Document, YAMLMap, YAMLSeq, isMap, parseDocument } from "yaml";
+function frontmatterKind(content) {
+  const body = content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+  if (/^---(\r?\n)/.test(body)) return "yaml";
+  if (/^(\+\+\+|;;;)(\r?\n)/.test(body)) return "unsupported";
+  return "none";
+}
+function splitYamlFrontmatter(content, path2) {
+  const bom = content.charCodeAt(0) === 65279 ? content.slice(0, 1) : "";
+  const body = bom ? content.slice(1) : content;
+  const openMatch = /^---(\r?\n)/.exec(body);
+  if (!openMatch) return null;
+  const eol = openMatch[1] === "\r\n" ? "\r\n" : "\n";
+  const [openLine = "", ...rest] = body.split(/(?<=\n)/);
+  let offset = openLine.length;
+  for (const line of rest) {
+    const stripped = line.replace(/\r?\n$/, "");
+    if (stripped === "---" || stripped === "...") {
+      const blockEnd = offset;
+      return {
+        open: bom + openLine,
+        block: body.slice(openLine.length, blockEnd),
+        suffix: body.slice(blockEnd),
+        eol
+      };
+    }
+    offset += line.length;
+  }
+  throw new GraphError(`${path2}: unterminated frontmatter block`);
+}
+function flowSeqs(node) {
+  if (node instanceof YAMLSeq) {
+    node.flow = true;
+    for (const item of node.items) flowSeqs(item);
+  } else if (node instanceof YAMLMap) {
+    for (const item of node.items) flowSeqs(item.value);
+  }
+}
+function setField(doc, map, field, value) {
+  const node = doc.createNode(value);
+  flowSeqs(node);
+  map.set(field, node);
+}
+function applyGraphFields(content, path2, values, options = {}) {
+  const entries = Object.entries(values).filter(
+    ([, v]) => v !== void 0 && v !== null && !(Array.isArray(v) && v.length === 0)
+  );
+  const pageEntries = Object.entries(options.page ?? {});
+  if (entries.length === 0 && pageEntries.length === 0) {
+    return { content, applied: [], skipped: [] };
+  }
+  if (frontmatterKind(content) === "unsupported") {
+    throw new GraphError(
+      `${path2}: only YAML frontmatter can be edited (found a TOML/JSON fence)`
+    );
+  }
+  const split = splitYamlFrontmatter(content, path2);
+  if (split === null) {
+    const eol = content.includes("\r\n") ? "\r\n" : "\n";
+    const nested = {};
+    for (const [field, value] of entries) {
+      const segments = field.split(".");
+      let target = nested;
+      for (const segment of segments.slice(0, -1)) {
+        target[segment] ??= {};
+        target = target[segment];
+      }
+      target[segments.at(-1) ?? field] = value;
+    }
+    const doc2 = new Document({
+      ...Object.fromEntries(pageEntries),
+      ...entries.length > 0 ? { graph: nested } : {}
+    });
+    const graph2 = doc2.get("graph", true);
+    if (isMap(graph2)) flowSeqs(graph2);
+    let block = doc2.toString();
+    if (eol === "\r\n") block = block.replace(/(?<!\r)\n/g, "\r\n");
+    return {
+      content: `---${eol}${block}---${eol}${eol}${content}`,
+      applied: entries.map(([k]) => k),
+      skipped: []
+    };
+  }
+  const doc = parseDocument(split.block);
+  if (doc.errors.length > 0) {
+    throw new GraphError(
+      `${path2}: cannot edit frontmatter \u2014 ${doc.errors[0]?.message ?? "parse error"}`
+    );
+  }
+  let graph = doc.get("graph", true);
+  if (graph !== void 0 && !isMap(graph)) {
+    throw new GraphError(`${path2}: frontmatter key "graph" is not a map`);
+  }
+  if (graph === void 0 && entries.length > 0) {
+    graph = doc.createNode({});
+    doc.set("graph", graph);
+  }
+  const graphMap = graph ?? doc.createNode({});
+  const applied = [];
+  const skipped = [];
+  for (const [field, value] of entries) {
+    const segments = field.split(".");
+    const leaf = segments.at(-1) ?? field;
+    let target = graphMap;
+    let missingParent = false;
+    for (const segment of segments.slice(0, -1)) {
+      const existing = target.get(segment, true);
+      if (existing === void 0) {
+        const created = doc.createNode({});
+        target.set(segment, created);
+        target = created;
+      } else if (isMap(existing)) {
+        target = existing;
+      } else {
+        missingParent = true;
+        break;
+      }
+    }
+    if (missingParent) {
+      skipped.push(field);
+      continue;
+    }
+    if (target.has(leaf) && !options.force) {
+      skipped.push(field);
+      continue;
+    }
+    setField(doc, target, leaf, value);
+    applied.push(field);
+  }
+  for (const [key, value] of pageEntries) {
+    doc.set(key, doc.createNode(value));
+  }
+  if (applied.length === 0 && pageEntries.length === 0) {
+    return { content, applied, skipped };
+  }
+  let newBlock = doc.toString();
+  if (split.eol === "\r\n") newBlock = newBlock.replace(/(?<!\r)\n/g, "\r\n");
+  return { content: split.open + newBlock + split.suffix, applied, skipped };
+}
+function frontmatterData(content) {
+  const split = splitYamlFrontmatter(content, "");
+  if (split === null) return {};
+  const doc = parseDocument(split.block);
+  if (doc.errors.length > 0) return {};
+  const plain = doc.toJS();
+  return plain !== null && typeof plain === "object" && !Array.isArray(plain) ? plain : {};
+}
+function existingMetaProvenance(content) {
+  return frontmatterData(content)["meta-provenance"];
+}
+function existingGraphFields(content) {
+  const split = splitYamlFrontmatter(content, "");
+  if (split === null) return [];
+  const doc = parseDocument(split.block);
+  if (doc.errors.length > 0) return [];
+  const graph = doc.get("graph", true);
+  if (!isMap(graph)) return [];
+  return graph.items.map((item) => {
+    const value = item.key.value;
+    return typeof value === "string" || typeof value === "number" ? String(value) : "";
+  }).filter((k) => k.length > 0);
+}
+
+// src/graph/core/fill-guard.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { resolve as resolve5 } from "node:path";
+import { DataFactory as DataFactory3, Store } from "n3";
+var GUARDED_FIELDS = [
+  "label",
+  "broader",
+  "narrower",
+  "related-concepts",
+  "applies-to",
+  "not-applicable-to",
+  "about-product-aspect",
+  "not-about-product-aspect"
+];
+var GUARD_SOURCES = ["frontmatter", "tags", "sections"];
+function leafOf(field) {
+  const dot = field.lastIndexOf(".");
+  return dot === -1 ? field : field.slice(dot + 1);
+}
+function toStore(quads) {
+  const store = new Store();
+  for (const q of quads) {
+    store.addQuad(
+      DataFactory3.quad(
+        DataFactory3.namedNode(q.s),
+        DataFactory3.namedNode(q.p),
+        q.o.kind === "iri" ? DataFactory3.namedNode(q.o.value) : DataFactory3.literal(
+          q.o.value,
+          q.o.datatype ? DataFactory3.namedNode(q.o.datatype) : void 0
+        )
+      )
+    );
+  }
+  return store;
+}
+var FillGuard = class _FillGuard {
+  constructor(allPaths, analyzeOptions, baseIri, sources, shapesPaths, force) {
+    this.allPaths = allPaths;
+    this.analyzeOptions = analyzeOptions;
+    this.baseIri = baseIri;
+    this.sources = sources;
+    this.shapesPaths = shapesPaths;
+    this.force = force;
+  }
+  allPaths;
+  analyzeOptions;
+  baseIri;
+  sources;
+  shapesPaths;
+  force;
+  models = /* @__PURE__ */ new Map();
+  baselineKeys = null;
+  /**
+   * Pages left out of the simulation because they would not analyze, sorted.
+   * The caller decides what each one means: a named page fails on its own,
+   * and a page read only for context is worth a warning.
+   */
+  unreadable = [];
+  /**
+   * Read and analyze the whole corpus once, up front. A path in `inline` is
+   * taken from memory rather than disk: that is how a page read from stdin
+   * joins the corpus. `format` is `--as`, applied to the run's `inputs`. Any
+   * other page is parsed by its extension, as `build` reads it. A page that
+   * will not read or analyze is left out and listed in `unreadable`.
+   */
+  static create(files, cwd, config, shapesPaths, force, {
+    inline = /* @__PURE__ */ new Map(),
+    format,
+    inputs = /* @__PURE__ */ new Set()
+  } = {}) {
+    const sources = config.build.derive.filter(
+      (s) => GUARD_SOURCES.includes(s)
+    );
+    const all = [...files, ...inline.keys()];
+    const guard = new _FillGuard(
+      new Set(all),
+      {
+        routes: config.routes,
+        ...format === void 0 ? {} : { format }
+      },
+      config.baseIri,
+      sources,
+      shapesPaths,
+      force
+    );
+    const byExtension = { routes: config.routes };
+    for (const path2 of all) {
+      try {
+        guard.models.set(
+          path2,
+          analyzeDoc(
+            inline.get(path2) ?? readFileSync3(resolve5(cwd, path2), "utf8"),
+            path2,
+            guard.allPaths,
+            inputs.has(path2) ? guard.analyzeOptions : byExtension
+          )
+        );
+      } catch {
+        guard.unreadable.push(path2);
+      }
+    }
+    guard.unreadable.sort(byCodeUnit);
+    return guard;
+  }
+  buildStore(override) {
+    const models = [];
+    for (const [path2, model] of this.models) {
+      models.push(override && path2 === override.path ? override.model : model);
+    }
+    return toStore(
+      deriveGraph(models, { baseIri: this.baseIri, derive: this.sources })
+    );
+  }
+  static key(f) {
+    return `${f.severity}|${f.focusNode}|${f.path ?? ""}|${f.message}`;
+  }
+  /** Findings already present before any proposal — never blamed on one. */
+  async baseline() {
+    if (this.baselineKeys === null) {
+      const findings = await validateGraph(this.buildStore(), this.shapesPaths);
+      this.baselineKeys = new Set(findings.map((f) => _FillGuard.key(f)));
+    }
+    return this.baselineKeys;
+  }
+  /** Fields a finding condemns, restricted to what the proposal contains. */
+  static offendingFields(finding, proposed) {
+    const hash = finding.focusNode.indexOf("#");
+    const slug = hash === -1 ? void 0 : finding.focusNode.slice(hash + 1);
+    const pick = (leaf) => {
+      if (slug !== void 0) {
+        const dotted = `sections.${slug}.${leaf}`;
+        if (proposed.has(dotted)) return [dotted];
+        return [];
+      }
+      return proposed.has(leaf) ? [leaf] : [];
+    };
+    const hierarchy = ["broader", "narrower"].flatMap(pick);
+    if (finding.path === `${NS.skos}prefLabel`) {
+      return pick("label");
+    }
+    if (finding.message.includes("cycle")) return hierarchy;
+    if (finding.path === `${NS.skos}broader`) return hierarchy;
+    if (finding.path === `${NS.skos}narrower`) return hierarchy;
+    if (finding.path === `${NS.skos}related`) {
+      return pick("related-concepts");
+    }
+    if (finding.path === GRAPH_NOT_APPLICABLE_TO_VARIANT) {
+      const negative = pick("not-applicable-to");
+      if (negative.length > 0) return negative;
+      return pick("applies-to");
+    }
+    if (finding.path === GRAPH_NOT_SOFTWARE_SUBJECT) {
+      const negative = pick("not-about-product-aspect");
+      if (negative.length > 0) return negative;
+      return pick("about-product-aspect");
+    }
+    return [];
+  }
+  /**
+   * Simulate `values` applied to the doc and drop fields until the graph
+   * stays clean. New violations always reject; new label warnings
+   * reject the proposed label (an LLM must not introduce a second
+   * spelling of an existing concept).
+   */
+  async vet(path2, content, values) {
+    const current = { ...values };
+    const rejected = [];
+    const guardedLeaves = new Set(GUARDED_FIELDS);
+    const guarded = () => Object.keys(current).filter(
+      (f) => current[f] !== void 0 && guardedLeaves.has(leafOf(f))
+    );
+    if (guarded().length === 0) return { values: current, rejected };
+    const baseline = await this.baseline();
+    while (guarded().length > 0) {
+      const applied = applyGraphFields(content, path2, current, {
+        force: this.force
+      });
+      const model = analyzeDoc(
+        applied.content,
+        path2,
+        this.allPaths,
+        this.analyzeOptions
+      );
+      const findings = await validateGraph(
+        this.buildStore({ path: path2, model }),
+        this.shapesPaths
+      );
+      const introduced = findings.filter(
+        (f) => !baseline.has(_FillGuard.key(f))
+      );
+      const bad = introduced.filter(
+        (f) => f.severity === "error" || f.severity === "warning" && f.path === `${NS.skos}prefLabel`
+      );
+      if (bad.length === 0) break;
+      const proposed = new Set(guarded());
+      const condemned = /* @__PURE__ */ new Map();
+      for (const f of bad) {
+        for (const field of _FillGuard.offendingFields(f, proposed)) {
+          if (!condemned.has(field)) condemned.set(field, f.message);
+        }
+      }
+      const firstBad = bad[0];
+      if (condemned.size === 0 && firstBad !== void 0) {
+        for (const field of guarded()) {
+          condemned.set(field, firstBad.message);
+        }
+      }
+      for (const [field, reason] of condemned) {
+        rejected.push({ field, reason });
+        Reflect.deleteProperty(current, field);
+      }
+    }
+    rejected.sort((a, b) => byCodeUnit(a.field, b.field));
+    return { values: current, rejected };
+  }
+  /** Fold an accepted (written or would-be-written) doc into guard state. */
+  commit(path2, content) {
+    this.models.set(
+      path2,
+      analyzeDoc(content, path2, this.allPaths, this.analyzeOptions)
+    );
+    this.baselineKeys = null;
+  }
+};
+
+// src/graph/commands/fill.ts
+import {
+  completeValidatedJSON,
+  validatorFor
+} from "@hawkeyexl/inference";
+
+// src/graph/llm/cache.ts
+import { JsonCache, buildCacheKey, sha256 } from "@hawkeyexl/inference";
+
+// src/graph/llm/prompt.ts
+var PROMPT_VERSION = 4;
+var TOPIC_TYPES = [
+  "task",
+  "concept",
+  "reference",
+  "learning",
+  "troubleshooting",
+  "form"
+];
+var LIFECYCLE_PHASES = [
+  "administration",
+  "customization",
+  "update",
+  "deployment",
+  "integration",
+  "deinstallation"
+];
+var SOFTWARE_SUBJECTS = ["architecture", "interface", "system-requirement"];
+var labelArray = (description) => ({
+  type: "array",
+  items: { type: "string", minLength: 1 },
+  uniqueItems: true,
+  description
+});
+var enumArray = (values, description) => ({
+  type: "array",
+  items: { enum: values },
+  uniqueItems: true,
+  description
+});
+var FIELD_SCHEMAS = {
+  label: {
+    type: "string",
+    minLength: 1,
+    description: "Preferred label of the single concept this document is primarily about."
+  },
+  "alt-labels": labelArray(
+    "Alternative labels: synonyms, abbreviations, common variants."
+  ),
+  broader: labelArray("Labels of broader (parent) concepts."),
+  narrower: labelArray("Labels of narrower (child) concepts."),
+  "related-concepts": labelArray("Labels of associatively related concepts."),
+  concepts: labelArray("Subject labels for the document, like tags."),
+  type: {
+    enum: TOPIC_TYPES,
+    description: "iiRDS topic type \u2014 the functional kind of this page. Only if the page clearly fits one."
+  },
+  "applies-to": labelArray(
+    "Product/variant names this page applies to. ONLY names the text explicitly states; never guess product names."
+  ),
+  "about-product-lifecycle": enumArray(
+    LIFECYCLE_PHASES,
+    "Software lifecycle phases this page covers, only if clearly evidenced."
+  ),
+  "about-product-aspect": enumArray(
+    SOFTWARE_SUBJECTS,
+    "Software information subjects this page is about, only if clearly evidenced."
+  ),
+  "not-applicable-to": labelArray(
+    "Product/variant names the text EXPLICITLY says this page does NOT apply to. Only with explicit textual evidence."
+  ),
+  "not-about-product-aspect": enumArray(
+    SOFTWARE_SUBJECTS,
+    "Software subjects the text EXPLICITLY says this page is NOT about. Only with explicit textual evidence."
+  )
+};
+var schemaCache = /* @__PURE__ */ new Map();
+var SECTION_FILL_FIELDS = [
+  "type",
+  "applies-to",
+  "about-product-lifecycle",
+  "about-product-aspect",
+  "not-applicable-to",
+  "not-about-product-aspect",
+  "concepts"
+];
+function proposalSchema(fields, options = {}) {
+  const sorted = [...fields].sort();
+  const sortedSections = options.sections ? [...options.sections].filter((f) => SECTION_FILL_FIELDS.includes(f)).sort() : void 0;
+  const lenient = options.lenient === true;
+  const key = [
+    sortedSections ? `s:${sortedSections.join(",")}` : "",
+    lenient ? "l:" : "",
+    sorted.join(",")
+  ].join("|");
+  const memoized = schemaCache.get(key);
+  if (memoized) return memoized;
+  const built = buildProposalSchema(sorted, sortedSections, lenient);
+  schemaCache.set(key, built);
+  return built;
+}
+function buildProposalSchema(fields, sectionFields, lenient) {
+  const scoreSchema = lenient ? {} : { type: "number", minimum: 0, maximum: 1 };
+  const noteSchema = lenient ? {} : { type: "string" };
+  const properties = {};
+  const confidence = {};
+  const reasoning = {};
+  for (const field of fields) {
+    properties[field] = FIELD_SCHEMAS[field];
+    confidence[field] = scoreSchema;
+    reasoning[field] = noteSchema;
+  }
+  properties["confidence"] = {
+    type: "object",
+    additionalProperties: false,
+    properties: confidence,
+    description: "For every field you propose a value for, a confidence 0..1 that the value is correct."
+  };
+  properties["reasoning"] = {
+    type: "object",
+    additionalProperties: false,
+    properties: reasoning,
+    description: "For every field you propose a value for, a one-sentence justification grounded in the page text."
+  };
+  if (sectionFields !== void 0) {
+    const sectionProps = {
+      slug: {
+        type: "string",
+        minLength: 1,
+        description: "The heading slug, copied exactly from the outline. Do not invent one."
+      }
+    };
+    const sectionConfidence = {};
+    const sectionReasoning = {};
+    for (const field of sectionFields) {
+      sectionProps[field] = FIELD_SCHEMAS[field];
+      sectionConfidence[field] = scoreSchema;
+      sectionReasoning[field] = noteSchema;
+    }
+    sectionProps["confidence"] = {
+      type: "object",
+      additionalProperties: false,
+      properties: sectionConfidence,
+      description: "For every field you propose on this section, a confidence 0..1."
+    };
+    sectionProps["reasoning"] = {
+      type: "object",
+      additionalProperties: false,
+      properties: sectionReasoning,
+      description: "For every field you propose on this section, a one-sentence justification."
+    };
+    properties["sections"] = {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["slug"],
+        properties: sectionProps
+      },
+      description: "Per-section metadata. Only for sections whose own content differs meaningfully from the page as a whole; omit a section rather than repeating the page's values."
+    };
+  }
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties
+  };
+}
+var SYSTEM_PROMPT = [
+  "You classify documentation pages into a controlled metadata vocabulary",
+  "(SKOS concepts and iiRDS typing). For each requested field, first reason",
+  "about whether the page's own text supports a value; propose a value only",
+  "when it clearly does, and omit the field otherwise. Reuse the document's",
+  "own terminology; do not invent concepts, product names, or classifications",
+  "the document does not discuss.",
+  "",
+  "For every field you propose a value for, include a `confidence` (0..1) and",
+  "a one-sentence `reasoning` grounded in the text. Score honestly and",
+  "conservatively. Product/variant fields (applies-to, not-applicable-to) and the",
+  "negative fields (not-applicable-to, not-about-product-aspect) require EXPLICIT",
+  "textual evidence \u2014 score them low and prefer to omit unless the page states",
+  "them outright. A field with no value needs no confidence or reasoning."
+].join("\n");
+var EXCERPT_CHARS = 2e3;
+function buildUserPrompt(doc, body, fields, options = {}) {
+  const title = typeof doc.frontmatter["title"] === "string" && doc.frontmatter["title"] || doc.firstH1 || "(untitled)";
+  const tags = doc.frontmatter["tags"] ?? doc.frontmatter["keywords"];
+  const withSections = options.sections === true && doc.sections.length > 0;
+  const outline = doc.sections.map(
+    (s) => `${"  ".repeat(Math.max(0, s.level - 1))}- ${s.title}` + (withSections ? `  [slug: ${s.slug}]` : "")
+  ).join("\n");
+  return [
+    `Propose the following frontmatter fields for this documentation page, with per-field confidence and reasoning: ${fields.join(", ")}.`,
+    withSections ? "Also propose per-section metadata in `sections`, using the exact slug shown in the outline. Include a section ONLY when its own content differs meaningfully from the page as a whole \u2014 repeating the page's values on every heading adds noise, not granularity." : "",
+    "",
+    `Path: ${doc.path}`,
+    `Title: ${title}`,
+    Array.isArray(tags) && tags.length > 0 ? `Existing tags: ${tags.join(", ")}` : "",
+    "",
+    "Heading outline:",
+    outline || "(no headings)",
+    "",
+    "Body excerpt:",
+    body.slice(0, EXCERPT_CHARS)
+  ].join("\n");
+}
+
+// src/graph/llm/cache.ts
+function cacheKey(provider, model, content, fields, sections = false) {
+  return buildCacheKey([
+    provider,
+    model,
+    `v${PROMPT_VERSION}`,
+    // Pre-hashed: documents are large and key parts should stay short.
+    sha256(content),
+    fields.join(","),
+    // Same fields, different request: a sections run sends a different schema
+    // and a different prompt, so its answer must not be served from a
+    // doc-only entry (or the other way round).
+    sections ? "sections" : "doc-only"
+  ]);
+}
+var FillCache = class extends JsonCache {
+  constructor(dir, enabled = true) {
+    super(dir, enabled, "manni");
+  }
+};
+
+// src/graph/llm/provider.ts
+import {
+  makeProvider as makeInferenceProvider
+} from "@hawkeyexl/inference";
+var CONFIG_KEY = "graph.provider";
+var toGraphError = (message) => new GraphError(message);
+function selectProvider2(config, flags = {}) {
+  assertLocalFlag(flags, toGraphError);
+  return selectProvider(flags, [
+    {
+      ...config.provider !== null ? { provider: config.provider } : {},
+      ...config.model !== null ? { model: config.model } : {},
+      origin: CONFIG_KEY
+    },
+    {
+      ...config.providers.provider !== void 0 ? { provider: config.providers.provider } : {},
+      ...config.providers.model !== void 0 ? { model: config.providers.model } : {},
+      origin: "providers.provider"
+    }
+  ]);
+}
+function announceSelection(selection) {
+  const message = localNotice(selection);
+  if (message !== void 0) noticeOnce(message);
+}
+function assertProviderSelection(selection) {
+  assertKnownProvider(selection.provider, toGraphError);
+  assertModelHasProvider(
+    selection.provider,
+    selection.model,
+    CONFIG_KEY,
+    toGraphError
+  );
+}
+function providerSpecFor2(config, selection) {
+  return providerSpecFor(config.providers, selection);
+}
+async function resolveProviderIdentity(config, flags = {}) {
+  const selection = selectProvider2(config, flags);
+  const { provider, model } = selection;
+  assertKnownProvider(provider, toGraphError);
+  assertModelHasProvider(provider, model, CONFIG_KEY, toGraphError);
+  announceSelection(selection);
+  return resolveIdentity(
+    providerSpecFor2(config, { provider, model: model ?? null }),
+    toGraphError
+  );
+}
+function constructProvider(config, identity) {
+  try {
+    return makeInferenceProvider(providerSpecFor2(config, identity));
+  } catch (e) {
+    throw new GraphError(errorMessage(e));
+  }
+}
+async function makeProvider(config, flags = {}) {
+  return constructProvider(config, await resolveProviderIdentity(config, flags));
+}
+
+// src/graph/commands/fill.ts
+var TURN_BUDGET_REASON = "turn budget";
+var RELATION_FIELDS = [
+  "alt-labels",
+  "broader",
+  "narrower",
+  "related-concepts"
+];
+function numberMap(v) {
+  const out = {};
+  if (v && typeof v === "object" && !Array.isArray(v)) {
+    for (const [k, val] of Object.entries(v)) {
+      if (typeof val === "number" && val >= 0 && val <= 1) out[k] = val;
+    }
+  }
+  return out;
+}
+function stringMap(v) {
+  const out = {};
+  if (v && typeof v === "object" && !Array.isArray(v)) {
+    for (const [k, val] of Object.entries(v)) {
+      if (typeof val === "string") out[k] = val;
+    }
+  }
+  return out;
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+var META_PROVENANCE_KEY = "meta-provenance";
+function graphPointer(field) {
+  return `/graph/${field.replace(/~/g, "~0").replace(/\//g, "~1")}`;
+}
+async function runFill(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const config = loadRunConfig(
+    {
+      ...opts.config === void 0 ? {} : { configPath: opts.config },
+      ...opts.noConfig === void 0 ? {} : { noConfig: opts.noConfig },
+      ...opts.paths === void 0 ? {} : { paths: opts.paths },
+      ...opts.collection === void 0 ? {} : { collection: opts.collection }
+    },
+    cwd
+  );
+  const flags = {
+    ...opts.provider === void 0 ? {} : { provider: opts.provider },
+    ...opts.model === void 0 ? {} : { model: opts.model },
+    ...opts.local === void 0 ? {} : { local: opts.local }
+  };
+  const selection = selectProvider2(config, flags);
+  assertProviderSelection(selection);
+  const format = assertInputFormat(opts.paths ?? [], opts.as);
+  const base2 = documentBase(config, opts, cwd);
+  const files = resolveDocumentSet(config, opts, "fill", cwd, base2);
+  const usingStdin = (opts.paths ?? []).includes(STDIN);
+  if (files.length === 0 && !usingStdin) {
+    if (opts.allowEmpty) {
+      return {
+        results: [],
+        turnsUsed: 0,
+        maxTurns: opts.maxTurns ?? config.fill.maxTurns,
+        warnings: [],
+        exitCode: 0
+      };
+    }
+    throw new GraphError(
+      `No input files matched: ${documentSetPatterns(config, opts).join(", ")} (cwd: ${cwd})`
+    );
+  }
+  if (usingStdin && opts.stdinContent === void 0) {
+    throw new GraphError("graph fill was given `-` but no stdin content.");
+  }
+  const stdinContent = usingStdin ? opts.stdinContent : void 0;
+  const analyzeOptions = {
+    routes: routesFrom(config, base2),
+    ...format === void 0 ? {} : { format }
+  };
+  let identity;
+  let construct;
+  if (opts.providerInstance) {
+    const injected = opts.providerInstance;
+    identity = { provider: injected.provider(), model: injected.modelName() };
+    construct = () => injected;
+    announceSelection(selection);
+  } else {
+    const resolved = await resolveProviderIdentity(config, flags);
+    identity = resolved;
+    construct = () => constructProvider(config, resolved);
+  }
+  let provider;
+  const getProvider = () => provider ??= construct();
+  const fields = opts.fields ?? config.fill.fields;
+  const withSections = opts.sections ?? config.fill.sections;
+  const sectionFields = withSections ? fields.filter((f) => SECTION_FILL_FIELDS.includes(f)) : void 0;
+  const validateProposal = validatorFor(
+    proposalSchema(fields, { sections: sectionFields, lenient: true })
+  );
+  const cache = new FillCache(
+    resolve6(cwd, config.fill.cacheDir),
+    !opts.noCache
+  );
+  const confidenceThreshold = opts.confidence ?? config.fill.confidenceThreshold;
+  const maxTurns = opts.maxTurns ?? config.fill.maxTurns;
+  const warnings = [];
+  const sectionsUnrecorded = [];
+  const allPaths = new Set(
+    stdinContent === void 0 ? files : [...files, STDIN_PATH]
+  );
+  const results = [];
+  let turnsUsed = 0;
+  const shapesPaths = config.check.shapes.length > 0 ? config.check.shapes.map((p) => resolve6(cwd, p)) : [bundledShapesPath(import.meta.url)];
+  const guardFiles = [
+    .../* @__PURE__ */ new Set([
+      ...config.collections.length > 0 ? resolveDocumentSet(config, {}, "fill", cwd, base2) : [],
+      ...files
+    ])
+  ];
+  const inputs = new Set(files);
+  const formatFor = (path2) => inputs.has(path2) ? format : void 0;
+  const mergeErrors = /* @__PURE__ */ new Map();
+  const view = await openMetaViewPerPage(
+    {
+      ...opts.config === void 0 ? {} : { configPath: opts.config },
+      ...opts.noConfig === void 0 ? {} : { noConfig: opts.noConfig }
+    },
+    cwd,
+    guardFiles,
+    base2,
+    mergeErrors
+  );
+  const mergedTexts = /* @__PURE__ */ new Map();
+  const inline = /* @__PURE__ */ new Map();
+  for (const path2 of guardFiles) {
+    if (mergeErrors.has(path2)) continue;
+    let text;
+    try {
+      text = readFileSync4(resolve6(base2, path2), "utf8");
+    } catch (e) {
+      mergeErrors.set(path2, e);
+      continue;
+    }
+    let asMetaReadsIt;
+    try {
+      asMetaReadsIt = await mergedText(
+        view,
+        path2,
+        text,
+        formatOf(path2, formatFor(path2))
+      );
+    } catch (e) {
+      mergeErrors.set(path2, e);
+      continue;
+    }
+    mergedTexts.set(path2, asMetaReadsIt);
+    if (asMetaReadsIt !== text) inline.set(path2, asMetaReadsIt);
+  }
+  if (stdinContent !== void 0) inline.set(STDIN_PATH, stdinContent);
+  const guard = !opts.noValidateGraph && config.fill.validateGraph ? FillGuard.create(
+    guardFiles.filter((path2) => !mergeErrors.has(path2)),
+    base2,
+    { ...config, routes: routesFrom(config, base2) },
+    shapesPaths,
+    opts.force ?? false,
+    {
+      inline,
+      ...format === void 0 ? {} : { format },
+      inputs: /* @__PURE__ */ new Set([...files, STDIN_PATH])
+    }
+  ) : void 0;
+  if (guard) {
+    const leftOut = [
+      ...guardFiles.filter((path2) => !inputs.has(path2) && mergeErrors.has(path2)),
+      ...guard.unreadable.filter((path2) => !inputs.has(path2) && path2 !== STDIN_PATH)
+    ].sort(byCodeUnit);
+    if (leftOut.length > 0) {
+      warn(
+        `The graph check left out ${String(leftOut.length)} page${leftOut.length === 1 ? "" : "s"} it could not read: ${leftOut.join(", ")}. Proposals were vetted without them. \`manni meta validate\` says what is wrong with each.`
+      );
+    }
+  }
+  for (const path2 of files) {
+    const absPath = resolve6(base2, path2);
+    let content;
+    try {
+      content = readFileSync4(absPath, "utf8");
+    } catch (e) {
+      throw new GraphError(
+        `cannot read ${path2}: ${errorMessage(e)}`
+      );
+    }
+    try {
+      results.push(await fillOne(path2, absPath, content));
+    } catch (e) {
+      results.push({
+        path: path2,
+        status: "error",
+        fields: [],
+        preserved: [],
+        cached: false,
+        error: errorMessage(e)
+      });
+    }
+  }
+  let stdinDocument;
+  if (stdinContent !== void 0) {
+    try {
+      const result = await fillOne(STDIN_PATH, void 0, stdinContent);
+      results.push(result);
+      stdinDocument = result.filledContent ?? stdinContent;
+      Reflect.deleteProperty(result, "filledContent");
+    } catch (e) {
+      results.push({
+        path: STDIN_PATH,
+        status: "error",
+        fields: [],
+        preserved: [],
+        cached: false,
+        error: errorMessage(e)
+      });
+    }
+  }
+  if (sectionsUnrecorded.length > 0) {
+    warnings.push(
+      "Section metadata was written but is NOT recorded in meta-provenance: /graph/sections is one of the three hand-curated pointers graph refuses, with /graph/revision-of and /graph/derived-from, so recording it would make `manni graph check` report an error. Review section values by hand \u2014 the review queue will not list them."
+    );
+  }
+  const hasErrors = results.some((r) => r.status === "error");
+  return {
+    results,
+    turnsUsed,
+    maxTurns,
+    warnings,
+    exitCode: hasErrors ? 1 : 0,
+    ...stdinDocument === void 0 ? {} : { stdinDocument }
+  };
+  async function fillOne(path2, absPath, content) {
+    if (frontmatterKind(content) === "unsupported") {
+      throw new GraphError(
+        "only YAML frontmatter can be edited (found a TOML/JSON fence) \u2014 exclude this file or convert its frontmatter"
+      );
+    }
+    const effective = absPath === void 0 ? content : mergedTexts.get(path2);
+    if (effective === void 0) {
+      const failure = mergeErrors.get(path2);
+      throw failure instanceof Error ? failure : new GraphError(errorMessage(failure));
+    }
+    if (absPath !== void 0) {
+      const own2 = ownMetadata(content).data;
+      if (GRAPH_KEY in own2) {
+        const home = await view.home(path2, own2, GRAPH_KEY);
+        if (home.kind !== "unowned") {
+          throw new GraphError(
+            `"${GRAPH_KEY}" is owned by manifest ${home.file} (collection ${home.collection}); remove it from the document`
+          );
+        }
+      }
+    }
+    const present = new Set(existingGraphFields(effective));
+    const missing = opts.force ? fields : fields.filter((f) => !present.has(f));
+    if (missing.length === 0 && !withSections) {
+      return {
+        path: path2,
+        status: "complete",
+        fields: [],
+        preserved: [],
+        cached: false
+      };
+    }
+    const key = cacheKey(
+      identity.provider,
+      identity.model,
+      content,
+      missing,
+      withSections
+    );
+    let proposal = cache.get(key);
+    if (proposal !== void 0 && !validateProposal(proposal)) {
+      proposal = void 0;
+    }
+    const cached = proposal !== void 0;
+    let docModel;
+    const doc = () => docModel ??= analyzeDoc(effective, path2, allPaths, analyzeOptions);
+    if (proposal === void 0) {
+      if (maxTurns !== null && turnsUsed >= maxTurns) {
+        return {
+          path: path2,
+          status: "skipped",
+          reason: TURN_BUDGET_REASON,
+          fields: [],
+          preserved: [],
+          cached: false
+        };
+      }
+      turnsUsed++;
+      const run = await completeValidatedJSON({
+        provider: getProvider(),
+        system: SYSTEM_PROMPT,
+        user: buildUserPrompt(doc(), content, missing, {
+          sections: withSections
+        }),
+        schema: proposalSchema(missing, { sections: sectionFields }),
+        validate: validateProposal,
+        temperature: config.fill.temperature
+      });
+      if (run.result === void 0) {
+        throw new Error(run.error ?? "provider returned no proposal");
+      }
+      proposal = run.result;
+      cache.set(key, proposal);
+    }
+    const confidence = numberMap(proposal["confidence"]);
+    const reasoning = stringMap(proposal["reasoning"]);
+    const narrowed = Object.fromEntries(
+      Object.entries(proposal).filter(([k]) => missing.includes(k)).map(([k, v]) => [k, Array.isArray(v) ? [...new Set(v)] : v])
+    );
+    const unknownSlugs = [];
+    if (withSections) {
+      const realSlugs = new Set(doc().sections.map((s) => s.slug));
+      for (const entry2 of Array.isArray(proposal["sections"]) ? proposal["sections"] : []) {
+        const slug = typeof entry2["slug"] === "string" ? entry2["slug"] : "";
+        if (!realSlugs.has(slug)) {
+          if (slug) unknownSlugs.push(slug);
+          continue;
+        }
+        const entryConfidence = numberMap(entry2["confidence"]);
+        const entryReasoning = stringMap(entry2["reasoning"]);
+        for (const [field, value] of Object.entries(entry2)) {
+          if (!SECTION_FILL_FIELDS.includes(field)) continue;
+          if (!fields.includes(field)) continue;
+          const name = `sections.${slug}.${field}`;
+          narrowed[name] = Array.isArray(value) ? [...new Set(value)] : value;
+          if (entryConfidence[field] !== void 0)
+            confidence[name] = entryConfidence[field];
+          if (entryReasoning[field] !== void 0)
+            reasoning[name] = entryReasoning[field];
+        }
+      }
+    }
+    const gateLabel = () => {
+      const hasLabel = present.has("label") || typeof narrowed["label"] === "string" && narrowed["label"].length > 0;
+      if (!hasLabel) {
+        for (const field of RELATION_FIELDS) Reflect.deleteProperty(narrowed, field);
+      }
+    };
+    gateLabel();
+    const lowConfidence = [];
+    for (const field of Object.keys(narrowed)) {
+      const c = confidence[field] ?? 0;
+      if (c < confidenceThreshold) {
+        lowConfidence.push({
+          field,
+          confidence: c,
+          ...reasoning[field] ? { reasoning: reasoning[field] } : {}
+        });
+        Reflect.deleteProperty(narrowed, field);
+      }
+    }
+    if (lowConfidence.length > 0) gateLabel();
+    const lowConf = lowConfidence.length > 0 ? { lowConfidence } : {};
+    let rejected;
+    if (guard) {
+      const vetted = await guard.vet(path2, effective, narrowed);
+      if (vetted.rejected.length > 0) {
+        rejected = vetted.rejected.map((r) => r.field);
+        for (const field of rejected) Reflect.deleteProperty(narrowed, field);
+        gateLabel();
+      }
+    }
+    const realFields = Object.keys(narrowed).filter((k) => {
+      const v = narrowed[k];
+      return v !== void 0 && v !== null && !(Array.isArray(v) && v.length === 0);
+    });
+    if (realFields.length === 0) {
+      return {
+        path: path2,
+        status: "nothing-proposed",
+        fields: [],
+        preserved: [],
+        ...rejected ? { rejected } : {},
+        ...unknownSlugs.length > 0 ? { unknownSections: unknownSlugs } : {},
+        ...lowConf,
+        cached
+      };
+    }
+    let provenanceList;
+    if (config.fill.writeProvenance) {
+      const recordable = realFields.filter((f) => !f.includes(".")).sort();
+      if (recordable.length < realFields.length) sectionsUnrecorded.push(path2);
+      const held = existingMetaProvenance(effective);
+      const priorEntry = Array.isArray(held) ? held.find(
+        (e) => !!e && typeof e === "object" && !Array.isArray(e) && e["generated-by"] === identity.model
+      ) : void 0;
+      const priorConfidence = numberMap(priorEntry?.["confidence"]);
+      const proposed = recordable.map((f) => {
+        const name = graphPointer(f);
+        const c = confidence[f];
+        return {
+          name,
+          confidence: c === void 0 ? priorConfidence[name] ?? 0 : round2(c)
+        };
+      });
+      const unscored = recordable.map((f) => [f, graphPointer(f)]).filter(
+        ([f, name]) => confidence[f] === void 0 && priorConfidence[name] === void 0
+      ).map(([, name]) => name);
+      const merged = mergeMetaProvenance(
+        held,
+        identity.model,
+        "fields",
+        proposed
+      );
+      if (merged) {
+        for (const name of unscored)
+          Reflect.deleteProperty(merged.entry.confidence, name);
+        provenanceList = merged.list;
+      }
+    }
+    const applied = applyGraphFields(effective, path2, narrowed, {
+      force: opts.force
+    });
+    const reportedFields = applied.applied;
+    if (reportedFields.length === 0) {
+      return {
+        path: path2,
+        status: "nothing-proposed",
+        fields: [],
+        preserved: applied.skipped,
+        ...rejected ? { rejected } : {},
+        ...unknownSlugs.length > 0 ? { unknownSections: unknownSlugs } : {},
+        ...lowConf,
+        cached
+      };
+    }
+    const own = ownMetadata(content).data;
+    const graphHome = absPath === void 0 ? void 0 : await view.home(path2, own, GRAPH_KEY);
+    const provenanceHome = absPath === void 0 || provenanceList === void 0 ? void 0 : await view.home(path2, own, META_PROVENANCE_KEY);
+    const graphTarget = writeTarget(path2, graphHome, GRAPH_KEY);
+    if (typeof graphTarget === "string") throw new GraphError(graphTarget);
+    let provenanceTarget = writeTarget(path2, provenanceHome, META_PROVENANCE_KEY);
+    if (typeof provenanceTarget === "string") {
+      warnings.push(`${provenanceTarget} The fill of ${path2} is not recorded.`);
+      provenanceList = void 0;
+      provenanceTarget = null;
+    }
+    const pageKeys = {};
+    if (provenanceList !== void 0 && provenanceTarget === null) {
+      pageKeys[META_PROVENANCE_KEY] = provenanceList;
+    }
+    const pageContent = applyGraphFields(
+      content,
+      path2,
+      graphTarget === null ? narrowed : {},
+      { force: opts.force, page: pageKeys }
+    ).content;
+    const manifestWrites = [];
+    if (graphTarget !== null) {
+      manifestWrites.push({
+        home: graphTarget,
+        key: GRAPH_KEY,
+        value: ownMetadata(applied.content).data[GRAPH_KEY]
+      });
+    }
+    if (provenanceList !== void 0 && provenanceTarget !== null) {
+      manifestWrites.push({
+        home: provenanceTarget,
+        key: META_PROVENANCE_KEY,
+        value: provenanceList
+      });
+    }
+    const manifests = await spliceAll(manifestWrites);
+    if (!opts.dryRun && absPath !== void 0) {
+      if (pageContent !== content) writeFileSync2(absPath, pageContent, "utf8");
+      for (const m of manifests) {
+        if (m.text !== m.before) {
+          await writeFileAtomic(m.absPath, m.text, { createParents: true });
+        }
+      }
+    }
+    guard?.commit(path2, applied.content);
+    return {
+      path: path2,
+      status: opts.dryRun ? "proposed" : "filled",
+      fields: reportedFields,
+      preserved: applied.skipped,
+      ...rejected ? { rejected } : {},
+      ...unknownSlugs.length > 0 ? { unknownSections: unknownSlugs } : {},
+      ...lowConf,
+      cached,
+      ...absPath === void 0 && !opts.dryRun ? { filledContent: pageContent } : {}
+    };
+  }
+}
+var GRAPH_KEY = "graph";
+function writeTarget(path2, home, key) {
+  if (home === void 0 || home.kind === "unowned") return null;
+  if (home.kind === "url") return urlManifestMessage(key, home.file);
+  if (home.entry === void 0) {
+    return `${path2} carries no ${home.join}, which ${home.file} joins on, so its ${key} has no entry there.`;
+  }
+  return {
+    file: home.file,
+    absPath: home.absPath,
+    join: home.join,
+    entry: home.entry,
+    perPage: home.perPage
+  };
+}
+async function spliceAll(writes) {
+  const out = /* @__PURE__ */ new Map();
+  for (const w of writes) {
+    let held = out.get(w.home.absPath);
+    if (held === void 0) {
+      let before;
+      try {
+        before = await readFile(w.home.absPath, "utf8");
+      } catch (e) {
+        if (!(w.home.perPage && isMissing(e))) {
+          throw new GraphError(`${w.home.file} could not be read: ${errorMessage(e)}`);
+        }
+        before = "";
+      }
+      held = { absPath: w.home.absPath, before, text: before };
+      out.set(w.home.absPath, held);
+    }
+    try {
+      held.text = spliceManifestValue(held.text, {
+        entry: w.home.entry,
+        key: w.key,
+        value: w.value,
+        join: w.home.join,
+        file: w.home.file
+      }).text;
+    } catch (e) {
+      throw new GraphError(errorMessage(e));
+    }
+  }
+  return [...out.values()];
+}
+async function mergedText(view, path2, content, format) {
+  if (frontmatterKind(content) === "unsupported") return content;
+  let own;
+  try {
+    own = ownMetadata(content);
+  } catch (e) {
+    throw new GraphError(`${path2}: ${errorMessage(e)}`);
+  }
+  const { supplied } = await mergePage(view, path2, own.data, own.present, format);
+  if (Object.keys(supplied).length === 0) return content;
+  return applyGraphFields(content, path2, {}, { page: supplied }).content;
+}
+async function openMetaViewPerPage(source, cwd, paths, base2, failures) {
+  try {
+    return await openMetaView(source, cwd, paths, base2);
+  } catch (whole) {
+    await openMetaView(source, cwd, [], base2);
+    const readable = [];
+    for (const path2 of paths) {
+      try {
+        await openMetaView(source, cwd, [path2], base2);
+        readable.push(path2);
+      } catch (e) {
+        failures.set(path2, e);
+      }
+    }
+    if (readable.length === paths.length) throw whole;
+    return openMetaView(source, cwd, readable, base2);
+  }
+}
+function renderFill(report, format) {
+  if (format === "json") {
+    return JSON.stringify({ ...report, stdinDocument: void 0 }, null, 2);
+  }
+  const lines = [];
+  for (const r of report.results) {
+    const dropped = r.rejected && r.rejected.length > 0 ? ` [graph check rejected: ${r.rejected.join(", ")}]` : "";
+    const lowConf = r.lowConfidence && r.lowConfidence.length > 0 ? ` [low confidence, not written: ${r.lowConfidence.map((l) => `${l.field} ${l.confidence.toFixed(2)}`).join(", ")}]` : "";
+    const unknown = r.unknownSections && r.unknownSections.length > 0 ? ` [no such section: ${r.unknownSections.join(", ")}]` : "";
+    switch (r.status) {
+      case "filled":
+        lines.push(
+          `filled    ${r.path} (${r.fields.join(", ")})${r.cached ? " [cached]" : ""}${dropped}${unknown}${lowConf}`
+        );
+        break;
+      case "proposed":
+        lines.push(
+          `proposed  ${r.path} (${r.fields.join(", ")})${r.cached ? " [cached]" : ""}${dropped}${unknown}${lowConf} \u2014 dry run, not written`
+        );
+        break;
+      case "complete":
+        lines.push(`complete  ${r.path}`);
+        break;
+      case "nothing-proposed":
+        lines.push(
+          `no-op     ${r.path} (model proposed nothing new)${dropped}${unknown}${lowConf}`
+        );
+        break;
+      case "skipped":
+        lines.push(`skipped   ${r.path} (${r.reason ?? "not processed"})`);
+        break;
+      case "error":
+        lines.push(`error     ${r.path}: ${r.error ?? ""}`);
+        break;
+    }
+  }
+  if (report.maxTurns !== null && report.results.some((r) => r.status === "skipped")) {
+    lines.push(
+      "",
+      `--max-turns reached (${report.maxTurns}); some pages were not processed.`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/graph/commands/embed.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import path, { dirname as dirname2, join as join2, resolve as resolve7 } from "node:path";
+
+// src/graph/core/vector-index.ts
+var MAGIC = new Uint8Array([77, 71, 82, 86]);
+var FORMAT_VERSION = 2;
+var HEADER_OFFSET = 12;
+var VectorIndexError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "VectorIndexError";
+  }
+};
+function normalize(vector) {
+  let sum = 0;
+  for (const value of vector) sum += value * value;
+  if (sum === 0) return vector;
+  const inv = 1 / Math.sqrt(sum);
+  vector.set(vector.map((value) => value * inv));
+  return vector;
+}
+function encodeVectorIndex(entries, meta) {
+  const sorted = [...entries].sort((a, b) => byCodeUnit(a.id, b.id));
+  const dims = sorted[0]?.vector.length ?? 0;
+  for (const entry2 of sorted) {
+    if (entry2.vector.length !== dims) {
+      throw new VectorIndexError(
+        `Inconsistent vector dimensions: ${entry2.id} has ${entry2.vector.length}, expected ${dims}.`
+      );
+    }
+  }
+  const header = {
+    model: meta.model,
+    dtype: meta.dtype,
+    dims,
+    count: sorted.length,
+    ids: sorted.map((e) => e.id),
+    source: meta.source,
+    language: meta.language
+  };
+  const headerBytes = new TextEncoder().encode(JSON.stringify(header));
+  const payloadBytes = sorted.length * dims * 4;
+  const out = new Uint8Array(HEADER_OFFSET + headerBytes.length + payloadBytes);
+  const view = new DataView(out.buffer);
+  out.set(MAGIC, 0);
+  view.setUint32(4, FORMAT_VERSION, true);
+  view.setUint32(8, headerBytes.length, true);
+  out.set(headerBytes, HEADER_OFFSET);
+  let offset = HEADER_OFFSET + headerBytes.length;
+  for (const entry2 of sorted) {
+    const vector = normalize(Float32Array.from(entry2.vector));
+    for (const value of vector) {
+      view.setFloat32(offset, value, true);
+      offset += 4;
+    }
+  }
+  return out;
+}
+function decodeVectorIndex(bytes) {
+  if (bytes.length < HEADER_OFFSET) {
+    throw new VectorIndexError("Not a manni graph vector index: file is too short.");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (!MAGIC.every((byte, i) => bytes[i] === byte)) {
+    throw new VectorIndexError(
+      "Not a manni graph vector index: bad magic \u2014 is this the right file?"
+    );
+  }
+  const version = view.getUint32(4, true);
+  if (version !== FORMAT_VERSION) {
+    throw new VectorIndexError(
+      `Unsupported vector index version ${version} (this build reads ${FORMAT_VERSION}) \u2014 re-run \`manni graph embed\`.`
+    );
+  }
+  const headerLength = view.getUint32(8, true);
+  if (HEADER_OFFSET + headerLength > bytes.length) {
+    throw new VectorIndexError("Vector index is truncated: header overruns.");
+  }
+  let header;
+  try {
+    header = JSON.parse(
+      new TextDecoder().decode(
+        bytes.subarray(HEADER_OFFSET, HEADER_OFFSET + headerLength)
+      )
+    );
+  } catch {
+    throw new VectorIndexError("Vector index header is not valid JSON.");
+  }
+  if (!Array.isArray(header.ids) || typeof header.dims !== "number" || header.ids.length !== header.count) {
+    throw new VectorIndexError("Vector index header is malformed.");
+  }
+  const start = HEADER_OFFSET + headerLength;
+  const expected = header.count * header.dims * 4;
+  if (bytes.length - start !== expected) {
+    throw new VectorIndexError(
+      `Vector index is truncated: expected ${expected} payload bytes, found ${bytes.length - start}.`
+    );
+  }
+  const vectors = new Float32Array(header.count * header.dims);
+  for (let i = 0; i < vectors.length; i++) {
+    vectors[i] = view.getFloat32(start + i * 4, true);
+  }
+  return { header, vectors };
+}
+
+// src/graph/embed/local.ts
+var EmbedderUnavailableError = class extends Error {
+  constructor(detail) {
+    super(
+      `Local embeddings need @huggingface/transformers, which is an optional peer dependency.
+  Install it:  npm install @huggingface/transformers
+  (${detail})`
+    );
+    this.name = "EmbedderUnavailableError";
+  }
+};
+async function loadTransformers(injected) {
+  if (injected) return injected;
+  try {
+    return await import("@huggingface/transformers");
+  } catch (e) {
+    throw new EmbedderUnavailableError(
+      errorMessage(e)
+    );
+  }
+}
+async function createLocalEmbedder(options = {}) {
+  const model = options.model ?? DEFAULT_MODEL;
+  const dtype = options.dtype ?? "q8";
+  const role = options.role ?? "passage";
+  const profile = profileFor(model);
+  const transformers = await loadTransformers(options.transformers);
+  if (transformers.env?.backends?.onnx?.wasm) {
+    transformers.env.backends.onnx.wasm.numThreads = 1;
+  }
+  const extractor = await transformers.pipeline("feature-extraction", model, {
+    // No `device`: its accepted values are disjoint across platforms, so any
+    // hardcoded choice throws on one of them (ADR 01025).
+    ...options.device === void 0 ? {} : { device: options.device },
+    dtype
+  });
+  let dims = 0;
+  return {
+    model,
+    dtype,
+    get dims() {
+      return dims;
+    },
+    async embed(text) {
+      const output = await extractor(withPrefix(profile, role, text), {
+        pooling: "mean",
+        normalize: true
+      });
+      const data = Float32Array.from(output.data);
+      dims = data.length;
+      return data;
+    }
+  };
+}
+
+// src/graph/embed/mock.ts
+function fnv1a(text, seed) {
+  let hash = (2166136261 ^ seed) >>> 0;
+  for (let i = 0; i < text.length; i++) {
+    hash = (hash ^ text.charCodeAt(i)) >>> 0;
+    hash = hash + ((hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24)) >>> 0;
+  }
+  return hash >>> 0;
+}
+function createMockEmbedder(options = {}) {
+  const dims = options.dims ?? 8;
+  const model = options.model ?? "mock";
+  const dtype = options.dtype ?? "mock";
+  return {
+    model,
+    dtype,
+    dims,
+    embed(text) {
+      const vector = new Float32Array(dims);
+      for (let i = 0; i < dims; i++) {
+        vector[i] = fnv1a(text, i) / 4294967296 * 2 - 1;
+      }
+      return Promise.resolve(vector);
+    }
+  };
+}
+
+// src/graph/commands/embed.ts
+function embedText(entry2) {
+  return [entry2.title, entry2.labels, entry2.description, entry2.text].filter((part) => part !== void 0 && part !== "").join("\n\n");
+}
+function sha2562(text) {
+  return createHash2("sha256").update(text, "utf8").digest("hex");
+}
+var VectorCache = class {
+  constructor(dir, enabled) {
+    this.dir = dir;
+    this.enabled = enabled;
+  }
+  dir;
+  enabled;
+  path(key) {
+    return join2(this.dir, `${key}.json`);
+  }
+  get(key) {
+    if (!this.enabled) return void 0;
+    const file = this.path(key);
+    if (!existsSync3(file)) return void 0;
+    try {
+      const parsed = JSON.parse(readFileSync5(file, "utf8"));
+      return Array.isArray(parsed) ? Float32Array.from(parsed) : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  set(key, vector) {
+    if (!this.enabled) return;
+    mkdirSync2(this.dir, { recursive: true });
+    writeFileSync3(this.path(key), JSON.stringify([...vector]), "utf8");
+  }
+};
+async function makeEmbedder(opts, model, dtype) {
+  if (opts.embedder) return opts.embedder;
+  if (model === "mock") return createMockEmbedder({ dtype });
+  try {
+    return await createLocalEmbedder({ model, dtype, role: "passage" });
+  } catch (e) {
+    if (e instanceof EmbedderUnavailableError) {
+      throw new GraphError(e.message);
+    }
+    throw new GraphError(
+      `Failed to load embedding model ${model}: ${errorMessage(e)}`
+    );
+  }
+}
+function manifestRelativePath(indexDir, outPath, pathApi = path) {
+  const rel = pathApi.relative(indexDir, outPath);
+  const recorded = rel.split(pathApi.sep).join("/");
+  if (pathApi.isAbsolute(rel) || !isSafeRelativePath(recorded)) {
+    throw new GraphError(
+      `Cannot record vectors at ${outPath}: the localization manifest needs a path relative to ${indexDir}. Write the sidecars on the index's drive.`
+    );
+  }
+  return recorded;
+}
+async function runEmbed(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const config = loadRunConfig(
+    {
+      ...opts.config === void 0 ? {} : { configPath: opts.config },
+      ...opts.noConfig === void 0 ? {} : { noConfig: opts.noConfig }
+    },
+    cwd
+  );
+  const graphPath = resolve7(cwd, opts.graph ?? config.out);
+  const indexDir = opts.index ? resolve7(cwd, opts.index) : dirname2(graphPath);
+  const manifestPath = join2(indexDir, LOCALIZATIONS_FILENAME);
+  if (!existsSync3(manifestPath)) {
+    throw new GraphError(
+      `Localization manifest not found: ${manifestPath} \u2014 run \`manni graph export search\` first.`
+    );
+  }
+  const manifest = parseLocalizations(readFileSync5(manifestPath, "utf8"));
+  if (!manifest) {
+    throw new GraphError(
+      `Not a manni graph localization manifest: ${manifestPath} \u2014 re-run \`manni graph export search\`.`
+    );
+  }
+  const outSetting = opts.out ?? config.embed.out;
+  const outDir = outSetting ? resolve7(cwd, outSetting) : indexDir;
+  mkdirSync2(outDir, { recursive: true });
+  const cache = new VectorCache(
+    resolve7(cwd, config.embed.cacheDir),
+    !opts.noCache
+  );
+  const embedders = /* @__PURE__ */ new Map();
+  const getEmbedder = (model, dtype) => {
+    const key = JSON.stringify([model, dtype]);
+    const existing = embedders.get(key);
+    if (existing) return existing;
+    const built = makeEmbedder(opts, model, dtype);
+    embedders.set(key, built);
+    return built;
+  };
+  const languages = [];
+  const updated = [];
+  for (const entry2 of manifest.languages) {
+    const indexPath = join2(indexDir, entry2.search.path);
+    if (!existsSync3(indexPath)) {
+      throw new GraphError(
+        `Search index not found: ${indexPath} \u2014 the manifest names it; re-run \`manni graph export search\`.`
+      );
+    }
+    const raw = readFileSync5(indexPath, "utf8");
+    const source = `sha256:${sha2562(raw)}`;
+    if (entry2.search.digest !== source) {
+      throw new GraphError(
+        `Stale manifest: ${entry2.search.path} does not match the digest recorded for "${entry2.language}" \u2014 re-run \`manni graph export search\`.`
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (e) {
+      throw new GraphError(
+        `Failed to parse ${indexPath}: ${errorMessage(e)} \u2014 re-run \`manni graph export search\`.`
+      );
+    }
+    const entries = parsed?.entries;
+    if (!Array.isArray(entries)) {
+      throw new GraphError(
+        `Not a manni graph search index: ${indexPath} \u2014 expected an \`entries\` array.`
+      );
+    }
+    const wanted = canonicalLanguageTag(entry2.language);
+    const perLanguage = Object.entries(config.embed.byLanguage).find(
+      ([tag]) => canonicalLanguageTag(tag) === wanted
+    )?.[1];
+    const model = opts.model ?? perLanguage?.model ?? config.embed.model;
+    const dtype = opts.dtype ?? perLanguage?.dtype ?? config.embed.dtype;
+    const identity = opts.embedder ? { model: opts.embedder.model, dtype: opts.embedder.dtype } : { model, dtype };
+    const vectors = [];
+    let embedded = 0;
+    let cached = 0;
+    for (const item of entries) {
+      const text = embedText(item);
+      if (text === "") continue;
+      const key = sha2562(
+        JSON.stringify([identity.model, identity.dtype, text])
+      );
+      let vector = cache.get(key);
+      if (vector) {
+        cached += 1;
+      } else {
+        vector = await (await getEmbedder(model, dtype)).embed(text);
+        cache.set(key, vector);
+        embedded += 1;
+      }
+      vectors.push({ id: item.id, vector });
+    }
+    const filename = vectorIndexFilename(entry2.language);
+    const outPath = join2(outDir, filename);
+    const manifestRelative = manifestRelativePath(indexDir, outPath);
+    writeFileSync3(
+      outPath,
+      encodeVectorIndex(vectors, {
+        model: identity.model,
+        dtype: identity.dtype,
+        source,
+        language: entry2.language
+      })
+    );
+    const dims = vectors[0]?.vector.length ?? 0;
+    languages.push({
+      language: entry2.language,
+      outPath,
+      model: identity.model,
+      dims,
+      embedded,
+      cached,
+      total: vectors.length
+    });
+    updated.push({
+      ...entry2,
+      vectors: {
+        path: manifestRelative,
+        model: identity.model,
+        dtype: identity.dtype,
+        dims,
+        count: vectors.length
+      }
+    });
+  }
+  writeFileSync3(
+    manifestPath,
+    emitLocalizations({ version: 1, languages: updated }),
+    "utf8"
+  );
+  return {
+    manifestPath,
+    languages,
+    embedded: languages.reduce((n, l) => n + l.embedded, 0),
+    cached: languages.reduce((n, l) => n + l.cached, 0),
+    total: languages.reduce((n, l) => n + l.total, 0)
+  };
+}
+function renderEmbed(report, format) {
+  if (format === "json") return JSON.stringify(report, null, 2);
+  const lines = report.languages.map(
+    (l) => `  ${l.language}: ${l.total} vector${l.total === 1 ? "" : "s"} (${l.dims}-d, ${l.model}) -> ${l.outPath}`
+  );
+  if (lines.length === 0) lines.push("  (no languages in the manifest)");
+  const n = report.languages.length;
+  return [
+    // Not "beside": `-o` may put the sidecars in a different directory from
+    // the manifest, and each line below names the path it actually wrote.
+    `Wrote ${n} sidecar${n === 1 ? "" : "s"}, recorded in ${report.manifestPath}`,
+    ...lines,
+    `  ${report.embedded} embedded, ${report.cached} from cache`
+  ].join("\n");
+}
+
+// src/graph/commands/search.ts
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "node:fs";
+import { dirname as dirname3, join as join3, resolve as resolve8 } from "node:path";
+
+// src/graph/runtime/vector.ts
+var VectorMismatchError = class extends Error {
+  reason;
+  constructor(mismatch) {
+    super(mismatch.detail);
+    this.name = "VectorMismatchError";
+    this.reason = mismatch.reason;
+  }
+};
+async function searchIndexDigest2(raw) {
+  const webCrypto = globalThis.crypto;
+  const subtle = webCrypto?.subtle;
+  if (!subtle) {
+    throw new Error(
+      "searchIndexDigest needs Web Crypto (globalThis.crypto.subtle), which is unavailable here \u2014 a page served over plain HTTP does not get it."
+    );
+  }
+  const digest = await subtle.digest("SHA-256", new TextEncoder().encode(raw));
+  const hex = [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `sha256:${hex}`;
+}
+function createVectorIndex(bytes) {
+  const { header, vectors } = decodeVectorIndex(bytes);
+  const { dims, ids } = header;
+  return {
+    model: header.model,
+    dtype: header.dtype,
+    dims,
+    source: header.source,
+    size: () => ids.length,
+    idAt: (row) => ids[row],
+    check(expected) {
+      if (expected.model !== void 0 && expected.model !== header.model) {
+        return {
+          reason: "model",
+          detail: `Vector index was built with ${header.model}, but the embedder is ${expected.model}. Re-run \`manni graph embed\`.`
+        };
+      }
+      if (expected.dtype !== void 0 && expected.dtype !== header.dtype) {
+        return {
+          reason: "dtype",
+          detail: `Vector index was built at dtype ${header.dtype}, but the embedder is at ${expected.dtype} \u2014 different weights are a different function. Re-run \`manni graph embed\`.`
+        };
+      }
+      if (expected.dims !== void 0 && expected.dims !== dims) {
+        return {
+          reason: "dims",
+          detail: `Vector index has ${dims} dimensions, but the embedder produces ${expected.dims}.`
+        };
+      }
+      if (expected.source !== void 0 && expected.source !== header.source) {
+        return {
+          reason: "stale-source",
+          detail: "Vector index was built from a different search index \u2014 the corpus changed. Re-run `manni graph embed`."
+        };
+      }
+      return void 0;
+    },
+    search(query, options = {}) {
+      if (dims === 0 || ids.length === 0) return [];
+      if (query.length !== dims) {
+        throw new VectorMismatchError({
+          reason: "dims",
+          detail: `Query vector has ${query.length} dimensions, but the index has ${dims}.`
+        });
+      }
+      const limit = normalizeLimit(options.limit);
+      if (limit === 0) return [];
+      const minScore = options.minScore ?? 0;
+      const q = normalize(Float32Array.from(query));
+      const scored = [];
+      for (const [row, iri2] of ids.entries()) {
+        const stored = vectors.subarray(row * dims, (row + 1) * dims);
+        let score = 0;
+        for (const [i, value] of q.entries()) score += value * (stored[i] ?? 0);
+        if (score >= minScore) {
+          scored.push({ iri: iri2, score, via: "vector" });
+        }
+      }
+      scored.sort(
+        (a, b) => a.score === b.score ? byCodeUnit(a.iri, b.iri) : b.score - a.score
+      );
+      return scored.slice(0, limit);
+    }
+  };
+}
+function normalizeLimit(limit) {
+  return typeof limit === "number" && Number.isInteger(limit) && limit >= 0 ? limit : 10;
+}
+
+// src/graph/runtime/trace.ts
+function createTrace() {
+  return { entry: [], hops: [], exclusions: [], resolutions: [] };
+}
+function reachedNodes(trace) {
+  const reached = /* @__PURE__ */ new Set();
+  for (const e of trace.entry) reached.add(e.iri);
+  for (const h of trace.hops) reached.add(h.to);
+  return reached;
+}
+
+// src/graph/runtime/entry.ts
+function rrfMerge(rankings, k = 60) {
+  const fused = /* @__PURE__ */ new Map();
+  for (const ranking of rankings) {
+    ranking.forEach((candidate, i) => {
+      const current = fused.get(candidate.iri) ?? {
+        score: 0,
+        vias: /* @__PURE__ */ new Set()
+      };
+      current.score += 1 / (k + i + 1);
+      current.vias.add(candidate.via);
+      fused.set(candidate.iri, current);
+    });
+  }
+  return [...fused.entries()].map(([iri2, { score, vias }]) => {
+    const [only] = vias;
+    return {
+      iri: iri2,
+      score,
+      via: vias.size === 1 && only !== void 0 ? only : "hybrid"
+    };
+  }).sort(
+    (a, b) => a.score === b.score ? byCodeUnit(a.iri, b.iri) : b.score - a.score
+  );
+}
+async function findEntry(query, options) {
+  const trace = options.trace ?? createTrace();
+  const limit = typeof options.limit === "number" && Number.isInteger(options.limit) && options.limit >= 0 ? options.limit : 10;
+  const lexical = options.lexical.search(query, { limit });
+  const embedder = options.embedder;
+  const embed = embedder ? (q) => embedder.embed(q) : options.embedQuery;
+  let vector = [];
+  if (options.vectors && embed && query.trim() !== "") {
+    const mismatch = options.vectors.check({
+      ...options.embedder ? { model: options.embedder.model, dtype: options.embedder.dtype } : {},
+      // Staleness is checked whichever way the query is embedded — it is a
+      // property of the corpus, not of the embedder, so even the unverified
+      // `embedQuery` path gets it when the caller supplies a digest.
+      ...options.source === void 0 ? {} : { source: options.source }
+    });
+    if (mismatch) throw new VectorMismatchError(mismatch);
+    const queryVector = await embed(query);
+    vector = options.vectors.search(queryVector, { limit });
+  }
+  const rankings = vector.length > 0 ? [lexical, vector] : [lexical];
+  const candidates = rrfMerge(rankings).slice(0, limit);
+  for (const candidate of candidates) trace.entry.push(candidate);
+  return { candidates, lexical, vector, trace };
+}
+
+// src/graph/runtime/lexical.ts
+import MiniSearch from "minisearch";
+function createLexicalIndex(input) {
+  const doc = typeof input === "string" ? JSON.parse(input) : input;
+  const entries = Array.isArray(doc?.entries) ? doc.entries : [];
+  const mini = new MiniSearch({
+    fields: ["title", "labels", "description", "text"],
+    storeFields: ["id"],
+    idField: "id",
+    // Titles and labels are the strongest signal that a node *is* the subject;
+    // body text is evidence it merely mentions it.
+    searchOptions: {
+      boost: { title: 3, labels: 2, description: 1.5 },
+      prefix: true,
+      fuzzy: 0.2
+    }
+  });
+  mini.addAll(entries);
+  const byIri = new Map(entries.map((e) => [e.id, e]));
+  return {
+    size: () => entries.length,
+    entry: (iri2) => byIri.get(iri2),
+    search(query, options = {}) {
+      const trimmed = query.trim();
+      if (trimmed === "") return [];
+      const hits = mini.search(trimmed);
+      hits.sort(
+        (a, b) => a.score === b.score ? byCodeUnit(String(a.id), String(b.id)) : b.score - a.score
+      );
+      return hits.slice(0, options.limit ?? 10).map((h) => ({ iri: String(h.id), score: h.score, via: "lexical" }));
+    }
+  };
+}
+
+// src/graph/commands/search.ts
+var SEARCH_MODES = ["lexical", "hybrid", "vector"];
+function loadSearchIndex(indexPath) {
+  const raw = readFileSync6(indexPath, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new GraphError(
+      `Failed to parse ${indexPath}: ${errorMessage(e)} \u2014 re-run \`manni graph export search\`.`
+    );
+  }
+  const entries = parsed?.entries;
+  if (!Array.isArray(entries)) {
+    throw new GraphError(
+      `Not a manni graph search index: ${indexPath} \u2014 expected an \`entries\` array; re-run \`manni graph export search\`.`
+    );
+  }
+  return {
+    doc: parsed,
+    // Same recipe `manni graph embed` uses, so the two digests are comparable.
+    source: `sha256:${createHash3("sha256").update(raw, "utf8").digest("hex")}`
+  };
+}
+function resolveLocalization(indexDir, lang) {
+  const manifestPath = join3(indexDir, LOCALIZATIONS_FILENAME);
+  if (!existsSync4(manifestPath)) {
+    throw new GraphError(
+      `Localization manifest not found: ${manifestPath} \u2014 run \`manni graph export search\` first.`
+    );
+  }
+  const manifest = parseLocalizations(readFileSync6(manifestPath, "utf8"));
+  if (!manifest) {
+    throw new GraphError(
+      `Not a manni graph localization manifest: ${manifestPath} \u2014 re-run \`manni graph export search\`.`
+    );
+  }
+  const available = manifest.languages.map((l) => l.language);
+  if (lang !== void 0) {
+    const wanted = canonicalLanguageTag(lang);
+    const hit = manifest.languages.find(
+      (l) => canonicalLanguageTag(l.language) === wanted
+    );
+    if (!hit) {
+      throw new GraphError(
+        `No index for language "${lang}" \u2014 this corpus has ${available.join(", ") || "none"}.`
+      );
+    }
+    return hit;
+  }
+  const only = manifest.languages[0];
+  if (!only) {
+    throw new GraphError(
+      `The localization manifest lists no languages: ${manifestPath} \u2014 re-run \`manni graph export search\`.`
+    );
+  }
+  if (manifest.languages.length > 1) {
+    throw new GraphError(
+      `This corpus has more than one localization (${available.join(", ")}) \u2014 pass --lang to choose one.`
+    );
+  }
+  return only;
+}
+async function runSearch(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const config = loadRunConfig(
+    {
+      ...opts.config === void 0 ? {} : { configPath: opts.config },
+      ...opts.noConfig === void 0 ? {} : { noConfig: opts.noConfig }
+    },
+    cwd
+  );
+  const graphPath = resolve8(cwd, opts.graph ?? config.out);
+  const indexDir = opts.index ? resolve8(cwd, opts.index) : dirname3(graphPath);
+  const localization = resolveLocalization(indexDir, opts.lang);
+  const indexPath = join3(indexDir, localization.search.path);
+  if (!existsSync4(indexPath)) {
+    throw new GraphError(
+      `Search index not found: ${indexPath} \u2014 the manifest names it; re-run \`manni graph export search\`.`
+    );
+  }
+  const { doc, source } = loadSearchIndex(indexPath);
+  if (localization.search.digest !== source) {
+    throw new GraphError(
+      `Stale manifest: ${localization.search.path} does not match the digest recorded for "${localization.language}". Re-run \`manni graph export search\`.`
+    );
+  }
+  const lexical = createLexicalIndex(doc);
+  const explicitVectors = opts.vectors !== void 0 && opts.vectors !== "" ? opts.vectors : void 0;
+  const wantsVector = opts.mode === "vector" || opts.mode === "hybrid" || explicitVectors !== void 0 && opts.mode !== "lexical";
+  const vectorsPath = explicitVectors ? resolve8(cwd, explicitVectors) : localization.vectors ? resolve8(indexDir, localization.vectors.path) : void 0;
+  let vectors;
+  if (opts.mode !== "lexical" && vectorsPath !== void 0 && existsSync4(vectorsPath)) {
+    try {
+      vectors = createVectorIndex(readFileSync6(vectorsPath));
+    } catch (e) {
+      if (e instanceof VectorIndexError) {
+        throw new GraphError(
+          `${e.message} (${vectorsPath}) \u2014 re-run \`manni graph embed\`, or use \`--mode lexical\`.`
+        );
+      }
+      throw e;
+    }
+    const stale = vectors.check({ source });
+    if (stale && wantsVector) throw new GraphError(stale.detail);
+    if (stale) {
+      warn(`${stale.detail} Falling back to lexical.`);
+      vectors = void 0;
+    }
+  } else if (wantsVector) {
+    const named = vectorsPath ?? `no sidecar recorded for "${localization.language}"`;
+    throw new GraphError(
+      `Vector index not found: ${named} \u2014 run \`manni graph embed\` first, or use \`--mode lexical\`.`
+    );
+  }
+  let embedder;
+  if (vectors) {
+    const requireEmbedder = opts.mode === "vector" || opts.mode === "hybrid";
+    embedder = await resolveEmbedder(opts, vectors, requireEmbedder);
+  }
+  const entry2 = await findEntry(opts.query, {
+    lexical,
+    // Pass the embedder, not a bare function: findEntry then verifies it
+    // against the index itself rather than trusting the CLI to have done so.
+    ...embedder && vectors ? { vectors, embedder } : {},
+    limit: opts.limit
+  }).catch((e) => {
+    if (e instanceof VectorMismatchError) {
+      throw new GraphError(`${e.message} Re-run \`manni graph embed\`.`);
+    }
+    throw e;
+  });
+  const decorate = (c) => {
+    const found = lexical.entry(c.iri);
+    return {
+      iri: c.iri,
+      score: c.score,
+      via: c.via,
+      ...found?.type === void 0 ? {} : { type: found.type },
+      ...found?.title === void 0 ? {} : { title: found.title }
+    };
+  };
+  const mode = opts.mode ?? (embedder && vectors ? "hybrid" : "lexical");
+  const results = opts.mode === "vector" ? entry2.vector : entry2.candidates;
+  if (opts.mode === "vector") {
+    entry2.trace.entry.length = 0;
+    entry2.trace.entry.push(...entry2.vector);
+  }
+  return {
+    query: opts.query,
+    mode,
+    results: results.map(decorate),
+    lexical: entry2.lexical.map(decorate),
+    vector: entry2.vector.map(decorate),
+    trace: entry2.trace
+  };
+}
+async function resolveEmbedder(opts, vectors, required) {
+  const { model, dtype } = vectors;
+  try {
+    const embedder = opts.embedder ?? (model === "mock" ? createMockEmbedder({ dtype }) : await createLocalEmbedder({ model, dtype, role: "query" }));
+    const mismatch = vectors.check({
+      model: embedder.model,
+      dtype: embedder.dtype,
+      // Defense in depth: a future model that changes output size without
+      // changing its id would otherwise only surface deep inside search().
+      ...embedder.dims > 0 ? { dims: embedder.dims } : {}
+    });
+    if (mismatch) throw new GraphError(mismatch.detail);
+    return embedder;
+  } catch (e) {
+    if (e instanceof GraphError) throw e;
+    if (e instanceof EmbedderUnavailableError) {
+      if (required) throw new GraphError(e.message);
+      return void 0;
+    }
+    throw new GraphError(
+      `Failed to load embedding model ${model}: ${errorMessage(e)}`
+    );
+  }
+}
+function renderSearch(report, format) {
+  if (format === "json") return JSON.stringify(report, null, 2);
+  const lines = [];
+  for (const r of report.results) {
+    const label = r.title ? ` \u2014 ${r.title}` : "";
+    const type = r.type ? ` [${r.type}]` : "";
+    lines.push(`${r.score.toFixed(4)}  ${compactIri(r.iri)}${type}${label}`);
+  }
+  if (report.results.length === 0) {
+    lines.push("(no matches)");
+  }
+  lines.push("");
+  lines.push(
+    `${report.results.length} result${report.results.length === 1 ? "" : "s"} (${report.mode})`
+  );
+  return lines.join("\n");
+}
+
+// src/graph/commands/stats.ts
+import { resolve as resolve9 } from "node:path";
+import { DataFactory as DataFactory4 } from "n3";
+function subjectsOfType(store, typeIri) {
+  return store.getQuads(null, DataFactory4.namedNode(RDF_TYPE), DataFactory4.namedNode(typeIri), null).map((q) => q.subject.value).sort();
+}
+function base(iri2) {
+  const hash = iri2.indexOf("#");
+  return hash === -1 ? iri2 : iri2.slice(0, hash);
+}
+function round1(pct) {
+  return Math.round(pct * 10) / 10;
+}
+function runStats(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const config = loadRunConfig(
+    {
+      ...opts.config === void 0 ? {} : { configPath: opts.config },
+      ...opts.noConfig === void 0 ? {} : { noConfig: opts.noConfig }
+    },
+    cwd
+  );
+  const store = loadGraph(resolve9(cwd, opts.graph ?? config.out));
+  const top = opts.top ?? 5;
+  const docIris = subjectsOfType(store, `${NS.graph}Document`);
+  const docSet = new Set(docIris);
+  const pathOf = new Map(docIris.map((d) => [d, d]));
+  for (const quad of store.getQuads(
+    null,
+    DataFactory4.namedNode(`${NS.graph}path`),
+    null,
+    null
+  )) {
+    pathOf.set(quad.subject.value, quad.object.value);
+  }
+  const refQuads = store.getQuads(
+    null,
+    DataFactory4.namedNode(`${NS.dcterms}references`),
+    null,
+    null
+  );
+  const degree = new Map(docIris.map((d) => [d, 0]));
+  for (const quad of refQuads) {
+    const from = quad.subject.value;
+    const to = base(quad.object.value);
+    if (docSet.has(from)) degree.set(from, (degree.get(from) ?? 0) + 1);
+    if (docSet.has(to) && to !== from)
+      degree.set(to, (degree.get(to) ?? 0) + 1);
+  }
+  const orphans = docIris.filter((d) => (degree.get(d) ?? 0) === 0).map((d) => pathOf.get(d) ?? d).sort();
+  const brokenLinks = store.getQuads(null, DataFactory4.namedNode(`${NS.graph}brokenLink`), null, null).map((q) => ({
+    doc: pathOf.get(q.subject.value) ?? q.subject.value,
+    target: q.object.value
+  })).sort((a, b) => a.doc + a.target < b.doc + b.target ? -1 : 1);
+  const brokenSectionRefs = store.getQuads(null, DataFactory4.namedNode(`${NS.graph}brokenSectionRef`), null, null).map((q) => ({
+    doc: pathOf.get(q.subject.value) ?? q.subject.value,
+    slug: q.object.value
+  })).sort((a, b) => a.doc + a.slug < b.doc + b.slug ? -1 : 1);
+  const mostConnected = [...degree.entries()].filter(([, deg]) => deg > 0).map(([doc, deg]) => ({ doc: pathOf.get(doc) ?? doc, degree: deg })).sort((a, b) => b.degree - a.degree || (a.doc < b.doc ? -1 : 1)).slice(0, top);
+  const total = docIris.length;
+  const coverageOver = (subjects, fields) => fields.map(({ field, iri: iri2 }) => {
+    let docs = 0;
+    for (const s of subjects) {
+      if (store.countQuads(DataFactory4.namedNode(s), DataFactory4.namedNode(iri2), null, null) > 0)
+        docs++;
+    }
+    const ratio = subjects.length === 0 ? 100 : docs / subjects.length * 100;
+    return { field, predicate: compactIri(iri2), docs, pct: round1(ratio) };
+  });
+  const coverage = coverageOver(docIris, COVERAGE_FIELDS);
+  const sectionCoverage = coverageOver(
+    subjectsOfType(store, `${NS.graph}Section`),
+    SECTION_COVERAGE_FIELDS
+  );
+  const languageOf = /* @__PURE__ */ new Map();
+  for (const q of store.getQuads(
+    null,
+    DataFactory4.namedNode(`${NS.dcterms}language`),
+    null,
+    null
+  )) {
+    if (docSet.has(q.subject.value))
+      languageOf.set(q.subject.value, q.object.value);
+  }
+  const byLanguage = /* @__PURE__ */ new Map();
+  for (const d of docIris) {
+    const tag = languageOf.get(d);
+    if (tag === void 0) continue;
+    const bucket = byLanguage.get(tag);
+    if (bucket) bucket.push(d);
+    else byLanguage.set(tag, [d]);
+  }
+  const sources = docIris.filter(
+    (d) => store.countQuads(
+      DataFactory4.namedNode(d),
+      DataFactory4.namedNode(`${NS.schema}translationOfWork`),
+      null,
+      null
+    ) === 0
+  );
+  const translatedInto = /* @__PURE__ */ new Map();
+  for (const q of store.getQuads(
+    null,
+    DataFactory4.namedNode(`${NS.schema}workTranslation`),
+    null,
+    null
+  )) {
+    const target = languageOf.get(q.object.value);
+    if (target === void 0) continue;
+    const known = translatedInto.get(q.subject.value);
+    if (known) known.add(target);
+    else translatedInto.set(q.subject.value, /* @__PURE__ */ new Set([target]));
+  }
+  const localization = {
+    unlabelled: docIris.length - languageOf.size,
+    // `entries()`, not `keys()` and a lookup: the docs come out of the map
+    // with the tag they are keyed by, so there is nothing left to assert.
+    languages: [...byLanguage.entries()].sort(([a], [b]) => byCodeUnit(a, b)).map(([language, docsIn]) => {
+      const untranslated = sources.filter((s) => languageOf.get(s) !== language).filter((s) => !translatedInto.get(s)?.has(language)).map((s) => pathOf.get(s) ?? s).sort(byCodeUnit);
+      return {
+        language,
+        docs: docsIn.length,
+        coverage: coverageOver(docsIn, COVERAGE_FIELDS),
+        untranslated
+      };
+    })
+  };
+  const uniform = opts.coverageThreshold;
+  const thresholds = uniform != null ? Object.fromEntries(coverage.map((c) => [c.field, uniform])) : config.stats.coverageThreshold;
+  const coverageFindings = coverage.flatMap((c) => {
+    const threshold = thresholds[c.field];
+    if (threshold === void 0) return [];
+    const pct = total === 0 ? 100 : c.docs / total * 100;
+    return pct < threshold ? [{ field: c.field, pct: c.pct, threshold }] : [];
+  });
+  const failed = !!opts.check && (brokenLinks.length > 0 || brokenSectionRefs.length > 0 || coverageFindings.length > 0);
+  return {
+    triples: store.size,
+    docs: docIris.length,
+    // countQuads avoids materializing + sorting arrays used only for counting.
+    sections: store.countQuads(
+      null,
+      DataFactory4.namedNode(RDF_TYPE),
+      DataFactory4.namedNode(`${NS.graph}Section`),
+      null
+    ),
+    concepts: store.countQuads(
+      null,
+      DataFactory4.namedNode(RDF_TYPE),
+      DataFactory4.namedNode(`${NS.skos}Concept`),
+      null
+    ),
+    references: refQuads.length,
+    orphans,
+    brokenLinks,
+    brokenSectionRefs,
+    mostConnected,
+    coverage,
+    sectionCoverage,
+    localization,
+    coverageFindings,
+    exitCode: failed ? 1 : 0
+  };
+}
+function renderStats(report, format) {
+  if (format === "json") {
+    const { exitCode: _exitCode, ...rest } = report;
+    return JSON.stringify(rest, null, 2);
+  }
+  const lines = [
+    `Triples:    ${report.triples}`,
+    `Documents:  ${report.docs}`,
+    `Sections:   ${report.sections}`,
+    `Concepts:   ${report.concepts}`,
+    `References: ${report.references}`
+  ];
+  lines.push("", "Most connected:");
+  if (report.mostConnected.length === 0) lines.push("  (none)");
+  for (const { doc, degree } of report.mostConnected) {
+    lines.push(`  ${doc} (${degree})`);
+  }
+  lines.push("", `Orphan docs (${report.orphans.length}):`);
+  for (const orphan of report.orphans) lines.push(`  ${orphan}`);
+  if (report.orphans.length === 0) lines.push("  (none)");
+  lines.push("", `Broken internal links (${report.brokenLinks.length}):`);
+  for (const { doc, target } of report.brokenLinks) {
+    lines.push(`  ${doc} -> ${target}`);
+  }
+  if (report.brokenLinks.length === 0) lines.push("  (none)");
+  lines.push("", `Broken section refs (${report.brokenSectionRefs.length}):`);
+  for (const { doc, slug } of report.brokenSectionRefs) {
+    lines.push(`  ${doc} -> #${slug}`);
+  }
+  if (report.brokenSectionRefs.length === 0) lines.push("  (none)");
+  const belowThreshold = new Set(report.coverageFindings.map((f) => f.field));
+  const width = Math.max(
+    ...report.coverage.map((c) => c.field.length),
+    ...report.sectionCoverage.map((c) => c.field.length)
+  );
+  lines.push("", "Coverage (documents):");
+  for (const { field, docs, pct } of report.coverage) {
+    const flag = belowThreshold.has(field) ? "  ! below threshold" : "";
+    lines.push(
+      `  ${field.padEnd(width)}  ${docs}/${report.docs}  ${pct.toFixed(1)}%${flag}`
+    );
+  }
+  lines.push("", "Coverage (sections, not gated):");
+  if (report.sections === 0) {
+    lines.push("  (no sections in this graph)");
+  } else {
+    for (const { field, docs, pct } of report.sectionCoverage) {
+      lines.push(
+        `  ${field.padEnd(width)}  ${docs}/${report.sections}  ${pct.toFixed(1)}%`
+      );
+    }
+  }
+  if (report.localization.languages.length > 0) {
+    const tagWidth = Math.max(
+      ...report.localization.languages.map((l) => l.language.length)
+    );
+    lines.push("", "Localization:");
+    for (const { language, docs, untranslated } of report.localization.languages) {
+      const plural = docs === 1 ? "doc" : "docs";
+      const backlog = untranslated.length === 0 ? "" : `  ${untranslated.length} untranslated`;
+      lines.push(`  ${language.padEnd(tagWidth)}  ${docs} ${plural}${backlog}`);
+    }
+    lines.push(`  no language: ${report.localization.unlabelled}`);
+  }
+  return lines.join("\n");
+}
+
+// src/graph/commands/traverse.ts
+import { resolve as resolve10 } from "node:path";
+
+// src/graph/runtime/traverse.ts
+var DCTERMS_TITLE3 = `${NS.dcterms}title`;
+var DCTERMS_REFERENCES = `${NS.dcterms}references`;
+var DCTERMS_LANGUAGE2 = `${NS.dcterms}language`;
+function documentOf(iri2) {
+  const hash = iri2.indexOf("#");
+  return hash === -1 ? iri2 : iri2.slice(0, hash);
+}
+function resolveVariant(graph, input) {
+  if (graph.has(input)) return input;
+  const wanted = input.toLowerCase();
+  const variants = graph.instancesOf(`${NS.iirds}ProductVariant`);
+  for (const v of variants) {
+    if (graph.literal(v, DCTERMS_TITLE3)?.toLowerCase() === wanted) return v;
+  }
+  for (const v of variants) {
+    if (v.slice(v.lastIndexOf("/") + 1).toLowerCase() === wanted) return v;
+  }
+  return void 0;
+}
+function resolveSubject(graph, input) {
+  const mapped = SOFTWARE_SUBJECT_IRIS[input.toLowerCase()];
+  if (mapped) return mapped;
+  const expanded = graph.expand(input);
+  return expanded.startsWith("http") ? expanded : void 0;
+}
+function scopeExclusion(graph, iri2, scope) {
+  const checks = [
+    [
+      scope.variantIri,
+      IIRDS_RELATES_TO_PRODUCT_VARIANT,
+      GRAPH_NOT_APPLICABLE_TO_VARIANT,
+      "iri"
+    ],
+    [scope.subjectIri, IIRDS_HAS_SUBJECT, GRAPH_NOT_SOFTWARE_SUBJECT, "iri"],
+    [scope.language, DCTERMS_LANGUAGE2, void 0, "literal"]
+  ];
+  for (const [target, positive, negative, kind] of checks) {
+    if (!target) continue;
+    if (negative !== void 0) {
+      const denied = graph.values(iri2, negative).some((v) => v.kind === kind && v.value === target);
+      if (denied) return { node: iri2, rule: negative, value: target };
+    }
+    const subject = positive === DCTERMS_LANGUAGE2 ? documentOf(iri2) : iri2;
+    const claimed = graph.values(subject, positive);
+    if (claimed.length > 0) {
+      const matches = claimed.some(
+        (v) => v.kind === kind && v.value === target
+      );
+      if (!matches) return { node: iri2, rule: positive, value: target };
+    }
+  }
+  return void 0;
+}
+function traverse(graph, options) {
+  const trace = options.trace ?? createTrace();
+  const maxDepth = options.depth ?? 1;
+  const direction = options.direction ?? "out";
+  const allowed = options.predicates && options.predicates.length > 0 ? new Set(options.predicates.map((p) => graph.expand(p))) : void 0;
+  const variantIri = options.variant ? resolveVariant(graph, options.variant) : void 0;
+  const subjectIri = options.subject ? resolveSubject(graph, options.subject) : void 0;
+  const language = options.language === void 0 ? void 0 : canonicalLanguageTag(options.language);
+  const scope = { variantIri, subjectIri, language };
+  const followTypes = options.includeTypeEdges === true || allowed?.has(RDF_TYPE) === true;
+  const excluded = /* @__PURE__ */ new Set();
+  const keep = (iri2) => {
+    if (excluded.has(iri2)) return false;
+    const exclusion = scopeExclusion(graph, iri2, scope);
+    if (exclusion) {
+      excluded.add(iri2);
+      trace.exclusions.push(exclusion);
+      return false;
+    }
+    return true;
+  };
+  const nodes = [];
+  const seen = /* @__PURE__ */ new Set();
+  let frontier = [];
+  const alreadySeeded = new Set(trace.entry.map((e) => e.iri));
+  for (const seed of [...options.seeds].sort(byCodeUnit)) {
+    if (!graph.has(seed) || seen.has(seed)) continue;
+    seen.add(seed);
+    if (!alreadySeeded.has(seed)) {
+      trace.entry.push({ iri: seed, score: 1, via: "explicit" });
+    }
+    if (keep(seed)) nodes.push({ iri: seed, depth: 0 });
+    frontier.push(seed);
+  }
+  const limit = options.limit ?? Infinity;
+  for (let depth = 1; depth <= maxDepth && frontier.length > 0; depth++) {
+    const next = [];
+    for (const from of frontier) {
+      if (nodes.length >= limit) break;
+      for (const { predicate, target, dir } of neighbors(
+        graph,
+        from,
+        direction
+      )) {
+        if (allowed && !allowed.has(predicate)) continue;
+        if (!followTypes && predicate === RDF_TYPE) continue;
+        trace.hops.push({ from, predicate, to: target, depth, direction: dir });
+        if (seen.has(target)) continue;
+        seen.add(target);
+        if (!keep(target)) continue;
+        if (nodes.length >= limit) break;
+        nodes.push({ iri: target, depth });
+        next.push(target);
+      }
+    }
+    frontier = next;
+  }
+  return { nodes, trace };
+}
+function neighbors(graph, iri2, direction) {
+  const out = [];
+  if (direction === "out" || direction === "both") {
+    for (const e of graph.out(iri2)) out.push({ ...e, dir: "out" });
+  }
+  if (direction === "in" || direction === "both") {
+    for (const e of graph.in(iri2)) out.push({ ...e, dir: "in" });
+  }
+  return out;
+}
+function reverseReferences(graph, iri2, options = {}) {
+  return traverse(graph, {
+    ...options,
+    seeds: [iri2],
+    direction: "in",
+    predicates: [DCTERMS_REFERENCES],
+    depth: options.depth ?? 1
+  });
+}
+function impact(graph, iri2, options = {}) {
+  const result = traverse(graph, {
+    ...options,
+    seeds: [iri2],
+    direction: "in",
+    depth: options.depth ?? 3,
+    // The seed *may* occupy a slot in the walker's limit, so ask for one more:
+    // `limit` means "this many *affected* nodes". Whether it actually takes
+    // one depends on the scope filter — a seed the filter excludes still
+    // expands but is not in `nodes` — so the slack is trimmed below rather
+    // than assumed spent.
+    limit: options.limit === void 0 ? void 0 : options.limit + 1
+  });
+  const affected = result.nodes.filter((n) => n.iri !== iri2);
+  return {
+    nodes: options.limit === void 0 ? affected : affected.slice(0, options.limit),
+    trace: result.trace
+  };
+}
+
+// src/graph/commands/traverse.ts
+function runTraverse(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const config = loadRunConfig(
+    {
+      ...opts.config === void 0 ? {} : { configPath: opts.config },
+      ...opts.noConfig === void 0 ? {} : { noConfig: opts.noConfig }
+    },
+    cwd
+  );
+  const store = loadGraph(resolve10(cwd, opts.graph ?? config.out));
+  const quads = storeToQuads(store);
+  const graph = GraphIndex.fromQuads(quads, Object.fromEntries(PREFIXES));
+  const node = expandTerm(opts.node);
+  if (!graph.has(node)) {
+    throw new GraphError(
+      `Node not found in the graph: ${opts.node} \u2014 check the IRI, or run \`manni graph build\` first.`
+    );
+  }
+  if (opts.variant && !resolveVariant(graph, opts.variant)) {
+    throw new GraphError(
+      `Unknown product variant: ${opts.variant} \u2014 no iirds:ProductVariant matches that IRI, title, or slug.`
+    );
+  }
+  if (opts.subject && !resolveSubject(graph, opts.subject)) {
+    throw new GraphError(
+      `Unknown software subject: ${opts.subject} \u2014 expected one of ${Object.keys(SOFTWARE_SUBJECT_IRIS).sort().join(", ")}, or a full IRI.`
+    );
+  }
+  const predicates = opts.predicates?.map(expandTerm);
+  if (predicates && predicates.length > 0) {
+    const used = /* @__PURE__ */ new Set();
+    for (const quad of quads) {
+      if (quad.o.kind === "iri") used.add(quad.p);
+    }
+    predicates.forEach((predicate, i) => {
+      if (!used.has(predicate)) {
+        throw new GraphError(
+          `Unknown predicate: ${opts.predicates?.[i] ?? predicate}. No edge in the graph uses it.`
+        );
+      }
+    });
+  }
+  const direction = opts.reverse ? "in" : "out";
+  const result = opts.impact ? impact(graph, node, {
+    depth: opts.depth,
+    predicates,
+    variant: opts.variant,
+    subject: opts.subject,
+    language: opts.lang,
+    limit: opts.limit
+  }) : traverse(graph, {
+    seeds: [node],
+    depth: opts.depth,
+    predicates,
+    direction,
+    variant: opts.variant,
+    subject: opts.subject,
+    language: opts.lang,
+    limit: opts.limit
+  });
+  return {
+    node,
+    nodes: result.nodes.map((n) => {
+      const title = graph.literal(n.iri, `${NS.dcterms}title`);
+      return title === void 0 ? { iri: n.iri, depth: n.depth } : { iri: n.iri, depth: n.depth, title };
+    }),
+    trace: result.trace
+  };
+}
+function renderTraverse(report, format) {
+  if (format === "json") return JSON.stringify(report, null, 2);
+  const lines = [];
+  for (const n of report.nodes) {
+    const indent = "  ".repeat(n.depth);
+    const title = n.title ? ` \u2014 ${n.title}` : "";
+    lines.push(`${indent}${compactIri(n.iri)}${title}`);
+  }
+  if (report.nodes.length === 0) lines.push("(no nodes)");
+  if (report.trace.exclusions.length > 0) {
+    lines.push("");
+    lines.push("excluded by scope:");
+    for (const e of report.trace.exclusions) {
+      lines.push(
+        `  ${compactIri(e.node)} \u2014 ${compactIri(e.rule)} ${compactIri(e.value)}`
+      );
+    }
+  }
+  lines.push("");
+  lines.push(
+    `${report.nodes.length} node${report.nodes.length === 1 ? "" : "s"}, ${report.trace.hops.length} hop${report.trace.hops.length === 1 ? "" : "s"}, ${report.trace.exclusions.length} excluded`
+  );
+  return lines.join("\n");
+}
+
+export {
+  emitJsonLd,
+  emitRdfXml,
+  writeZip,
+  projectPackage,
+  splitFragment,
+  documentSectionOrder,
+  sectionOccurrences,
+  sectionOccurrence,
+  documentPreamble,
+  sliceSection,
+  sectionOwnText,
+  createFetchResolver,
+  buildSearchIndex,
+  emitSearchIndex,
+  partitionByLanguage,
+  documentsByLanguage,
+  GraphIndex,
+  EXPORT_TARGETS,
+  runExport,
+  runQuery,
+  renderQuery,
+  frontmatterKind,
+  applyGraphFields,
+  existingMetaProvenance,
+  existingGraphFields,
+  selectProvider2 as selectProvider,
+  assertProviderSelection,
+  providerSpecFor2 as providerSpecFor,
+  resolveProviderIdentity,
+  constructProvider,
+  makeProvider,
+  runFill,
+  renderFill,
+  VectorIndexError,
+  normalize,
+  encodeVectorIndex,
+  decodeVectorIndex,
+  EmbedderUnavailableError,
+  createLocalEmbedder,
+  createMockEmbedder,
+  embedText,
+  runEmbed,
+  renderEmbed,
+  VectorMismatchError,
+  searchIndexDigest2 as searchIndexDigest,
+  createVectorIndex,
+  createTrace,
+  reachedNodes,
+  rrfMerge,
+  findEntry,
+  createLexicalIndex,
+  SEARCH_MODES,
+  runSearch,
+  renderSearch,
+  runStats,
+  renderStats,
+  resolveVariant,
+  resolveSubject,
+  scopeExclusion,
+  traverse,
+  reverseReferences,
+  impact,
+  runTraverse,
+  renderTraverse
+};
+//# sourceMappingURL=chunk-644JVKJ4.js.map