@hawkeyexl/manni 4.11.0 → 4.12.1

package/dist/chunk-KCB5JCK4.js

@@ -0,0 +1,2272 @@
+#!/usr/bin/env node
+import {
+  COPIED_SHARE,
+  DEFAULT_MODEL,
+  GraphError,
+  LOCALIZATIONS_FILENAME,
+  NS,
+  PREFIXES,
+  RDF_TYPE,
+  STDIN_PATH,
+  UNDETERMINED,
+  byCodeUnit,
+  canonicalLanguageTag,
+  copiedPairs,
+  formatOf,
+  isTreeFormat,
+  loadRunConfig,
+  mergePage,
+  metadataOf,
+  mintTreeSections,
+  openMetaView,
+  parseLocalizations,
+  parseTree,
+  profileFor,
+  questionKey,
+  readQuestionFile,
+  readSampleQuestions,
+  withPrefix
+} from "./chunk-Q2QC5AZB.js";
+import {
+  packageRoot
+} from "./chunk-TIUTIOFB.js";
+import {
+  bodyLineOf,
+  findWindows,
+  pinOfLines,
+  spellLines,
+  splitLines,
+  toFileLines
+} from "./chunk-WO4JYWZK.js";
+import {
+  locateFrontmatter
+} from "./chunk-KFKL4VTL.js";
+import {
+  warn
+} from "./chunk-HX44GB4Z.js";
+import {
+  errorMessage
+} from "./chunk-G3T47CFV.js";
+
+// src/graph/core/load.ts
+import { existsSync, readFileSync } from "node:fs";
+import { Parser, Store } from "n3";
+var XSD_STRING = `${NS.xsd}string`;
+function loadGraph(ttlPath) {
+  if (!existsSync(ttlPath)) {
+    throw new GraphError(
+      `Graph not found: ${ttlPath} \u2014 run \`manni graph build\` first.`
+    );
+  }
+  return parseGraph(readFileSync(ttlPath, "utf8"), ttlPath);
+}
+function parseGraph(turtle, label) {
+  const parser = new Parser({ format: "text/turtle" });
+  let quads;
+  try {
+    quads = parser.parse(turtle);
+  } catch (e) {
+    throw new GraphError(
+      `Failed to parse ${label}: ${errorMessage(e)}`
+    );
+  }
+  return new Store(quads);
+}
+function storeToQuads(store) {
+  return store.getQuads(null, null, null, null).map((q) => {
+    const o = q.object;
+    let term;
+    if (o.termType === "Literal" && o.language !== "") {
+      term = { kind: "literal", value: o.value, language: o.language };
+    } else if (o.termType === "Literal") {
+      const dt = o.datatype.value;
+      term = dt && dt !== XSD_STRING ? { kind: "literal", value: o.value, datatype: dt } : { kind: "literal", value: o.value };
+    } else {
+      term = { kind: "iri", value: o.value };
+    }
+    return { s: q.subject.value, p: q.predicate.value, o: term };
+  });
+}
+function expandTerm(input) {
+  const colon = input.indexOf(":");
+  if (colon > 0) {
+    const prefix = input.slice(0, colon);
+    const ns = NS[prefix];
+    if (ns) return `${ns}${input.slice(colon + 1)}`;
+  }
+  return input;
+}
+function compactIri(iri) {
+  for (const [prefix, ns] of PREFIXES) {
+    if (iri.startsWith(ns) && iri.length > ns.length) {
+      return `${prefix}:${iri.slice(ns.length)}`;
+    }
+  }
+  return iri;
+}
+
+// src/graph/core/pkg.ts
+import { join } from "node:path";
+function bundledShapesPath(moduleUrl) {
+  return join(packageRoot(moduleUrl), "shapes", "graph", "shapes-1.1.0.ttl");
+}
+
+// src/graph/core/shacl.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { DataFactory, Parser as Parser2, Store as Store2 } from "n3";
+import SHACLValidator from "rdf-validate-shacl";
+var FAMILY_SEVERITY = {
+  violation: "error",
+  warning: "warning",
+  info: "notice"
+};
+function finding(shaclSeverity, rest) {
+  return { severity: FAMILY_SEVERITY[shaclSeverity], shaclSeverity, ...rest };
+}
+var SEVERITY_RANK = {
+  error: 0,
+  warning: 1,
+  notice: 2
+};
+function compareFindings(a, b) {
+  return SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity] || byCodeUnit(a.focusNode, b.focusNode) || byCodeUnit(a.path ?? "", b.path ?? "") || byCodeUnit(a.message, b.message);
+}
+function loadShapes(paths) {
+  const store = new Store2();
+  for (const path of paths) {
+    let text;
+    try {
+      text = readFileSync2(path, "utf8");
+    } catch {
+      throw new GraphError(`Shapes file not found: ${path}`);
+    }
+    try {
+      store.addQuads(new Parser2({ format: "text/turtle" }).parse(text));
+    } catch (e) {
+      throw new GraphError(
+        `Failed to parse shapes ${path}: ${errorMessage(e)}`
+      );
+    }
+  }
+  return store;
+}
+function blameDocs(store, focus) {
+  const pathPred = DataFactory.namedNode(`${NS.graph}path`);
+  const pathOf = (iri) => store.getQuads(DataFactory.namedNode(iri), pathPred, null, null)[0]?.object.value;
+  const found = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const walk = (iri, depth) => {
+    if (visited.has(iri)) return;
+    visited.add(iri);
+    const own = pathOf(iri);
+    if (own !== void 0) {
+      found.add(own);
+      return;
+    }
+    const hash = iri.indexOf("#");
+    if (hash !== -1) {
+      const base = pathOf(iri.slice(0, hash));
+      if (base !== void 0) {
+        found.add(base);
+        return;
+      }
+    }
+    if (depth === 0) return;
+    for (const quad of store.getQuads(null, null, DataFactory.namedNode(iri), null)) {
+      if (quad.subject.termType === "NamedNode") {
+        walk(quad.subject.value, depth - 1);
+      }
+    }
+  };
+  walk(focus, 2);
+  return [...found].sort();
+}
+function broaderEdges(store) {
+  const edges2 = [];
+  for (const q of store.getQuads(
+    null,
+    DataFactory.namedNode(`${NS.skos}broader`),
+    null,
+    null
+  )) {
+    if (q.object.termType === "NamedNode") {
+      edges2.push({ s: q.subject.value, o: q.object.value });
+    }
+  }
+  for (const q of store.getQuads(
+    null,
+    DataFactory.namedNode(`${NS.skos}narrower`),
+    null,
+    null
+  )) {
+    if (q.object.termType === "NamedNode") {
+      edges2.push({ s: q.object.value, o: q.subject.value });
+    }
+  }
+  return edges2;
+}
+function broaderCycles(store) {
+  const adjacency = /* @__PURE__ */ new Map();
+  const selfLoops = /* @__PURE__ */ new Set();
+  for (const { s, o } of broaderEdges(store)) {
+    if (s === o) selfLoops.add(s);
+    const list = adjacency.get(s);
+    if (list) list.push(o);
+    else adjacency.set(s, [o]);
+    if (!adjacency.has(o)) adjacency.set(o, []);
+  }
+  for (const list of adjacency.values()) list.sort();
+  const index = /* @__PURE__ */ new Map();
+  const lowlink = /* @__PURE__ */ new Map();
+  const onStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  const components = [];
+  let counter = 0;
+  const numberOf = (map, node) => {
+    const value = map.get(node);
+    if (value === void 0) {
+      throw new GraphError(
+        `internal: ${node} was visited before it was numbered`
+      );
+    }
+    return value;
+  };
+  const nodes = [...adjacency.keys()].sort();
+  for (const root of nodes) {
+    if (index.has(root)) continue;
+    const frames = [[root, 0]];
+    for (let frame = frames.at(-1); frame !== void 0; frame = frames.at(-1)) {
+      const [node, childIdx] = frame;
+      if (childIdx === 0) {
+        index.set(node, counter);
+        lowlink.set(node, counter);
+        counter += 1;
+        stack.push(node);
+        onStack.add(node);
+      }
+      const children = adjacency.get(node) ?? [];
+      const child = children[childIdx];
+      if (child !== void 0) {
+        frame[1] += 1;
+        if (!index.has(child)) {
+          frames.push([child, 0]);
+        } else if (onStack.has(child)) {
+          lowlink.set(
+            node,
+            Math.min(numberOf(lowlink, node), numberOf(index, child))
+          );
+        }
+      } else {
+        if (lowlink.get(node) === index.get(node)) {
+          const component = [];
+          let member;
+          do {
+            member = stack.pop();
+            if (member === void 0) break;
+            onStack.delete(member);
+            component.push(member);
+          } while (member !== node);
+          if (component.length > 1 || selfLoops.has(node)) {
+            components.push(component.sort());
+          }
+        }
+        frames.pop();
+        const parent = frames.at(-1);
+        if (parent) {
+          lowlink.set(
+            parent[0],
+            Math.min(numberOf(lowlink, parent[0]), numberOf(lowlink, node))
+          );
+        }
+      }
+    }
+  }
+  return components.sort((a, b) => (a[0] ?? "") < (b[0] ?? "") ? -1 : 1);
+}
+function broaderClosure(edges2, start) {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const { s, o } of edges2) {
+    const list = adjacency.get(s);
+    if (list) list.push(o);
+    else adjacency.set(s, [o]);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [...adjacency.get(start) ?? []];
+  for (let node = queue.shift(); node !== void 0; node = queue.shift()) {
+    if (seen.has(node)) continue;
+    seen.add(node);
+    queue.push(...adjacency.get(node) ?? []);
+  }
+  return seen;
+}
+function relatedConflicts(store) {
+  const edges2 = broaderEdges(store);
+  const direct = /* @__PURE__ */ new Map();
+  for (const e of edges2) {
+    const targets = direct.get(e.s);
+    if (targets) targets.add(e.o);
+    else direct.set(e.s, /* @__PURE__ */ new Set([e.o]));
+  }
+  const findings = [];
+  for (const q of store.getQuads(
+    null,
+    DataFactory.namedNode(`${NS.skos}related`),
+    null,
+    null
+  )) {
+    if (q.object.termType !== "NamedNode") continue;
+    const s = q.subject.value;
+    const o = q.object.value;
+    if (direct.get(s)?.has(o)) continue;
+    const conflict = broaderClosure(edges2, s).has(o) || broaderClosure(edges2, o).has(s);
+    if (!conflict) continue;
+    findings.push(
+      finding("violation", {
+        message: `skos:related conflicts with skos:broaderTransitive between ${compactIri(s)} and ${compactIri(o)} \u2014 a concept cannot be both related to and an ancestor/descendant of another`,
+        focusNode: s,
+        path: `${NS.skos}related`,
+        docs: blameDocs(store, s)
+      })
+    );
+  }
+  return findings;
+}
+function cycleFindings(store) {
+  return broaderCycles(store).map(
+    (members) => finding("violation", {
+      message: `skos:broader cycle through ${members.map((m) => compactIri(m)).join(
+        ", "
+      )} (${members.map((m) => m).join(" \u2192 ")}) \u2014 a concept cannot be its own ancestor`,
+      // `broaderCycles` returns only components of at least one member, so
+      // the first is there; `?? ""` says that without asserting it.
+      focusNode: members[0] ?? "",
+      path: `${NS.skos}broader`,
+      docs: [...new Set(members.flatMap((m) => blameDocs(store, m)))].sort()
+    })
+  );
+}
+var PREF_LABEL_COLLISION = "concept carries multiple prefLabels (same slug, different spellings) \u2014 settle on one spelling";
+function untaggedPrefLabelFindings(store) {
+  const prefLabel = `${NS.skos}prefLabel`;
+  const untagged = /* @__PURE__ */ new Map();
+  for (const q of store.getQuads(null, DataFactory.namedNode(prefLabel), null, null)) {
+    if (q.object.termType !== "Literal" || q.object.language !== "") continue;
+    untagged.set(q.subject.value, (untagged.get(q.subject.value) ?? 0) + 1);
+  }
+  return [...untagged].filter(([, count]) => count > 1).map(
+    ([focusNode]) => finding("warning", {
+      message: PREF_LABEL_COLLISION,
+      focusNode,
+      path: prefLabel,
+      docs: blameDocs(store, focusNode)
+    })
+  );
+}
+var MAPPINGS = ["exactMatch", "closeMatch", "broadMatch", "narrowMatch", "relatedMatch"];
+function inSchemeMappingFindings(store) {
+  const inScheme = DataFactory.namedNode(`${NS.skos}inScheme`);
+  const findings = [];
+  for (const mapping of MAPPINGS) {
+    const path = `${NS.skos}${mapping}`;
+    for (const q of store.getQuads(null, DataFactory.namedNode(path), null, null)) {
+      if (q.object.termType !== "NamedNode") continue;
+      const schemes = new Set(store.getObjects(q.subject, inScheme, null).map((o) => o.value));
+      const shared = store.getObjects(q.object, inScheme, null).some((o) => schemes.has(o.value));
+      if (!shared) continue;
+      findings.push(
+        finding("violation", {
+          message: `skos:${mapping} points into this scheme (${compactIri(q.object.value)}), so use broader, narrower or related instead.`,
+          focusNode: q.subject.value,
+          path,
+          docs: blameDocs(store, q.subject.value)
+        })
+      );
+    }
+  }
+  return findings;
+}
+var CURATED_FIELDS = /* @__PURE__ */ new Set(["sections", "revision-of", "derived-from"]);
+var GRAPH_FILL_FRAGMENT = "#prov.graph-fill.";
+function curatedFieldFindings(store) {
+  const filledField = `${NS.graph}filledField`;
+  const pathPred = DataFactory.namedNode(`${NS.graph}path`);
+  const findings = [];
+  for (const q of store.getQuads(null, DataFactory.namedNode(filledField), null, null)) {
+    if (q.object.termType !== "Literal") continue;
+    const field = q.object.value;
+    if (!CURATED_FIELDS.has(field)) continue;
+    const node = q.subject.value;
+    const at = node.indexOf(GRAPH_FILL_FRAGMENT);
+    const fieldAt = node.lastIndexOf(".field.");
+    if (at === -1 || fieldAt <= at) continue;
+    const activity = node.slice(0, fieldAt);
+    const model = node.slice(at + GRAPH_FILL_FRAGMENT.length, fieldAt);
+    const docIri = activity.slice(0, activity.indexOf("#"));
+    const path = store.getQuads(DataFactory.namedNode(docIri), pathPred, null, null)[0]?.object.value;
+    findings.push(
+      finding("violation", {
+        message: `meta-provenance attributes /graph/${field} to ${model} \u2014 ${field} is curated by hand, never filled by a machine`,
+        focusNode: activity,
+        path: filledField,
+        docs: path === void 0 ? blameDocs(store, activity) : [path]
+      })
+    );
+  }
+  return findings;
+}
+function severityOf(iri) {
+  if (iri === "http://www.w3.org/ns/shacl#Warning") return "warning";
+  if (iri === "http://www.w3.org/ns/shacl#Info") return "info";
+  return "violation";
+}
+async function validateGraph(store, shapesPaths) {
+  const shapes = loadShapes(shapesPaths);
+  const validator = new SHACLValidator(shapes);
+  let report;
+  try {
+    report = await validator.validate(store);
+  } catch (e) {
+    throw new GraphError(
+      `SHACL validation failed: ${errorMessage(e)}`
+    );
+  }
+  const findings = [];
+  for (const result of report.results) {
+    const focus = result.focusNode?.value ?? "";
+    const path = result.path?.value;
+    const messages = result.message.map((m) => m.value).filter((m) => m.length > 0);
+    const message = messages.length > 0 ? messages.join("; ") : `constraint violated${path ? ` on ${compactIri(path)}` : ""}`;
+    findings.push(
+      finding(severityOf(result.severity?.value), {
+        message,
+        focusNode: focus,
+        ...path !== void 0 ? { path } : {},
+        docs: blameDocs(store, focus)
+      })
+    );
+  }
+  const said = new Set(
+    findings.filter((f) => f.message === PREF_LABEL_COLLISION).map((f) => f.focusNode)
+  );
+  findings.push(
+    ...cycleFindings(store),
+    ...relatedConflicts(store),
+    ...curatedFieldFindings(store),
+    ...inSchemeMappingFindings(store),
+    ...untaggedPrefLabelFindings(store).filter((f) => !said.has(f.focusNode))
+  );
+  findings.sort(compareFindings);
+  return findings;
+}
+
+// src/graph/commands/search.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import { dirname, join as join2, resolve } 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/runtime/vector.ts
+var VectorMismatchError = class extends Error {
+  reason;
+  constructor(mismatch) {
+    super(mismatch.detail);
+    this.name = "VectorMismatchError";
+    this.reason = mismatch.reason;
+  }
+};
+async function searchIndexDigest(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, iri] 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, 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(([iri, { score, vias }]) => {
+    const [only] = vias;
+    return {
+      iri,
+      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: (iri) => byIri.get(iri),
+    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/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/search.ts
+var SEARCH_MODES = ["lexical", "hybrid", "vector"];
+function loadSearchIndex(indexPath) {
+  const raw = readFileSync3(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:${createHash("sha256").update(raw, "utf8").digest("hex")}`
+  };
+}
+function resolveLocalization(indexDir, lang) {
+  const manifestPath = join2(indexDir, LOCALIZATIONS_FILENAME);
+  if (!existsSync2(manifestPath)) {
+    throw new GraphError(
+      `Localization manifest not found: ${manifestPath} \u2014 run \`manni graph export search\` first.`
+    );
+  }
+  const manifest = parseLocalizations(readFileSync3(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 = resolve(cwd, opts.graph ?? config.out);
+  const indexDir = opts.index ? resolve(cwd, opts.index) : dirname(graphPath);
+  const localization = resolveLocalization(indexDir, opts.lang);
+  const indexPath = join2(indexDir, localization.search.path);
+  if (!existsSync2(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 ? resolve(cwd, explicitVectors) : localization.vectors ? resolve(indexDir, localization.vectors.path) : void 0;
+  let vectors;
+  if (opts.mode !== "lexical" && vectorsPath !== void 0 && existsSync2(vectorsPath)) {
+    try {
+      vectors = createVectorIndex(readFileSync3(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.embedder, 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(override, vectors, required) {
+  const { model, dtype } = vectors;
+  try {
+    const embedder = override ?? (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/questions.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "node:fs";
+import { join as join3, resolve as resolve3 } from "node:path";
+import GithubSlugger from "github-slugger";
+
+// src/graph/core/search-index.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4 } 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(iri) {
+  const hash = iri.indexOf("#");
+  return hash < 0 ? { doc: iri } : { doc: iri.slice(0, hash), fragment: iri.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 = (iri) => graph.out(iri, 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 = (iri) => {
+    for (const child of childrenOf(iri)) {
+      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 sectionOwnLines(markdown, title, level, occurrence = 0) {
+  const span = locate(markdown.split(/\r?\n/), title, level, occurrence, true);
+  return span === void 0 ? void 0 : { start: span.start + 1, end: span.end };
+}
+function slice(markdown, title, level, occurrence, ownTextOnly) {
+  const lines = markdown.split(/\r?\n/);
+  const span = locate(lines, title, level, occurrence, ownTextOnly);
+  if (span === void 0) return void 0;
+  return lines.slice(span.start, span.end).join("\n").trimEnd();
+}
+function locate(lines, title, level, occurrence, ownTextOnly) {
+  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);
+  return { start: match.start, end: next?.start ?? lines.length };
+}
+function createFetchResolver(graph, options = {}) {
+  const doFetch = options.fetch ?? ((url) => globalThis.fetch(url));
+  const toUrl = options.pathToUrl ?? ((path) => `${options.baseUrl ?? ""}${path}`);
+  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(iri) {
+      const { doc, fragment } = splitFragment(iri);
+      const path = graph.literal(doc, GRAPH_PATH);
+      if (!path) return void 0;
+      const sourceUrl = toUrl(path);
+      const body = await fetchDoc(sourceUrl);
+      const title = graph.literal(iri, DCTERMS_TITLE);
+      if (body === void 0) {
+        options.trace?.resolutions.push({
+          iri,
+          sourceUrl,
+          ok: false,
+          error: "fetch failed"
+        });
+        return void 0;
+      }
+      let text = body;
+      if (fragment) {
+        const levelText = graph.literal(iri, 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, iri)
+        );
+        if (slice2 === void 0) {
+          options.trace?.resolutions.push({
+            iri,
+            sourceUrl,
+            ok: false,
+            error: "section heading not found"
+          });
+          return void 0;
+        }
+        text = slice2;
+      }
+      options.trace?.resolutions.push({ iri, sourceUrl, ok: true });
+      return { iri, text, sourceUrl, title };
+    }
+  };
+}
+
+// src/graph/core/search-index.ts
+var GRAPH_DOCUMENT = `${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 plainText(nodes) {
+  return nodes.map((n) => n.text.replace(/\r\n/g, "\n").trim()).filter((t) => t !== "");
+}
+function treeText(source, path) {
+  const format = formatOf(path);
+  if (format === "markdown" || format === "mdx") return void 0;
+  const minted = mintTreeSections(parseTree(source, path, format).sections);
+  const sections = /* @__PURE__ */ new Map();
+  for (const [n, section] of minted.sections.entries()) {
+    const own = plainText(minted.owned[n] ?? []);
+    sections.set(section.slug, [section.title, ...own].join("\n\n"));
+  }
+  const lead = plainText(minted.unowned);
+  return { doc: lead.length > 0 ? lead.join("\n\n") : void 0, sections };
+}
+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 ?? ((path) => {
+    const abs = resolve2(cwd, path);
+    return existsSync3(abs) ? readFileSync4(abs, "utf8") : void 0;
+  });
+  const entries = [];
+  const sourceOf = /* @__PURE__ */ new Map();
+  const treeTextOf = /* @__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_DOCUMENT)) {
+    const path = graph.literal(doc, GRAPH_PATH2);
+    const source = path === void 0 ? void 0 : readDoc(path);
+    sourceOf.set(doc, source);
+    if (path !== void 0 && source === void 0) {
+      warnings.push(
+        `Source not found for ${path} \u2014 indexed without body text.`
+      );
+    }
+    const tree = source === void 0 || path === void 0 ? void 0 : treeText(source, path);
+    if (tree) treeTextOf.set(doc, tree);
+    const body = source === void 0 ? void 0 : stripFrontmatter(source).replace(/\r\n/g, "\n");
+    const text = tree ? tree.doc : body === void 0 ? void 0 : (sectionsOf.get(doc)?.length ?? 0) > 0 ? documentPreamble(body) : body;
+    entries.push(
+      entry(doc, compactIri(GRAPH_DOCUMENT), {
+        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 tree = treeTextOf.get(doc);
+    const text = tree ? tree.sections.get(section.slice(hash + 1)) : 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_DOCUMENT);
+  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_DOCUMENT)) {
+    const language = languageOfDocument(graph, doc);
+    out.set(language, (out.get(language) ?? 0) + 1);
+  }
+  return out;
+}
+
+// src/graph/runtime/graph.ts
+var XSD_STRING2 = "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 ?? "" : "";
+  const la = a.kind === "literal" ? a.language ?? "" : "";
+  const lb = b.kind === "literal" ? b.language ?? "" : "";
+  return byCodeUnit(da, db) || byCodeUnit(la, lb);
+}
+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.language ? { kind: "literal", value: o.value, language: o.language } : o.datatype && o.datatype !== XSD_STRING2 ? { 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(iri) {
+    let best = iri;
+    let bestNs = "";
+    for (const [prefix, ns] of Object.entries(this.context)) {
+      if (iri.startsWith(ns) && iri.length > ns.length && ns.length > bestNs.length) {
+        best = `${prefix}:${iri.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);
+        if (typeof o["@language"] === "string") {
+          return { kind: "literal", value: lexical, language: o["@language"] };
+        }
+        const dt = typeof o["@type"] === "string" ? this.expand(o["@type"]) : void 0;
+        return dt && dt !== XSD_STRING2 ? { 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(iri) {
+    return this.nodes.get(iri);
+  }
+  has(iri) {
+    return this.nodes.has(iri);
+  }
+  /** Class IRIs of a node, sorted. */
+  types(iri) {
+    return this.nodes.get(iri)?.types ?? [];
+  }
+  /** Instances of a class, sorted. */
+  instancesOf(classIri) {
+    return this.byType.get(classIri) ?? [];
+  }
+  /** All values for a predicate, sorted. */
+  values(iri, predicate) {
+    return this.nodes.get(iri)?.props.get(predicate) ?? [];
+  }
+  /** Literal lexical forms for a predicate, sorted. */
+  literals(iri, predicate) {
+    return this.values(iri, predicate).filter((v) => v.kind === "literal").map((v) => v.value);
+  }
+  /** The first literal for a predicate, if any. */
+  literal(iri, predicate) {
+    return this.literals(iri, predicate)[0];
+  }
+  /** Outbound IRI targets: all predicates, or one. Sorted. */
+  out(iri, predicate) {
+    return edges(this.outbound, iri, predicate);
+  }
+  /** Inbound IRI sources (who points at this node). Sorted. */
+  in(iri, predicate) {
+    return edges(this.inbound, iri, 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, iri, predicate) {
+  const preds = map.get(iri);
+  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/questions.ts
+var DOCUMENT = `${NS.graph}Document`;
+var SECTION = `${NS.graph}Section`;
+var PATH = `${NS.graph}path`;
+var LEVEL = `${NS.graph}level`;
+var TITLE = `${NS.dcterms}title`;
+var LANGUAGE = `${NS.dcterms}language`;
+var SAMPLE_QUESTION = `${NS.graph}sampleQuestion`;
+var DOCUMENT_TYPE = compactIri(DOCUMENT);
+var SECTION_TYPE = compactIri(SECTION);
+function readManifest(indexDir) {
+  const path = join3(indexDir, LOCALIZATIONS_FILENAME);
+  if (!existsSync4(path)) return [];
+  const manifest = parseLocalizations(readFileSync5(path, "utf8"));
+  if (!manifest) {
+    throw new GraphError(
+      `Not a manni graph localization manifest: ${path} \u2014 re-run \`manni graph export search\`.`
+    );
+  }
+  return manifest.languages;
+}
+async function openRetriever(doc, entry2, indexDir) {
+  const lexical = createLexicalIndex(doc);
+  if (!entry2?.vectors) return { lexical };
+  const path = resolve3(indexDir, entry2.vectors.path);
+  if (!existsSync4(path)) return { lexical };
+  let vectors;
+  try {
+    vectors = createVectorIndex(readFileSync5(path));
+  } catch (e) {
+    if (e instanceof VectorIndexError) {
+      throw new GraphError(`${e.message} (${path}) \u2014 re-run \`manni graph embed\`.`);
+    }
+    throw e;
+  }
+  const source = `sha256:${createHash2("sha256").update(emitSearchIndex(doc), "utf8").digest("hex")}`;
+  const stale = vectors.check({ source });
+  if (stale) {
+    warn(`${stale.detail} Falling back to lexical.`);
+    return { lexical };
+  }
+  const embedder = await resolveEmbedder(void 0, vectors, false);
+  return embedder ? { lexical, vectors, embedder } : { lexical };
+}
+async function rankNodes(question, r) {
+  const entry2 = await findEntry(question, {
+    lexical: r.lexical,
+    ...r.vectors && r.embedder ? { vectors: r.vectors, embedder: r.embedder } : {},
+    limit: r.lexical.size()
+  }).catch((e) => {
+    if (e instanceof VectorMismatchError) {
+      throw new GraphError(`${e.message} Re-run \`manni graph embed\`.`);
+    }
+    throw e;
+  });
+  return entry2.candidates.flatMap((c) => {
+    const type = r.lexical.entry(c.iri)?.type;
+    return type === DOCUMENT_TYPE || type === SECTION_TYPE ? [c.iri] : [];
+  });
+}
+function pageOf(iri) {
+  const hash = iri.indexOf("#");
+  return hash < 0 ? iri : iri.slice(0, hash);
+}
+function lastLine(position) {
+  const { start, end } = position;
+  return end.column <= 1 && end.line > start.line ? end.line - 1 : end.line;
+}
+function sectionSpans(graph, doc, path, content, sections) {
+  const format = formatOf(path);
+  const out = [];
+  if (isTreeFormat(format)) {
+    const known = new Set(sections);
+    const minted = mintTreeSections(parseTree(content, path, format).sections);
+    for (const [n, section] of minted.sections.entries()) {
+      const iri = `${doc}#${section.slug}`;
+      const node = minted.nodes[n];
+      if (!known.has(iri) || node === void 0) continue;
+      const head = node.titlePosition ?? node.position;
+      const end = Math.max(
+        lastLine(head),
+        ...(minted.owned[n] ?? []).map((c) => lastLine(c.position))
+      );
+      out.push({ iri, span: { start: head.start.line, end } });
+    }
+    return out;
+  }
+  const occurrences = sectionOccurrences(graph, doc);
+  for (const iri of sections) {
+    const title = graph.literal(iri, TITLE);
+    if (title === void 0) continue;
+    const level = Number.parseInt(graph.literal(iri, LEVEL) ?? "", 10);
+    const span = sectionOwnLines(
+      content,
+      title,
+      Number.isNaN(level) ? void 0 : level,
+      occurrences.get(iri) ?? 0
+    );
+    if (span) out.push({ iri, span });
+  }
+  return out;
+}
+function bodyOf(content, format) {
+  const bodyLine = format === "html" || format === "xml" ? 1 : bodyLineOf(content, locateFrontmatter(content)?.closeEnd ?? 0);
+  return { bodyLine, body: splitLines(content).slice(bodyLine - 1) };
+}
+function freshness(body, pin) {
+  const { lines, integrity } = pin;
+  if (integrity === void 0) {
+    return lines.end <= body.length ? { state: "current", ranges: [lines] } : { state: "changed" };
+  }
+  if (pinOfLines(body, lines) === integrity) return { state: "current", ranges: [lines] };
+  const length = lines.end - lines.start + 1;
+  const { starts } = findWindows(body, length, integrity, void 0, { around: lines.start });
+  const ranges = starts.map((start) => ({ start, end: start + length - 1 }));
+  if (ranges.length === 0) return { state: "changed" };
+  return { state: ranges.length === 1 ? "moved" : "ambiguous", ranges };
+}
+function matchList(ranges) {
+  const spelled = ranges.map(spellLines);
+  const head = spelled.slice(0, -1);
+  const last = spelled[spelled.length - 1] ?? "";
+  if (head.length === 0) return `lines ${last} match`;
+  const both = head.length === 1 ? "both" : "all";
+  return `lines ${head.join(", ")} and ${last} ${both} match`;
+}
+async function readPages(graph, sources, view, verb) {
+  const contents = /* @__PURE__ */ new Map();
+  const onDisk = [];
+  const byAbs = /* @__PURE__ */ new Map();
+  let missing = 0;
+  for (const doc of graph.instancesOf(DOCUMENT)) {
+    const path = graph.literal(doc, PATH);
+    if (path === void 0 || path === STDIN_PATH) continue;
+    const abs = resolve3(sources, path);
+    if (!existsSync4(abs)) {
+      missing += 1;
+      continue;
+    }
+    contents.set(path, readFileSync5(abs, "utf8"));
+    onDisk.push({ doc, path });
+    byAbs.set(abs, { doc, path });
+  }
+  if (missing > 0) {
+    warn(
+      missing === 1 ? `1 page in the graph is not on disk, so its questions were not ${verb}; run manni graph build.` : `${String(missing)} pages in the graph are not on disk, so their questions were not ${verb}; run manni graph build.`
+    );
+  }
+  const sectionsOf = /* @__PURE__ */ new Map();
+  for (const section of graph.instancesOf(SECTION)) {
+    const doc = pageOf(section);
+    const siblings = sectionsOf.get(doc);
+    if (siblings) siblings.push(section);
+    else sectionsOf.set(doc, [section]);
+  }
+  const records = /* @__PURE__ */ new Map();
+  const record = (doc, path, questions) => {
+    const known = records.get(doc);
+    if (known) return known;
+    const content = contents.get(path) ?? "";
+    const { bodyLine, body } = bodyOf(content, formatOf(path));
+    const tag = graph.literal(doc, LANGUAGE);
+    const page = {
+      doc,
+      path,
+      language: tag === void 0 ? UNDETERMINED : canonicalLanguageTag(tag),
+      bodyLine,
+      body,
+      sections: sectionSpans(graph, doc, path, content, sectionsOf.get(doc) ?? []),
+      questions
+    };
+    records.set(doc, page);
+    return page;
+  };
+  const meta = await openMetaView(view.source, view.cwd, onDisk.map((p) => p.path), sources);
+  const pages = [];
+  for (const { doc, path } of onDisk) {
+    const content = contents.get(path) ?? "";
+    const format = formatOf(path);
+    const own = metadataOf(content, path, format);
+    const { data } = await mergePage(meta, path, own.data, own.present, format);
+    const questions = readSampleQuestions(data["sample-questions"]);
+    if (questions.length > 0) pages.push(record(doc, path, questions));
+  }
+  pages.sort((a, b) => byCodeUnit(a.path, b.path));
+  return {
+    pages,
+    contents,
+    pageAt: (abs) => {
+      const hit = byAbs.get(abs);
+      return hit && record(hit.doc, hit.path, []);
+    }
+  };
+}
+function holdersOf(page, lines) {
+  const out = page.sections.filter(({ span }) => span.start <= lines.end && lines.start <= span.end).map(({ iri }) => iri);
+  for (let line = lines.start; line <= lines.end; line++) {
+    if (!page.sections.some(({ span }) => span.start <= line && line <= span.end)) {
+      return [page.doc, ...out];
+    }
+  }
+  return out;
+}
+function percent(part, of) {
+  return of === 0 ? 0 : Math.floor(part / of * 100);
+}
+function plural(n, word) {
+  return `${String(n)} ${word}${n === 1 ? "" : "s"}`;
+}
+function listOf(items) {
+  const head = items.slice(0, -1);
+  const last = items[items.length - 1] ?? "";
+  return head.length === 0 ? last : `${head.join(", ")} and ${last}`;
+}
+function renderQuestionSummary(s) {
+  const homes = [
+    ...s.pages > 0 ? [`on ${plural(s.pages, "page")}`] : [],
+    ...s.files.length > 0 ? [`in ${listOf(s.files)}`] : []
+  ];
+  const { reviewed, drafted } = s.found;
+  const a = s.answers;
+  return [
+    `questions  ${String(s.total)}: ${String(s.reviewed)} reviewed, ${String(s.drafted)} drafted${homes.length > 0 ? `, ${homes.join(" and ")}` : ""}`,
+    `  found    ${String(reviewed.inTop)} of ${String(reviewed.of)} reviewed in the top ${String(s.top)} (${String(percent(reviewed.inTop, reviewed.of))}%), ${String(reviewed.first)} first (${String(percent(reviewed.first, reviewed.of))}%)`,
+    ...drafted.of > 0 ? [`  drafted  ${String(drafted.inTop)} of ${String(drafted.of)} in the top ${String(s.top)}, not counted until reviewed`] : [],
+    `  answers  ${String(a.pinned)} pinned, ${String(a.unreviewed)} not reviewed: ${String(a.current)} current, ${String(a.moved)} moved, ${String(a.changed)} changed; ${String(a.unpinned)} not pinned`,
+    ...s.gaps > 0 ? [`  gaps     ${plural(s.gaps, "question")} the docs don't answer`] : []
+  ];
+}
+async function askSampleQuestions(store, settings, sources, indexDir, view, questionFiles, configDir) {
+  const knob = settings.severity;
+  const top = settings.top;
+  const sets = questionFiles.map((label) => ({
+    label,
+    questions: readQuestionFile(resolve3(configDir, label), label)
+  }));
+  const graph = GraphIndex.fromQuads(storeToQuads(store), Object.fromEntries(PREFIXES));
+  const { pages, contents, pageAt } = await readPages(graph, sources, view, "checked");
+  const total = pages.reduce((n, p) => n + p.questions.length, 0) + sets.reduce((n, f) => n + f.questions.length, 0);
+  if (total === 0) return { findings: [] };
+  let byLanguage;
+  let manifest = [];
+  const retrievers = /* @__PURE__ */ new Map();
+  const ranked = /* @__PURE__ */ new Map();
+  const rank = async (language, question) => {
+    const key = JSON.stringify([language, question]);
+    const cached = ranked.get(key);
+    if (cached) return cached;
+    if (byLanguage === void 0) {
+      byLanguage = partitionByLanguage(
+        graph,
+        buildSearchIndex(graph, sources, { readDoc: (p) => contents.get(p) })
+      );
+      manifest = readManifest(indexDir);
+    }
+    let retriever = retrievers.get(language);
+    if (!retriever) {
+      retriever = await openRetriever(
+        byLanguage.get(language) ?? { version: 1, entries: [] },
+        manifest.find((l) => canonicalLanguageTag(l.language) === language),
+        indexDir
+      );
+      retrievers.set(language, retriever);
+    }
+    const nodes = await rankNodes(question, retriever);
+    ranked.set(key, nodes);
+    return nodes;
+  };
+  const describe = (iri) => {
+    const path = graph.literal(pageOf(iri), PATH) ?? pageOf(iri);
+    const title = iri.includes("#") ? graph.literal(iri, TITLE) : void 0;
+    return title === void 0 ? path : `${path} \xA7 ${title}`;
+  };
+  const where = (position, first) => [
+    position === 0 ? "it is not found" : `it ranks ${String(position)}`,
+    ...first === void 0 ? [] : [`first is ${describe(first)}`]
+  ].join("; ");
+  const findings = [];
+  const reporter = (target) => (kind, message, draft) => {
+    const level = kind === "knob" ? knob : kind;
+    if (level === "off") return;
+    const suffix = draft === "question" ? " (drafted, not reviewed)" : draft === "pin" ? " (answer not reviewed)" : "";
+    findings.push({
+      severity: draft ? "notice" : level,
+      message: `${message}${suffix}`,
+      focusNode: target.focusNode,
+      ...target.path === void 0 ? {} : { path: target.path },
+      docs: target.docs
+    });
+  };
+  const empty = () => ({ inTop: 0, first: 0, of: 0 });
+  const summary = {
+    total,
+    reviewed: 0,
+    drafted: 0,
+    pages: pages.length,
+    files: [...questionFiles],
+    top,
+    found: { reviewed: empty(), drafted: empty() },
+    answers: { pinned: 0, unreviewed: 0, current: 0, moved: 0, changed: 0, unpinned: 0 },
+    gaps: 0
+  };
+  const tally = (reviewed, tests) => {
+    if (tests.length === 0) return;
+    const count = reviewed ? summary.found.reviewed : summary.found.drafted;
+    count.of += 1;
+    if (tests.every((p) => p >= 1 && p <= top)) count.inTop += 1;
+    if (tests.every((p) => p === 1)) count.first += 1;
+  };
+  const askPin = async (page, pin, question, language, report, draft, file) => {
+    const fresh = freshness(page.body, pin);
+    if (fresh.state === "changed") {
+      summary.answers.changed += 1;
+      const of2 = file === void 0 ? "" : ` of ${file}`;
+      const fix = file === void 0 ? "re-pair it with manni graph fill --fields sample-questions and review it" : "re-pin it and review it";
+      report(
+        "knob",
+        `lines ${spellLines(pin.lines)}${of2} no longer hold the answer to "${question}" as pinned, so ${fix}.`,
+        draft
+      );
+      return { position: 0 };
+    }
+    const [range] = fresh.ranges;
+    const inFile = file === void 0 ? "" : ` in ${file}`;
+    if (fresh.state === "current") summary.answers.current += 1;
+    else summary.answers.moved += 1;
+    if (fresh.state === "moved" && range) {
+      report(
+        "notice",
+        `the answer to "${question}"${inFile} moved from lines ${spellLines(pin.lines)} to ${spellLines(range)}, so manni graph fill --fields sample-questions re-pins it.`,
+        draft
+      );
+    } else if (fresh.state === "ambiguous") {
+      report(
+        "warning",
+        `the answer to "${question}"${inFile} moved, and ${matchList(fresh.ranges)}, so pin one of them by hand.`,
+        draft
+      );
+    }
+    const text = range ? page.body.slice(range.start - 1, range.end).join("\n") : void 0;
+    const nodes = await rank(language, question);
+    const answering = fresh.ranges.flatMap((r) => holdersOf(page, toFileLines(r, page.bodyLine)));
+    const positions = answering.map((iri) => nodes.indexOf(iri) + 1);
+    const best = positions.reduce(
+      (b, p, i) => p >= 1 && (b.p === 0 || p < b.p) ? { p, i } : b,
+      { p: 0, i: 0 }
+    );
+    if (best.p >= 1 && best.p <= top) return { position: best.p, ...text === void 0 ? {} : { text } };
+    const holder = answering[best.i];
+    if (holder !== void 0) {
+      const title = holder.includes("#") ? graph.literal(holder, TITLE) : void 0;
+      const target = file !== void 0 ? `does not find ${describe(holder)}` : title === void 0 ? "does not find this page, whose own text answers it," : `does not find the section that answers it, \xA7 ${title},`;
+      report("knob", `"${question}" ${target} in the top ${String(top)} (${where(best.p, nodes[0])})`, draft);
+    }
+    return { position: best.p, ...text === void 0 ? {} : { text } };
+  };
+  const copies = (question, said, report, draft) => {
+    const m = said.length === 0 ? void 0 : copiedPairs(question, ...said);
+    if (m && m.copied / m.of > COPIED_SHARE) {
+      report(
+        "notice",
+        `"${question}" repeats ${String(m.copied)} of its ${String(m.of)} word pairs from its answer, so it tests matching words more than finding.`,
+        draft
+      );
+    }
+  };
+  const asked = [];
+  for (const page of pages) {
+    const report = reporter({ focusNode: page.doc, path: SAMPLE_QUESTION, docs: [page.path] });
+    for (const [n, q] of page.questions.entries()) {
+      const drafted = q.reviewed ? void 0 : "question";
+      if (q.reviewed) summary.reviewed += 1;
+      else summary.drafted += 1;
+      asked.push({ key: questionKey(q.question), where: page.path, order: n, text: q.question, report, ...drafted ? { draft: drafted } : {} });
+      if (q.answers.length === 0) summary.answers.unpinned += 1;
+      const tests = [];
+      if (q.answers.length === 0 || q.reviewed && q.answers.every((a) => !a.reviewed)) {
+        const nodes = await rank(page.language, q.question);
+        const pagesFound = [...new Set(nodes.map(pageOf))];
+        const position = pagesFound.indexOf(page.doc) + 1;
+        tests.push(position);
+        if (position < 1 || position > top) {
+          report(
+            "knob",
+            `"${q.question}" does not find this page in the top ${String(top)} (${where(position, pagesFound[0])})`,
+            drafted
+          );
+        }
+      }
+      const said = [];
+      for (const pin of q.answers) {
+        const draft = drafted ?? (pin.reviewed ? void 0 : "pin");
+        summary.answers.pinned += 1;
+        if (draft) summary.answers.unreviewed += 1;
+        const { position, text } = await askPin(page, pin, q.question, page.language, report, draft);
+        if (text !== void 0) said.push(text);
+        if (draft !== "pin") tests.push(position);
+      }
+      copies(q.question, said, report, drafted);
+      tally(q.reviewed, tests);
+    }
+  }
+  for (const set of sets) {
+    for (const [n, q] of set.questions.entries()) {
+      const report = reporter({ focusNode: `${set.label}:${String(q.line)}`, docs: [set.label] });
+      const drafted = q.reviewed ? void 0 : "question";
+      if (q.reviewed) summary.reviewed += 1;
+      else summary.drafted += 1;
+      asked.push({ key: questionKey(q.question), where: set.label, order: n, text: q.question, report, ...drafted ? { draft: drafted } : {} });
+      if (q.answers.length === 0) {
+        summary.gaps += 1;
+        continue;
+      }
+      const [firstAnswer] = q.answers;
+      const firstPage = firstAnswer && pageAt(resolve3(configDir, firstAnswer.file));
+      const language = q.language !== void 0 ? canonicalLanguageTag(q.language) : firstPage?.language ?? UNDETERMINED;
+      const tests = [];
+      const said = [];
+      for (const pin of q.answers) {
+        const draft = drafted ?? (pin.reviewed ? void 0 : "pin");
+        summary.answers.pinned += 1;
+        if (draft) summary.answers.unreviewed += 1;
+        const abs = resolve3(configDir, pin.file);
+        const page = pageAt(abs);
+        if (page === void 0) {
+          if (existsSync4(abs)) {
+            const nodes = await rank(language, q.question);
+            report("knob", `"${q.question}" does not find ${pin.file} in the top ${String(top)} (${where(0, nodes[0])})`, draft);
+          } else {
+            summary.answers.changed += 1;
+            report(
+              "knob",
+              `${pin.file}, which holds the answer to "${q.question}", does not exist, so re-pin or remove the question.`,
+              draft
+            );
+          }
+          if (draft !== "pin") tests.push(0);
+          continue;
+        }
+        const { position, text } = await askPin(page, pin, q.question, language, report, draft, pin.file);
+        if (text !== void 0) said.push(text);
+        if (draft !== "pin") tests.push(position);
+      }
+      copies(q.question, said, report, drafted);
+      tally(q.reviewed, tests);
+    }
+  }
+  asked.sort((a, b) => byCodeUnit(a.where, b.where) || a.order - b.order);
+  const firstAt = /* @__PURE__ */ new Map();
+  for (const copy of asked) {
+    if (copy.key === "") continue;
+    const first = firstAt.get(copy.key);
+    if (first === void 0) firstAt.set(copy.key, copy.where);
+    else copy.report("knob", `"${copy.text}" is also asked on ${first}, so keep it where it is answered.`, copy.draft);
+  }
+  const threshold = settings.foundThreshold;
+  const { inTop, of } = summary.found.reviewed;
+  if (threshold !== null && of > 0 && inTop / of * 100 < threshold) {
+    findings.push({
+      severity: "error",
+      message: `${String(inTop)} of ${String(of)} reviewed questions are found in the top ${String(top)} (${String(percent(inTop, of))}%), under the ${String(threshold)}% that graph.check.questions.foundThreshold asks for.`,
+      focusNode: "questions",
+      docs: []
+    });
+  }
+  return { findings, summary };
+}
+async function exportSampleQuestions(store, sources, view, questionFiles, configDir) {
+  const sets = questionFiles.map((label) => ({
+    label,
+    questions: readQuestionFile(resolve3(configDir, label), label)
+  }));
+  const graph = GraphIndex.fromQuads(storeToQuads(store), Object.fromEntries(PREFIXES));
+  const { pages, pageAt } = await readPages(graph, sources, view, "exported");
+  let stale = 0;
+  const pinned = (page, file, pin, reviewed) => {
+    const fresh = freshness(page.body, pin);
+    const range = fresh.state === "changed" ? pin.lines : fresh.ranges[0] ?? pin.lines;
+    if (fresh.state === "changed") stale += 1;
+    const first = toFileLines({ start: range.start, end: range.start }, page.bodyLine);
+    const text = page.body.slice(range.start - 1, range.end).join("\n");
+    return {
+      id: holdersOf(page, first)[0] ?? page.doc,
+      file,
+      lines: spellLines(range),
+      reviewed,
+      ...fresh.state === "changed" ? { stale: true } : {},
+      ...text === "" ? {} : { text }
+    };
+  };
+  const lines = [];
+  const write = (id, question, language, reviewed, expected) => {
+    lines.push(
+      JSON.stringify({ id, question, language, reviewed, answerable: expected.length > 0, expected })
+    );
+  };
+  for (const page of pages) {
+    const slugger = new GithubSlugger();
+    for (const q of page.questions) {
+      const expected = q.answers.length === 0 ? [{ id: page.doc, file: page.path, reviewed: q.reviewed }] : q.answers.map((pin) => pinned(page, page.path, pin, q.reviewed && pin.reviewed));
+      write(`${page.path}#${slugger.slug(q.question)}`, q.question, page.language, q.reviewed, expected);
+    }
+  }
+  for (const set of sets) {
+    const slugger = new GithubSlugger();
+    for (const q of set.questions) {
+      const expected = q.answers.map((pin) => {
+        const reviewed = q.reviewed && pin.reviewed;
+        const abs = resolve3(configDir, pin.file);
+        const page = pageAt(abs);
+        if (page) return pinned(page, pin.file, pin, reviewed);
+        const gone = !existsSync4(abs);
+        if (gone) stale += 1;
+        return { file: pin.file, lines: spellLines(pin.lines), reviewed, ...gone ? { stale: true } : {} };
+      });
+      const [firstAnswer] = q.answers;
+      const firstPage = firstAnswer && pageAt(resolve3(configDir, firstAnswer.file));
+      const language = q.language !== void 0 ? canonicalLanguageTag(q.language) : firstPage?.language ?? UNDETERMINED;
+      write(`${set.label}#${slugger.slug(q.question)}`, q.question, language, q.reviewed, expected);
+    }
+  }
+  return { lines, stale };
+}
+
+export {
+  loadGraph,
+  parseGraph,
+  storeToQuads,
+  expandTerm,
+  compactIri,
+  bundledShapesPath,
+  compareFindings,
+  validateGraph,
+  splitFragment,
+  documentSectionOrder,
+  sectionOccurrences,
+  sectionOccurrence,
+  documentPreamble,
+  sliceSection,
+  sectionOwnText,
+  createFetchResolver,
+  buildSearchIndex,
+  emitSearchIndex,
+  partitionByLanguage,
+  documentsByLanguage,
+  VectorIndexError,
+  normalize,
+  encodeVectorIndex,
+  decodeVectorIndex,
+  VectorMismatchError,
+  searchIndexDigest,
+  createVectorIndex,
+  createTrace,
+  reachedNodes,
+  rrfMerge,
+  findEntry,
+  GraphIndex,
+  createLexicalIndex,
+  EmbedderUnavailableError,
+  createLocalEmbedder,
+  createMockEmbedder,
+  SEARCH_MODES,
+  runSearch,
+  renderSearch,
+  bodyOf,
+  freshness,
+  matchList,
+  renderQuestionSummary,
+  askSampleQuestions,
+  exportSampleQuestions
+};
+//# sourceMappingURL=chunk-KCB5JCK4.js.map