@hawkeyexl/manni 4.11.0 → 4.12.1

package/dist/{chunk-2IAZEB45.js → chunk-WGMFDG6U.js}

@@ -1,8 +1,5 @@
 #!/usr/bin/env node
 import {
-  DEFAULT_CONFIG_FILENAME,
-  DEFAULT_INDEX_FILES,
-  DEFAULT_LINK_EXTENSIONS,
   GRAPH_NOT_APPLICABLE_TO_VARIANT,
   GRAPH_NOT_SOFTWARE_SUBJECT,
   GraphError,
@@ -18,12 +15,18 @@ import {
   ROLE,
   SOFTWARE_LIFECYCLE_IRIS,
   SOFTWARE_SUBJECT_IRIS,
+  STDIN,
   STDIN_PATH,
   TOPIC_TYPE_IRIS,
-  assertCollectionWithoutPaths,
+  analyzeDoc,
+  assertInputFormat,
   byCodeUnit,
+  canonicalLanguageTag,
   conceptSlug,
+  documentBase,
+  documentSetPatterns,
   encodeSegment,
+  hasScheme,
   loadRunConfig,
   mintAgentIri,
   mintBuildActivityIri,
@@ -33,521 +36,42 @@ import {
   mintProductIri,
   mintSchemeIri,
   mintSectionIri,
-  normalizeDocPath
-} from "./chunk-JROBZ7JA.js";
-import {
-  parserByName,
-  parserForExtension,
-  supportedExtensions,
-  unsupportedFormatMessage
-} from "./chunk-2IR4T5PO.js";
-import {
-  metaPageView
-} from "./chunk-LKP7QDFN.js";
+  mintTermConceptIri,
+  normalizeDocPath,
+  openMetaView,
+  parseBody,
+  readSampleQuestions,
+  resolveDocumentSet,
+  resolveRelative,
+  routesFrom,
+  withExternalMetadata
+} from "./chunk-Q2QC5AZB.js";
 import {
-  STDIN_REQUIRES_AS,
   writeTextAtomic
-} from "./chunk-GV56WGL2.js";
-import {
-  extractFrontmatter,
-  extractorForExtension
-} from "./chunk-VSEBFHAY.js";
-import {
-  selectCollections
-} from "./chunk-QLWC7MKD.js";
+} from "./chunk-WO4JYWZK.js";
 import {
-  warn
-} from "./chunk-HX44GB4Z.js";
+  termLabelSource
+} from "./chunk-DSWKBZWW.js";
 import {
   package_default
-} from "./chunk-2MJ62AYQ.js";
+} from "./chunk-7MCQHTQ5.js";
 import {
   errorMessage
 } from "./chunk-G3T47CFV.js";
 
 // src/graph/commands/build.ts
 import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
-import { dirname, resolve as resolve3 } from "node:path";
-
-// src/graph/core/analyze.ts
-import { createHash } from "node:crypto";
-import { extname } from "node:path";
-import { unified } from "unified";
-import remarkParse from "remark-parse";
-import remarkGfm from "remark-gfm";
-import remarkFrontmatter from "remark-frontmatter";
-import remarkMdx from "remark-mdx";
-import { toString as mdastToString } from "mdast-util-to-string";
-import GithubSlugger from "github-slugger";
-var DOC_FORMATS = [
-  "asciidoc",
-  "html",
-  "markdown",
-  "mdx",
-  "rst",
-  "xml"
-];
-function isTreeFormat(format) {
-  return format !== "markdown" && format !== "mdx";
-}
-function isDocFormat(name) {
-  return DOC_FORMATS.includes(name);
-}
-function formatOf(path, format) {
-  if (format !== void 0) return format;
-  const name = parserForExtension(extname(path))?.name;
-  return name !== void 0 && isDocFormat(name) ? name : "markdown";
-}
-var processor = unified().use(remarkParse).use(remarkGfm).use(remarkFrontmatter, ["yaml", "toml"]);
-var mdxProcessor = unified().use(remarkParse).use(remarkGfm).use(remarkFrontmatter, ["yaml", "toml"]).use(remarkMdx);
-var IMAGE_ELEMENTS = /* @__PURE__ */ new Set(["img", "image"]);
-function jsxAttributeValue(node, attributeName) {
-  const attributes = node.attributes;
-  if (!Array.isArray(attributes)) return void 0;
-  for (const attribute of attributes) {
-    if (attribute.type !== "mdxJsxAttribute") continue;
-    if (attribute.name !== attributeName) continue;
-    return typeof attribute.value === "string" ? attribute.value : void 0;
-  }
-  return void 0;
-}
-function hasScheme(target) {
-  return /^[a-z][a-z0-9+.-]*:/i.test(target);
-}
-function resolveRelative(docPath, target) {
-  const baseSegments = normalizeDocPath(docPath).split("/").slice(0, -1);
-  const segments = [...baseSegments];
-  for (const part of target.split("/")) {
-    if (part === "" || part === ".") continue;
-    if (part === "..") {
-      if (segments.length === 0) return null;
-      if (segments[segments.length - 1] === "..") segments.push("..");
-      else segments.pop();
-    } else {
-      segments.push(part);
-    }
-  }
-  return segments.join("/");
-}
-var HAS_EXTENSION = /\.[a-z0-9]+$/i;
-function addressesDocument(target, extensions) {
-  if (target === "" || !HAS_EXTENSION.test(target)) return true;
-  if (extensions.length === 0) return true;
-  const ext = target.slice(target.lastIndexOf(".")).toLowerCase();
-  return extensions.some((e) => e.toLowerCase() === ext);
-}
-function slugNorm(path) {
-  return path.toLowerCase().replace(/[-_]/g, "");
-}
-var PathIndex = class {
-  constructor(exact) {
-    this.exact = exact;
-    for (const path of exact) {
-      const lower = path.toLowerCase();
-      this.lower.set(lower, this.lower.has(lower) ? null : path);
-      const slug = slugNorm(path);
-      this.slugged.set(slug, this.slugged.has(slug) ? null : path);
-    }
-  }
-  exact;
-  lower = /* @__PURE__ */ new Map();
-  slugged = /* @__PURE__ */ new Map();
-  resolve(candidate) {
-    if (this.exact.has(candidate)) return candidate;
-    return this.lower.get(candidate.toLowerCase()) ?? this.slugged.get(slugNorm(candidate)) ?? void 0;
-  }
-};
-function safeDecode(value) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-function targetCandidates(target, isDirectory, extensions, indexFiles) {
-  if (target !== "" && HAS_EXTENSION.test(target)) return [target];
-  const extensionCandidates = target === "" ? [] : extensions.map((ext) => `${target}${ext}`);
-  const dir = target === "" ? "" : `${target}/`;
-  const indexCandidates = [];
-  for (const indexFile of indexFiles) {
-    for (const ext of extensions)
-      indexCandidates.push(`${dir}${indexFile}${ext}`);
-  }
-  return isDirectory ? [...indexCandidates, ...extensionCandidates] : [...extensionCandidates, ...indexCandidates];
-}
-function routeLanguageFor(path, routes) {
-  let best;
-  for (const mapping of routes) {
-    if (mapping.language === void 0) continue;
-    const root = mapping.root;
-    const covers = root === "" || path === root || path.startsWith(`${root}/`);
-    if (!covers) continue;
-    if (best === void 0 || root.length > best.root.length) {
-      best = { root, language: mapping.language };
-    }
-  }
-  return best?.language;
-}
-function resolveRoute(pathPart, routes, index) {
-  const isDirectory = /\/+$/.test(pathPart);
-  const clean = safeDecode(pathPart).replace(/\/+$/, "");
-  let anyMatched = false;
-  for (const mapping of routes) {
-    if (clean !== mapping.basePath && !clean.startsWith(`${mapping.basePath}/`)) {
-      continue;
-    }
-    const rest = clean.slice(mapping.basePath.length).replace(/^\/+/, "");
-    if (!addressesDocument(rest, mapping.extensions)) continue;
-    anyMatched = true;
-    const prefix = mapping.root ? `${mapping.root}/` : "";
-    const stem = rest === "" ? mapping.root : `${prefix}${rest}`;
-    const candidates = targetCandidates(
-      stem,
-      isDirectory || rest === "",
-      mapping.extensions,
-      mapping.indexFiles
-    );
-    for (const candidate of candidates) {
-      const resolved = index.resolve(candidate);
-      if (resolved) return resolved;
-    }
-  }
-  return anyMatched ? "broken" : null;
-}
-var indexCache = /* @__PURE__ */ new WeakMap();
-function pathIndexFor(allPaths) {
-  let index = indexCache.get(allPaths);
-  if (!index) {
-    index = new PathIndex(allPaths);
-    indexCache.set(allPaths, index);
-  }
-  return index;
-}
-function classifyLink(docPath, rawTarget, allPaths, routes) {
-  const raw = rawTarget;
-  if (hasScheme(raw)) {
-    try {
-      return { raw, kind: "external", url: new URL(raw).href };
-    } catch {
-      return null;
-    }
-  }
-  const hashAt = raw.indexOf("#");
-  const pathPart = hashAt === -1 ? raw : raw.slice(0, hashAt);
-  const anchor = hashAt === -1 ? void 0 : raw.slice(hashAt + 1);
-  if (pathPart === "") return null;
-  if (pathPart.startsWith("/")) {
-    const resolved2 = resolveRoute(pathPart, routes, pathIndexFor(allPaths));
-    if (resolved2 === null) return null;
-    if (resolved2 === "broken") return { raw, kind: "broken" };
-    const link = { raw, kind: "internal", resolvedPath: resolved2 };
-    if (anchor) link.anchor = anchor;
-    return link;
-  }
-  const resolved = resolveRelative(docPath, safeDecode(pathPart));
-  if (resolved !== null) {
-    const index = pathIndexFor(allPaths);
-    let candidates;
-    if (allPaths.has(resolved)) {
-      candidates = [resolved];
-    } else if (HAS_EXTENSION.test(resolved)) {
-      if (!addressesDocument(resolved, DEFAULT_LINK_EXTENSIONS)) return null;
-      candidates = [];
-    } else {
-      candidates = targetCandidates(
-        resolved,
-        pathPart.endsWith("/"),
-        DEFAULT_LINK_EXTENSIONS,
-        DEFAULT_INDEX_FILES
-      );
-    }
-    for (const candidate of candidates) {
-      const hit = index.resolve(candidate);
-      if (hit) {
-        const link = { raw, kind: "internal", resolvedPath: hit };
-        if (anchor) link.anchor = anchor;
-        return link;
-      }
-    }
-  }
-  return { raw, kind: "broken" };
-}
-function classifyImage(docPath, rawTarget) {
-  if (hasScheme(rawTarget)) {
-    return { raw: rawTarget, target: rawTarget, external: true };
-  }
-  const resolved = resolveRelative(docPath, rawTarget);
-  return { raw: rawTarget, target: resolved ?? rawTarget, external: false };
-}
-function extractorFor(format) {
-  return extractorForExtension(parserByName(format)?.extensions[0] ?? "");
-}
-function metadataOf(content, path, format) {
-  try {
-    const meta = format === "markdown" || format === "mdx" ? extractFrontmatter(content, "markdown") : extractorFor(format)?.extract(content, path);
-    return meta === void 0 ? { data: {}, present: false } : { data: meta.data, present: meta.present };
-  } catch (error) {
-    throw new GraphError(`${path}: ${errorMessage(error)}`);
-  }
-}
-function analyzeDoc(content, relPath, allPaths, options = {}) {
-  const routes = options.routes ?? [];
-  const path = normalizeDocPath(relPath);
-  const format = formatOf(path, options.format);
-  const parse = options.parse ?? parseBody;
-  let body = isTreeFormat(format) ? parse(content, path, format) : void 0;
-  const meta = metadataOf(content, path, format);
-  body ??= parse(content, path, format);
-  const links = [];
-  for (const target of body.linkTargets) {
-    const link = classifyLink(path, target, allPaths, routes);
-    if (link) links.push(link);
-  }
-  const routeLanguage = routeLanguageFor(path, routes);
-  return {
-    path,
-    frontmatter: meta.data,
-    frontmatterPresent: meta.present,
-    format,
-    firstH1: body.firstH1,
-    sections: body.sections,
-    links,
-    images: body.imageTargets.map((target) => classifyImage(path, target)),
-    codeLanguages: body.codeLanguages,
-    // Omitted rather than set to undefined, so a doc under no localized route
-    // carries no key at all — `routeLanguage` in JSON output means something.
-    ...routeLanguage === void 0 ? {} : { routeLanguage },
-    // Over the content as read — line endings included, so the digest is
-    // byte-faithful and equals `sha256sum <file>` for any valid-UTF-8 file
-    // (ADR 01036). The CRLF corpus fixture depends on this not normalizing.
-    contentHash: createHash("sha256").update(content, "utf8").digest("hex")
-  };
-}
-function parseBody(content, path, format) {
-  if (isTreeFormat(format)) return parseTreeBody(content, path, format);
-  const isMdx = format === "mdx";
-  let tree;
-  try {
-    tree = (isMdx ? mdxProcessor : processor).parse(content);
-  } catch (error) {
-    if (!isMdx) throw error;
-    const reason = errorMessage(error);
-    throw new GraphError(`Could not parse MDX in ${path}: ${reason}`);
-  }
-  const sections = [];
-  const linkTargets = [];
-  const imageTargets = [];
-  const codeLanguages = /* @__PURE__ */ new Set();
-  const definitions = /* @__PURE__ */ new Map();
-  let firstH1;
-  visit(tree, (node) => {
-    if (node.type === "definition") {
-      const def = node;
-      definitions.set(def.identifier, def);
-    }
-  });
-  const slugger = new GithubSlugger();
-  const stack = [];
-  const childCount = /* @__PURE__ */ new Map();
-  visit(tree, (node) => {
-    switch (node.type) {
-      case "heading": {
-        const level = node.depth;
-        const title = mdastToString(node);
-        const slug = slugger.slug(title);
-        if (level === 1 && firstH1 === void 0) firstH1 = title;
-        for (let top = stack.at(-1); top !== void 0 && top.level >= level; top = stack.at(-1)) {
-          stack.pop();
-        }
-        const parentSlug = stack.at(-1)?.slug ?? null;
-        const parentKey = parentSlug ?? "";
-        const order = (childCount.get(parentKey) ?? 0) + 1;
-        childCount.set(parentKey, order);
-        sections.push({ slug, title, level, order, parentSlug });
-        stack.push({ level, slug });
-        break;
-      }
-      case "link": {
-        linkTargets.push(node.url);
-        break;
-      }
-      case "linkReference": {
-        const def = definitions.get(
-          node.identifier
-        );
-        if (def) linkTargets.push(def.url);
-        break;
-      }
-      case "image": {
-        imageTargets.push(node.url);
-        break;
-      }
-      case "imageReference": {
-        const def = definitions.get(
-          node.identifier
-        );
-        if (def) imageTargets.push(def.url);
-        break;
-      }
-      case "code": {
-        const lang = node.lang;
-        if (lang) codeLanguages.add(lang);
-        break;
-      }
-      // A JSX element's `href` is a link and its `src` is an image, on any
-      // element (ADR 01022). Those are HTML's own names for the relationships,
-      // so this stays structural — dockg never learns what `<LinkCard>` means.
-      case "mdxJsxFlowElement":
-      case "mdxJsxTextElement": {
-        const href = jsxAttributeValue(node, "href");
-        if (href !== void 0) linkTargets.push(href);
-        const name = node.name ?? "";
-        if (IMAGE_ELEMENTS.has(name.toLowerCase())) {
-          const src = jsxAttributeValue(node, "src");
-          if (src !== void 0) imageTargets.push(src);
-        }
-        break;
-      }
-    }
-  });
-  return {
-    firstH1,
-    sections,
-    linkTargets,
-    imageTargets,
-    codeLanguages: [...codeLanguages].sort()
-  };
-}
-function parseTree(content, path, format) {
-  const parser = parserByName(format);
-  if (parser === void 0) {
-    throw new GraphError(`No parser reads ${format}.`);
-  }
-  try {
-    return parser.parse(content, path);
-  } catch (error) {
-    throw new GraphError(
-      `Could not parse ${format} in ${path}: ${errorMessage(error)}`
-    );
-  }
-}
-var IRI_SAFE_ID = /^[A-Za-z_][A-Za-z0-9_.:-]*$/;
-function mintTreeSections(roots) {
-  const out = {
-    sections: [],
-    owned: [],
-    unowned: [],
-    firstH1: void 0
-  };
-  const slugger = new GithubSlugger();
-  const taken = /* @__PURE__ */ new Set();
-  const childCount = /* @__PURE__ */ new Map();
-  const anchorFor = (node) => {
-    const id = node.id;
-    if (id !== void 0 && IRI_SAFE_ID.test(id) && !id.startsWith("prov.")) {
-      let anchor2 = id;
-      for (let n = 1; taken.has(anchor2); n++) anchor2 = `${id}-${String(n)}`;
-      taken.add(anchor2);
-      return anchor2;
-    }
-    let anchor = slugger.slug(node.title);
-    while (taken.has(anchor)) anchor = slugger.slug(node.title);
-    taken.add(anchor);
-    return anchor;
-  };
-  const walk = (nodes, parentSlug) => {
-    for (const node of nodes) {
-      if (node.level === 0 || node.synthetic || node.title.trim() === "") {
-        out.unowned.push(...node.children);
-        walk(node.sections, parentSlug);
-        continue;
-      }
-      const slug = anchorFor(node);
-      if (node.level === 1 && out.firstH1 === void 0) {
-        out.firstH1 = node.title;
-      }
-      const parentKey = parentSlug ?? "";
-      const order = (childCount.get(parentKey) ?? 0) + 1;
-      childCount.set(parentKey, order);
-      out.sections.push({
-        slug,
-        title: node.title,
-        level: node.level,
-        order,
-        parentSlug
-      });
-      out.owned.push(node.children);
-      walk(node.sections, slug);
-    }
-  };
-  walk(roots, null);
-  return out;
-}
-function eachContent(nodes, fn) {
-  for (const node of nodes) {
-    fn(node);
-    switch (node.kind) {
-      case "list":
-        for (const item of node.items) eachContent(item.children, fn);
-        break;
-      case "table":
-        for (const row of node.children) {
-          for (const cell of row.children) eachContent(cell.children, fn);
-        }
-        break;
-      case "definitionList":
-        for (const item of node.children) eachContent(item.definition, fn);
-        break;
-      case "admonition":
-      case "blockquote":
-      case "element":
-        eachContent(node.children, fn);
-        break;
-      default:
-        break;
-    }
-  }
-}
-function treeContent(sections) {
-  return sections.flatMap((s) => [...s.children, ...treeContent(s.sections)]);
-}
-function parseTreeBody(content, path, format) {
-  const tree = parseTree(content, path, format);
-  const minted = mintTreeSections(tree.sections);
-  const imageTargets = [];
-  const codeLanguages = /* @__PURE__ */ new Set();
-  eachContent(treeContent(tree.sections), (node) => {
-    if (node.kind === "image") imageTargets.push(node.url);
-    else if (node.kind === "codeBlock" && node.language) {
-      codeLanguages.add(node.language);
-    }
-  });
-  return {
-    ...minted.firstH1 === void 0 ? {} : { firstH1: minted.firstH1 },
-    sections: minted.sections,
-    linkTargets: tree.links.map((l) => l.target),
-    imageTargets,
-    codeLanguages: [...codeLanguages].sort()
-  };
-}
-function visit(node, fn) {
-  const children = node.children;
-  if (!children) return;
-  for (const child of children) {
-    fn(child);
-    visit(child, fn);
-  }
-}
+import { dirname, resolve } from "node:path";
 
 // src/graph/core/analyze-cache.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash } from "node:crypto";
 import { mkdir } from "node:fs/promises";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 var ANALYZE_CACHE_DIR = ".manni/graph/analyze-cache";
 var ENTRY_VERSION = 1;
 function sha256(text) {
-  return createHash2("sha256").update(text, "utf8").digest("hex");
+  return createHash("sha256").update(text, "utf8").digest("hex");
 }
 var isStrings = (value) => Array.isArray(value) && value.every((v) => typeof v === "string");
 function isSection(value) {
@@ -609,87 +133,73 @@ function readEntry(file, key) {
   }
 }
 
-// src/graph/core/localizations.ts
-var LOCALIZATIONS_FILENAME = "localizations.json";
-var UNDETERMINED = "und";
-var LANGUAGE_TAG = /^[A-Za-z]{2,3}(-[A-Za-z]{4})?(-([A-Za-z]{2}|[0-9]{3}))?(-([A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*$/;
-function isLanguageTag(value) {
-  return LANGUAGE_TAG.test(value);
-}
-function canonicalLanguageTag(tag) {
-  try {
-    return Intl.getCanonicalLocales(tag)[0] ?? tag;
-  } catch {
-    return tag;
-  }
-}
-function searchIndexFilename(language) {
-  return `search.${language}.json`;
-}
-function vectorIndexFilename(language) {
-  return `vectors.${language}.bin`;
+// src/graph/core/concepts.ts
+function canonicalLanguage(tag) {
+  return tag === void 0 || tag === "" ? void 0 : canonicalLanguageTag(tag);
+}
+var primary = (tag) => (tag.split("-")[0] ?? "").toLowerCase();
+var MAX_REDIRECTS = 8;
+var built = /* @__PURE__ */ new WeakMap();
+function termIndex(terms) {
+  const cached = built.get(terms);
+  if (cached !== void 0) return cached;
+  const index = buildTermIndex(terms);
+  built.set(terms, index);
+  return index;
 }
-function emitLocalizations(doc) {
-  const languages = [...doc.languages].sort(
-    (a, b) => byCodeUnit(a.language, b.language)
+function buildTermIndex(terms) {
+  const sorted = [...terms].map((t) => ({ term: t, language: canonicalLanguage(t.language) })).sort(
+    (a, b) => byCodeUnit(a.term.id, b.term.id) || byCodeUnit(a.language ?? "", b.language ?? "") || byCodeUnit(a.term.label, b.term.label)
   );
-  return `${JSON.stringify({ version: doc.version, languages }, null, 2)}
-`;
-}
-function isRecord(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function parseLocalizations(text) {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    return void 0;
-  }
-  if (!isRecord(parsed)) return void 0;
-  if (parsed["version"] !== 1 || !Array.isArray(parsed["languages"])) {
-    return void 0;
-  }
-  for (const entry of parsed["languages"]) {
-    if (!isRecord(entry)) return void 0;
-    const language = entry["language"];
-    const search = entry["search"];
-    if (typeof language !== "string" || !isLanguageTag(language) || typeof entry["documents"] !== "number" || !isRecord(search) || typeof search["path"] !== "string" || typeof search["entries"] !== "number" || typeof search["digest"] !== "string" || !ownsFilename(search["path"], searchIndexFilename(language))) {
-      return void 0;
+  const groups = /* @__PURE__ */ new Map();
+  const redirects = [];
+  const byLabel = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  const byAlt = /* @__PURE__ */ new Map();
+  const put = (map, value, key) => {
+    const k = value.toLowerCase();
+    const list = map.get(k);
+    if (list) list.push(key);
+    else map.set(k, [key]);
+  };
+  for (const { term, language } of sorted) {
+    const target = term.see === void 0 ? { id: term.id } : { see: term.see, language };
+    if (term.see === void 0) {
+      const group = groups.get(term.id);
+      if (group) group.push(term);
+      else groups.set(term.id, [term]);
+    } else {
+      redirects.push(term);
     }
-    const v = entry["vectors"];
-    if (v !== void 0) {
-      if (!isRecord(v) || typeof v["path"] !== "string" || typeof v["model"] !== "string" || typeof v["dtype"] !== "string" || typeof v["dims"] !== "number" || typeof v["count"] !== "number" || // Same constraint `search.path` gets: the last segment must be the
-      // filename this language's sidecar would be given. Without it,
-      // `isSafeRelativePath` alone leaves `vectors.path` far more reachable
-      // than `search.path` — and `search --mode vector` opens it.
-      !ownsFilename(v["path"], vectorIndexFilename(language))) {
-        return void 0;
+    put(byLabel, term.label, { language, target });
+    put(byId, term.id, { language, target });
+    for (const alt of term.altLabels ?? []) put(byAlt, alt, { language, target });
+  }
+  const tiers = [byLabel, byId, byAlt];
+  const resolve2 = (label, language, depth) => {
+    const wanted = canonicalLanguage(language);
+    const passes = wanted === void 0 ? [() => true] : [
+      (k) => k.language === wanted,
+      (k) => k.language !== void 0 && primary(k.language) === primary(wanted),
+      () => true
+    ];
+    const needle = label.toLowerCase();
+    for (const pass of passes) {
+      for (const tier of tiers) {
+        const hit = tier.get(needle)?.find(pass);
+        if (hit === void 0) continue;
+        if ("id" in hit.target) return hit.target.id;
+        if (depth >= MAX_REDIRECTS) return void 0;
+        return resolve2(hit.target.see, hit.target.language ?? wanted, depth + 1);
       }
     }
-  }
-  return parsed;
-}
-function isSafeRelativePath(path) {
-  if (path === "" || path.startsWith("/") || /^[A-Za-z]:/.test(path)) {
-    return false;
-  }
-  if (path.includes("\\")) return false;
-  const segments = path.split("/");
-  let leading = true;
-  for (const segment of segments) {
-    if (segment === "" || segment === ".") return false;
-    if (segment === "..") {
-      if (!leading) return false;
-      continue;
-    }
-    leading = false;
-  }
-  return true;
-}
-function ownsFilename(path, expected) {
-  if (!isSafeRelativePath(path)) return false;
-  return path.slice(path.lastIndexOf("/") + 1) === expected;
+    return void 0;
+  };
+  return {
+    groups,
+    redirects,
+    resolve: (label, language) => groups.size === 0 ? void 0 : resolve2(label, language, 0)
+  };
 }
 
 // src/graph/core/derive.ts
@@ -699,6 +209,15 @@ function resolveProvDocPath(docPath, raw, docByPath) {
   const repoRelative = normalizeDocPath(raw);
   return docByPath.has(repoRelative) ? repoRelative : null;
 }
+function termConceptCount(termbase) {
+  return termIndex(termbase).groups.size;
+}
+var INVERSE = {
+  broader: "narrower",
+  narrower: "broader",
+  related: "related"
+};
+var CONCEPT_SCHEME_TITLE = "manni graph concepts";
 var iri = (value) => ({ kind: "iri", value });
 var lit = (value) => ({ kind: "literal", value });
 var typedLit = (value, datatype) => ({
@@ -789,7 +308,10 @@ function deriveGraph(docs, options) {
   const quads = [];
   const add = (s, p, o) => quads.push({ s, p, o });
   const mintedConcepts = /* @__PURE__ */ new Set();
-  const concept = (label) => {
+  const terms = termIndex(sources.has("terms") ? options.termbase ?? [] : []);
+  const concept = (label, language) => {
+    const id = terms.resolve(label, language);
+    if (id !== void 0) return mintTermConceptIri(baseIri, id);
     const c = mintConceptIri(baseIri, label);
     add(c, RDF_TYPE, iri(`${NS.skos}Concept`));
     add(c, `${NS.skos}prefLabel`, lit(label));
@@ -797,6 +319,10 @@ function deriveGraph(docs, options) {
     mintedConcepts.add(c);
     return c;
   };
+  const hierarchy = (s, relation, o) => {
+    add(s, `${NS.skos}${relation}`, iri(o));
+    add(o, `${NS.skos}${INVERSE[relation]}`, iri(s));
+  };
   const variantNode = (label) => {
     const variant = mintProductIri(baseIri, label);
     add(variant, RDF_TYPE, iri(IIRDS_PRODUCT_VARIANT));
@@ -885,6 +411,9 @@ function deriveGraph(docs, options) {
     const fm = doc.frontmatter;
     const block = graphBlock(fm);
     const harvested = resolveGraph(block, fm);
+    const pageLanguage = canonicalLanguage(
+      asString(fmValue(fm, ["lang", "language"])) ?? doc.routeLanguage
+    );
     let createdEmitted = false;
     let modifiedEmitted = false;
     add(docIri, RDF_TYPE, iri(`${NS.graph}Document`));
@@ -917,9 +446,13 @@ function deriveGraph(docs, options) {
         add(docIri, `${NS.dcterms}modified`, dateTerm(modified));
         modifiedEmitted = true;
       }
-      const language = asString(fmValue(fm, ["lang", "language"])) ?? doc.routeLanguage;
-      if (language) {
-        add(docIri, `${NS.dcterms}language`, lit(canonicalLanguageTag(language)));
+      if (pageLanguage) add(docIri, `${NS.dcterms}language`, lit(pageLanguage));
+      for (const { question } of readSampleQuestions(fmValue(fm, ["sample-questions"]))) {
+        add(
+          docIri,
+          `${NS.graph}sampleQuestion`,
+          pageLanguage ? { kind: "literal", value: question, language: pageLanguage } : lit(question)
+        );
       }
       for (const raw of asStringArray(fmValue(fm, ["translation-of"]))) {
         provTargetEdge(
@@ -930,10 +463,10 @@ function deriveGraph(docs, options) {
           `${NS.schema}workTranslation`
         );
       }
+      const blockLabel = block ? asString(block["label"]) : void 0;
       if (block) {
-        const label = asString(block["label"]);
-        if (label) {
-          const topic = concept(label);
+        if (blockLabel) {
+          const topic = concept(blockLabel, pageLanguage);
           add(docIri, `${NS.foaf}primaryTopic`, iri(topic));
           for (const alt of asStringArray(block["alt-labels"])) {
             add(topic, `${NS.skos}altLabel`, lit(alt));
@@ -944,11 +477,19 @@ function deriveGraph(docs, options) {
             ["related-concepts", "related"]
           ]) {
             for (const value of asStringArray(block[key])) {
-              add(topic, `${NS.skos}${predicate}`, iri(concept(value)));
+              hierarchy(topic, predicate, concept(value, pageLanguage));
             }
           }
         }
       }
+      if (!blockLabel && asString(fm["type"]) === "term") {
+        const id = asString(fm["id"]);
+        const label = asString(fm["label"]);
+        const termId = (id !== void 0 && terms.groups.has(id) ? id : void 0) ?? (label === void 0 ? void 0 : terms.resolve(label, pageLanguage));
+        if (termId !== void 0) {
+          add(docIri, `${NS.foaf}primaryTopic`, iri(mintTermConceptIri(baseIri, termId)));
+        }
+      }
       emitIirdsTyping(docIri, harvested);
     }
     if (sources.has("tags")) {
@@ -957,7 +498,7 @@ function deriveGraph(docs, options) {
         ...asStringArray(harvested["concepts"])
       ];
       for (const label of labels) {
-        add(docIri, `${NS.dcterms}subject`, iri(concept(label)));
+        add(docIri, `${NS.dcterms}subject`, iri(concept(label, pageLanguage)));
       }
     }
     if (sources.has("sections")) {
@@ -982,7 +523,7 @@ function deriveGraph(docs, options) {
         const meta = asRecord(sectionMeta[section.slug]);
         emitIirdsTyping(secIri, meta);
         for (const label of asStringArray(meta["concepts"])) {
-          add(secIri, `${NS.dcterms}subject`, iri(concept(label)));
+          add(secIri, `${NS.dcterms}subject`, iri(concept(label, pageLanguage)));
         }
       }
       for (const slug of Object.keys(sectionMeta)) {
@@ -1099,10 +640,13 @@ function deriveGraph(docs, options) {
         }
         const label = block ? asString(block["label"]) : void 0;
         if (label && filled.has("label")) {
+          const id = terms.resolve(label, pageLanguage);
           add(
             activity,
             `${NS.prov}generated`,
-            iri(mintConceptIri(baseIri, label))
+            iri(
+              id === void 0 ? mintConceptIri(baseIri, label) : mintTermConceptIri(baseIri, id)
+            )
           );
         }
       }
@@ -1132,15 +676,70 @@ function deriveGraph(docs, options) {
       );
     }
   }
+  const tagged = (value, language) => language === void 0 ? lit(value) : { kind: "literal", value, language };
+  for (const [id, entries] of terms.groups) {
+    const c = mintTermConceptIri(baseIri, id);
+    add(c, RDF_TYPE, iri(`${NS.skos}Concept`));
+    add(c, `${NS.skos}inScheme`, iri(mintSchemeIri(baseIri)));
+    mintedConcepts.add(c);
+    for (const entry of entries) {
+      const language = canonicalLanguage(entry.language);
+      add(c, `${NS.skos}prefLabel`, tagged(entry.label, language));
+      for (const [values, predicate] of [
+        [entry.altLabels, "altLabel"],
+        [entry.hiddenLabels, "hiddenLabel"],
+        [entry.definition, "definition"],
+        [entry.scopeNote, "scopeNote"]
+      ]) {
+        for (const value of asStringArray(values)) {
+          add(c, `${NS.skos}${predicate}`, tagged(value, language));
+        }
+      }
+      for (const relation of ["broader", "narrower", "related"]) {
+        for (const value of entry[relation] ?? []) {
+          hierarchy(c, relation, concept(value, language));
+        }
+      }
+      if (entry.notation !== void 0) add(c, `${NS.skos}notation`, lit(entry.notation));
+      for (const [values, predicate] of [
+        [entry.exactMatches, "exactMatch"],
+        [entry.closeMatches, "closeMatch"],
+        [entry.broadMatches, "broadMatch"],
+        [entry.narrowMatches, "narrowMatch"],
+        [entry.relatedMatches, "relatedMatch"]
+      ]) {
+        for (const value of values ?? []) add(c, `${NS.skos}${predicate}`, iri(value));
+      }
+    }
+  }
+  for (const entry of terms.redirects) {
+    const language = canonicalLanguage(entry.language);
+    const target = entry.see === void 0 ? void 0 : terms.resolve(entry.see, language);
+    if (target === void 0) continue;
+    add(
+      mintTermConceptIri(baseIri, target),
+      `${NS.skos}altLabel`,
+      tagged(entry.label, language)
+    );
+  }
   if (mintedConcepts.size > 0) {
     const scheme = mintSchemeIri(baseIri);
     add(scheme, RDF_TYPE, iri(`${NS.skos}ConceptScheme`));
-    add(scheme, `${NS.dcterms}title`, lit("manni graph concepts"));
+    add(scheme, `${NS.dcterms}title`, lit(CONCEPT_SCHEME_TITLE));
+    const broader = `${NS.skos}broader`;
+    const hasBroader = new Set(
+      quads.filter((q) => q.p === broader).map((q) => q.s)
+    );
+    for (const c of mintedConcepts) {
+      if (hasBroader.has(c)) continue;
+      add(c, `${NS.skos}topConceptOf`, iri(scheme));
+      add(scheme, `${NS.skos}hasTopConcept`, iri(c));
+    }
   }
   return dedupe(quads);
 }
 function quadKey(q) {
-  const o = q.o.kind === "iri" ? `i:${q.o.value}` : `l:${q.o.value}|${q.o.datatype ?? ""}`;
+  const o = q.o.kind === "iri" ? `i:${q.o.value}` : `l:${q.o.value}|${q.o.datatype ?? ""}|${q.o.language ?? ""}`;
   return `${q.s}|${q.p}|${o}`;
 }
 function dedupe(quads) {
@@ -1155,154 +754,6 @@ function dedupe(quads) {
   return out;
 }
 
-// src/graph/core/discover.ts
-import { statSync } from "node:fs";
-import { extname as extname2, relative, resolve } from "node:path";
-import fg from "fast-glob";
-function discoverFiles(inputs, exclude, cwd) {
-  const matches = fg.sync(inputs, {
-    cwd,
-    ignore: exclude,
-    onlyFiles: true,
-    dot: false,
-    unique: true
-  });
-  return [...new Set(matches.map((m) => m.replace(/\\/g, "/")))].sort(
-    byCodeUnit
-  );
-}
-var FAMILY_EXCLUDE = ["**/node_modules/**", "**/.git/**"];
-var DEFAULT_EXTENSIONS = supportedExtensions();
-var STDIN = "-";
-function assertInputFormat(paths, as) {
-  if (as === void 0) {
-    if (paths.includes(STDIN)) throw new GraphError(STDIN_REQUIRES_AS);
-    return void 0;
-  }
-  if (!isDocFormat(as)) {
-    throw new GraphError(
-      `Unknown format "${as}". Known formats: ${DOC_FORMATS.join(", ")}.`
-    );
-  }
-  return as;
-}
-function expandInputs(inputs, base, ignore) {
-  const named = [];
-  const patterns = [];
-  for (const input of inputs) {
-    if (fg.isDynamicPattern(input)) {
-      patterns.push(input.replace(/\\/g, "/"));
-      continue;
-    }
-    let isDirectory;
-    try {
-      isDirectory = statSync(resolve(base, input)).isDirectory();
-    } catch {
-      patterns.push(input.replace(/\\/g, "/"));
-      continue;
-    }
-    const literal = fg.convertPathToPattern(input);
-    if (isDirectory) patterns.push(`${literal.replace(/\/$/, "")}/**/*`);
-    else named.push(...glob([literal], base, ignore));
-  }
-  return { named, walked: glob(patterns, base, ignore) };
-}
-function glob(patterns, base, ignore) {
-  if (patterns.length === 0) return [];
-  return fg.sync(patterns, {
-    cwd: base,
-    ignore,
-    absolute: true,
-    dot: false,
-    onlyFiles: true
-  });
-}
-function normalizeExtensions(exts) {
-  return new Set(
-    exts.map((e) => {
-      const lower = e.toLowerCase();
-      return lower.startsWith(".") ? lower : `.${lower}`;
-    })
-  );
-}
-function resolveDocumentSet(config, options = {}, verb = "build", cwd = process.cwd(), base = documentBase(config, options, cwd)) {
-  const paths = options.paths ?? [];
-  const wanted = options.collection ?? [];
-  assertCollectionWithoutPaths(wanted, paths);
-  const format = assertInputFormat(paths, options.as);
-  if (wanted.length > 0 && config.configSource === null) {
-    throw new GraphError("--collection needs a config file to select from.");
-  }
-  const collections = selectCollections(
-    config.collections,
-    wanted,
-    config.configSource ?? DEFAULT_CONFIG_FILENAME,
-    (message) => new GraphError(message)
-  );
-  const exclude = [...FAMILY_EXCLUDE, ...options.exclude ?? []];
-  let named = [];
-  let walked;
-  if (paths.length > 0) {
-    ({ named, walked } = expandInputs(
-      paths.filter((p) => p !== STDIN),
-      cwd,
-      exclude
-    ));
-  } else {
-    const patterns = collections.flatMap((c) => c.paths);
-    if (patterns.length === 0) {
-      throw new GraphError(
-        `No files to ${verb}. Pass paths/globs, or declare a collection under \`collections:\` in manni.config.yaml.`
-      );
-    }
-    walked = collections.flatMap((c) => {
-      const found = expandInputs(c.paths, config.configDir, [
-        ...exclude,
-        ...c.exclude
-      ]);
-      return [...found.named, ...found.walked];
-    });
-  }
-  const exts = normalizeExtensions(options.ext ?? DEFAULT_EXTENSIONS);
-  const keepNamed = (p) => {
-    const ext = extname2(p);
-    if (format !== void 0 || parserForExtension(ext) !== void 0) {
-      return true;
-    }
-    const label = relative(base, p).replace(/\\/g, "/");
-    warn(`skipped ${label}: ${unsupportedFormatMessage(ext || label)}`);
-    return false;
-  };
-  const keepWalked = (p) => exts.has(extname2(p).toLowerCase());
-  return [
-    ...new Set(
-      [...named.filter(keepNamed), ...walked.filter(keepWalked)].map(
-        (p) => relative(base, p).replace(/\\/g, "/")
-      )
-    )
-  ].sort(byCodeUnit);
-}
-function documentBase(config, options = {}, cwd = process.cwd()) {
-  const typed = (options.paths ?? []).length > 0;
-  return typed || config.collections.length === 0 ? cwd : config.configDir;
-}
-function routesFrom(config, base) {
-  return config.routes.map((m) => ({
-    ...m,
-    root: relative(base, resolve(config.configDir, m.root)).replace(/\\/g, "/")
-  }));
-}
-function documentSetPatterns(config, options = {}) {
-  const paths = options.paths ?? [];
-  if (paths.length > 0) return paths;
-  return selectCollections(
-    config.collections,
-    options.collection ?? [],
-    config.configSource ?? DEFAULT_CONFIG_FILENAME,
-    (message) => new GraphError(message)
-  ).flatMap((c) => c.paths);
-}
-
 // src/graph/core/emit.ts
 var SAFE_LOCAL = /^[A-Za-z_][A-Za-z0-9_-]*$/;
 var ILLEGAL_IRI_CHARS = '<>"{}|^`\\';
@@ -1343,6 +794,7 @@ function renderTerm(term) {
   if (term.datatype === INTEGER && INTEGER_RE.test(term.value))
     return term.value;
   const quoted = `"${escapeLiteral(term.value)}"`;
+  if (term.language) return `${quoted}@${term.language}`;
   return term.datatype ? `${quoted}^^${shorten(term.datatype)}` : quoted;
 }
 function compareTerms(a, b) {
@@ -1351,7 +803,9 @@ function compareTerms(a, b) {
   if (byValue !== 0) return byValue;
   const da = a.kind === "literal" ? a.datatype ?? "" : "";
   const db = b.kind === "literal" ? b.datatype ?? "" : "";
-  return byCodeUnit(da, db);
+  const la = a.kind === "literal" ? a.language ?? "" : "";
+  const lb = b.kind === "literal" ? b.language ?? "" : "";
+  return byCodeUnit(da, db) || byCodeUnit(la, lb);
 }
 function emitTurtle(quads) {
   shortenMemo.clear();
@@ -1640,57 +1094,6 @@ async function suppressGraphOutput(docs, sets) {
   return out;
 }
 
-// src/graph/core/external.ts
-import { resolve as resolve2 } from "node:path";
-async function openMetaView(source, cwd, paths, base = cwd) {
-  try {
-    return await metaPageView({
-      cwd: base,
-      ...source.configPath === void 0 ? {} : { configPath: resolve2(cwd, source.configPath) },
-      ...source.noConfig === void 0 ? {} : { noConfig: source.noConfig },
-      pages: paths.filter((p) => p !== STDIN_PATH).map((p) => resolve2(base, p))
-    });
-  } catch (e) {
-    throw new GraphError(errorMessage(e));
-  }
-}
-function pointerOf(key) {
-  return `/${key.replace(/~/g, "~0").replace(/\//g, "~1")}`;
-}
-async function mergePage(view, path, frontmatter, present, format) {
-  let merged;
-  try {
-    merged = await view.merge(path, {
-      data: frontmatter,
-      present,
-      format,
-      lineFor: () => void 0
-    });
-  } catch (e) {
-    throw new GraphError(errorMessage(e));
-  }
-  const data = merged.extracted.data;
-  const supplied = {};
-  for (const key of Object.keys(data)) {
-    if (merged.locate(pointerOf(key)) !== void 0) supplied[key] = data[key];
-  }
-  return { data, supplied };
-}
-async function withExternalMetadata(docs, view) {
-  const out = [];
-  for (const doc of docs) {
-    const { data } = await mergePage(
-      view,
-      doc.path,
-      doc.frontmatter,
-      doc.frontmatterPresent,
-      doc.format
-    );
-    out.push(data === doc.frontmatter ? doc : { ...doc, frontmatter: data });
-  }
-  return out;
-}
-
 // src/graph/commands/build.ts
 var GIT_ABSENT_WARNING = "the graph has no revision history or commit agents";
 function gitAbsentWarning(reason) {
@@ -1717,10 +1120,17 @@ async function buildGraph(opts = {}) {
   const base = documentBase(config, opts, cwd);
   const files = resolveDocumentSet(config, opts, "build", cwd, base);
   const usingStdin = (opts.paths ?? []).includes(STDIN);
-  const outPath = resolve3(cwd, opts.out ?? config.out);
+  const outPath = resolve(cwd, opts.out ?? config.out);
   if (files.length === 0 && !usingStdin) {
     if (opts.allowEmpty) {
-      return { outPath, docs: 0, quads: 0, warnings: [], turtle: emitTurtle([]) };
+      return {
+        outPath,
+        docs: 0,
+        quads: 0,
+        concepts: { total: 0, fromTermbase: 0 },
+        warnings: [],
+        turtle: emitTurtle([])
+      };
     }
     throw new GraphError(
       `No input files matched: ${documentSetPatterns(config, opts).join(", ")} (cwd: ${cwd})`
@@ -1730,14 +1140,14 @@ async function buildGraph(opts = {}) {
     throw new GraphError("graph build was given `-` but no stdin content.");
   }
   const allPaths = new Set(usingStdin ? [...files, STDIN_PATH] : files);
-  const cache = new AnalyzeCache(resolve3(cwd, ANALYZE_CACHE_DIR));
+  const cache = new AnalyzeCache(resolve(cwd, ANALYZE_CACHE_DIR));
   const analyzeOptions = {
     routes: routesFrom(config, base),
     ...format === void 0 ? {} : { format },
     parse: cache.parse
   };
   const read = files.map(
-    (path) => analyzeDoc(readFileSync2(resolve3(base, path), "utf8"), path, allPaths, analyzeOptions)
+    (path) => analyzeDoc(readFileSync2(resolve(base, path), "utf8"), path, allPaths, analyzeOptions)
   );
   if (usingStdin && opts.stdinContent !== void 0) {
     read.push(analyzeDoc(opts.stdinContent, STDIN_PATH, allPaths, analyzeOptions));
@@ -1762,6 +1172,21 @@ async function buildGraph(opts = {}) {
       warnings.push(gitAbsentWarning(errorMessage(e)));
     }
   }
+  const source = termLabelSource();
+  let termbase = [];
+  if (config.build.derive.includes("terms") && source !== void 0) {
+    try {
+      termbase = await source({
+        cwd,
+        ...opts.config === void 0 ? {} : { configPath: opts.config },
+        ...opts.noConfig === true ? { noConfig: true } : {}
+      });
+    } catch (e) {
+      warnings.push(
+        `the graph holds no termbase concepts: the termbase could not be read \u2014 ${errorMessage(e)}`
+      );
+    }
+  }
   const quads = deriveGraph(docs, {
     baseIri: config.baseIri,
     derive: config.build.derive,
@@ -1769,45 +1194,28 @@ async function buildGraph(opts = {}) {
     // package, one version: the tool no longer has one of its own.
     toolVersion: package_default.version,
     gitHistory,
-    qualified: config.provenance.qualified
+    qualified: config.provenance.qualified,
+    termbase
   });
+  const concept = `${NS.skos}Concept`;
+  const concepts = {
+    total: quads.filter((q) => q.p === RDF_TYPE && q.o.value === concept).length,
+    fromTermbase: termConceptCount(termbase)
+  };
   const turtle = emitTurtle(quads);
   await cache.flush();
-  return { outPath, docs: docs.length, quads: quads.length, warnings, turtle };
+  return { outPath, docs: docs.length, quads: quads.length, concepts, warnings, turtle };
 }
 
 export {
-  formatOf,
-  extractorFor,
-  metadataOf,
-  analyzeDoc,
-  parseTree,
-  mintTreeSections,
-  discoverFiles,
-  DEFAULT_EXTENSIONS,
-  STDIN,
-  assertInputFormat,
-  resolveDocumentSet,
-  documentBase,
-  routesFrom,
-  documentSetPatterns,
-  LOCALIZATIONS_FILENAME,
-  UNDETERMINED,
-  isLanguageTag,
-  canonicalLanguageTag,
-  searchIndexFilename,
-  vectorIndexFilename,
-  emitLocalizations,
-  parseLocalizations,
-  isSafeRelativePath,
+  canonicalLanguage,
+  termIndex,
   deriveGraph,
   emitTurtle,
   collectGitHistory,
-  openMetaView,
-  mergePage,
   GIT_ABSENT_WARNING,
   gitAbsentWarning,
   runBuild,
   buildGraph
 };
-//# sourceMappingURL=chunk-2IAZEB45.js.map
+//# sourceMappingURL=chunk-WGMFDG6U.js.map