@hawkeyexl/manni 4.3.1 → 4.4.1

package/dist/chunk-NLXTXE5Y.js

@@ -0,0 +1,1661 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_CONFIG_FILENAME,
+  DEFAULT_INDEX_FILES,
+  DEFAULT_LINK_EXTENSIONS,
+  GRAPH_NOT_APPLICABLE_TO_VARIANT,
+  GRAPH_NOT_SOFTWARE_SUBJECT,
+  GraphError,
+  IIRDS_HAS_SUBJECT,
+  IIRDS_HAS_TOPIC_TYPE,
+  IIRDS_PRODUCT_VARIANT,
+  IIRDS_RELATES_TO_LIFECYCLE_PHASE,
+  IIRDS_RELATES_TO_PRODUCT_VARIANT,
+  NS,
+  PAGE_TYPE_TO_TOPIC_TYPE,
+  PREFIXES,
+  RDF_TYPE,
+  ROLE,
+  SOFTWARE_LIFECYCLE_IRIS,
+  SOFTWARE_SUBJECT_IRIS,
+  STDIN_PATH,
+  TOPIC_TYPE_IRIS,
+  assertCollectionWithoutPaths,
+  byCodeUnit,
+  conceptSlug,
+  encodeSegment,
+  loadRunConfig,
+  mintAgentIri,
+  mintBuildActivityIri,
+  mintConceptIri,
+  mintDocIri,
+  mintGraphIri,
+  mintProductIri,
+  mintSchemeIri,
+  mintSectionIri,
+  normalizeDocPath
+} from "./chunk-M2JCK5F6.js";
+import {
+  metaPageView
+} from "./chunk-QRWGPQKO.js";
+import {
+  STDIN_REQUIRES_AS
+} from "./chunk-TK3FC4RF.js";
+import {
+  writeTextAtomic
+} from "./chunk-M3W7J6MU.js";
+import {
+  extractFrontmatter
+} from "./chunk-57NEQRVO.js";
+import {
+  selectCollections
+} from "./chunk-Q35YIDBV.js";
+import {
+  package_default
+} from "./chunk-UJCVAWP7.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 { 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 = ["markdown", "mdx"];
+function formatOf(path, format) {
+  return format ?? (path.endsWith(".mdx") ? "mdx" : "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 analyzeDoc(content, relPath, allPaths, options = {}) {
+  const routes = options.routes ?? [];
+  const path = normalizeDocPath(relPath);
+  let meta;
+  try {
+    meta = extractFrontmatter(content, "markdown");
+  } catch (error) {
+    throw new GraphError(`${path}: ${errorMessage(error)}`);
+  }
+  const format = formatOf(path, options.format);
+  const body = (options.parse ?? parseBody)(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) {
+  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 visit(node, fn) {
+  const children = node.children;
+  if (!children) return;
+  for (const child of children) {
+    fn(child);
+    visit(child, fn);
+  }
+}
+
+// src/graph/core/analyze-cache.ts
+import { createHash as createHash2 } 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");
+}
+var isStrings = (value) => Array.isArray(value) && value.every((v) => typeof v === "string");
+function isSection(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const s = value;
+  return typeof s.slug === "string" && typeof s.title === "string" && typeof s.level === "number" && typeof s.order === "number" && (s.parentSlug === null || typeof s.parentSlug === "string");
+}
+function isDocBody(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const b = value;
+  return (b.firstH1 === void 0 || typeof b.firstH1 === "string") && Array.isArray(b.sections) && b.sections.every(isSection) && isStrings(b.linkTargets) && isStrings(b.imageTargets) && isStrings(b.codeLanguages);
+}
+var AnalyzeCache = class {
+  constructor(dir, version = package_default.version) {
+    this.dir = dir;
+    this.version = version;
+  }
+  dir;
+  version;
+  /** Pages this run served from the cache. */
+  hits = 0;
+  /** Pages this run parsed. */
+  misses = 0;
+  writes = [];
+  /** `parseBody`, served from the entry for `path` when its key matches. */
+  parse = (content, path, format) => {
+    const key = sha256(JSON.stringify([ENTRY_VERSION, this.version, format, path, content]));
+    const file = join(this.dir, `${sha256(path)}.json`);
+    const cached = readEntry(file, key);
+    if (cached !== void 0) {
+      this.hits++;
+      return cached;
+    }
+    const body = parseBody(content, path, format);
+    this.misses++;
+    this.writes.push(this.write(file, JSON.stringify({ key, body })));
+    return body;
+  };
+  /** Wait for this run's writes. Never rejects. */
+  async flush() {
+    await Promise.all(this.writes);
+  }
+  async write(file, text) {
+    try {
+      await mkdir(this.dir, { recursive: true });
+      await writeTextAtomic(file, text);
+    } catch {
+    }
+  }
+};
+function readEntry(file, key) {
+  try {
+    const entry = JSON.parse(readFileSync(file, "utf8"));
+    if (typeof entry !== "object" || entry === null) return void 0;
+    const { key: stored, body } = entry;
+    return stored === key && isDocBody(body) ? body : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/graph/core/localizations.ts
+var LOCALIZATIONS_FILENAME = "localizations.json";
+var UNDETERMINED = "und";
+var LANGUAGE_TAG = /^[A-Za-z]{2,3}(-[A-Za-z]{4})?(-([A-Za-z]{2}|[0-9]{3}))?(-([A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*$/;
+function isLanguageTag(value) {
+  return LANGUAGE_TAG.test(value);
+}
+function canonicalLanguageTag(tag) {
+  try {
+    return Intl.getCanonicalLocales(tag)[0] ?? tag;
+  } catch {
+    return tag;
+  }
+}
+function searchIndexFilename(language) {
+  return `search.${language}.json`;
+}
+function vectorIndexFilename(language) {
+  return `vectors.${language}.bin`;
+}
+function emitLocalizations(doc) {
+  const languages = [...doc.languages].sort(
+    (a, b) => byCodeUnit(a.language, b.language)
+  );
+  return `${JSON.stringify({ version: doc.version, languages }, null, 2)}
+`;
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function parseLocalizations(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed)) return void 0;
+  if (parsed["version"] !== 1 || !Array.isArray(parsed["languages"])) {
+    return void 0;
+  }
+  for (const entry of parsed["languages"]) {
+    if (!isRecord(entry)) return void 0;
+    const language = entry["language"];
+    const search = entry["search"];
+    if (typeof language !== "string" || !isLanguageTag(language) || typeof entry["documents"] !== "number" || !isRecord(search) || typeof search["path"] !== "string" || typeof search["entries"] !== "number" || typeof search["digest"] !== "string" || !ownsFilename(search["path"], searchIndexFilename(language))) {
+      return void 0;
+    }
+    const v = entry["vectors"];
+    if (v !== void 0) {
+      if (!isRecord(v) || typeof v["path"] !== "string" || typeof v["model"] !== "string" || typeof v["dtype"] !== "string" || typeof v["dims"] !== "number" || typeof v["count"] !== "number" || // Same constraint `search.path` gets: the last segment must be the
+      // filename this language's sidecar would be given. Without it,
+      // `isSafeRelativePath` alone leaves `vectors.path` far more reachable
+      // than `search.path` — and `search --mode vector` opens it.
+      !ownsFilename(v["path"], vectorIndexFilename(language))) {
+        return void 0;
+      }
+    }
+  }
+  return parsed;
+}
+function isSafeRelativePath(path) {
+  if (path === "" || path.startsWith("/") || /^[A-Za-z]:/.test(path)) {
+    return false;
+  }
+  if (path.includes("\\")) return false;
+  const segments = path.split("/");
+  let leading = true;
+  for (const segment of segments) {
+    if (segment === "" || segment === ".") return false;
+    if (segment === "..") {
+      if (!leading) return false;
+      continue;
+    }
+    leading = false;
+  }
+  return true;
+}
+function ownsFilename(path, expected) {
+  if (!isSafeRelativePath(path)) return false;
+  return path.slice(path.lastIndexOf("/") + 1) === expected;
+}
+
+// src/graph/core/derive.ts
+function resolveProvDocPath(docPath, raw, docByPath) {
+  const docRelative = resolveRelative(docPath, raw);
+  if (docRelative !== null && docByPath.has(docRelative)) return docRelative;
+  const repoRelative = normalizeDocPath(raw);
+  return docByPath.has(repoRelative) ? repoRelative : null;
+}
+var iri = (value) => ({ kind: "iri", value });
+var lit = (value) => ({ kind: "literal", value });
+var typedLit = (value, datatype) => ({
+  kind: "literal",
+  value,
+  datatype
+});
+var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var DATETIME_RE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/;
+function dateTerm(value) {
+  if (DATE_RE.test(value)) return typedLit(value, `${NS.xsd}date`);
+  if (DATETIME_RE.test(value)) return typedLit(value, `${NS.xsd}dateTime`);
+  return lit(value);
+}
+function asString(v) {
+  if (typeof v === "string" && v.length > 0) return v;
+  if (typeof v === "number") return String(v);
+  if (v instanceof Date) {
+    return Number.isNaN(v.getTime()) ? void 0 : v.toISOString();
+  }
+  return void 0;
+}
+function asStringArray(v) {
+  if (typeof v === "string") return v.length > 0 ? [v] : [];
+  if (Array.isArray(v)) {
+    return v.flatMap((item) => {
+      const s = asString(item);
+      return s === void 0 ? [] : [s];
+    });
+  }
+  return [];
+}
+function asPersonNames(v) {
+  const one = (item) => {
+    const name = item != null && typeof item === "object" && !Array.isArray(item) ? asString(asRecord(item).name) : asString(item);
+    return name === void 0 ? [] : [name];
+  };
+  return Array.isArray(v) ? v.flatMap(one) : one(v);
+}
+function asRecord(v) {
+  return v != null && typeof v === "object" && !Array.isArray(v) ? v : {};
+}
+function fmValue(fm, keys) {
+  for (const key of keys) {
+    if (fm[key] !== void 0 && fm[key] !== null) return fm[key];
+  }
+  return void 0;
+}
+var AGENT_KIND = {
+  Person: "person",
+  Organization: "org",
+  SoftwareAgent: "software"
+};
+function graphBlock(fm) {
+  const block = fm["graph"];
+  return block && typeof block === "object" && !Array.isArray(block) ? block : void 0;
+}
+function resolveGraph(block, fm) {
+  const k = { ...block ?? {} };
+  const fallback = (key, pageKeys) => {
+    if (k[key] !== void 0 && k[key] !== null) return;
+    const pageValue = fmValue(fm, pageKeys);
+    if (pageValue !== void 0) k[key] = pageValue;
+  };
+  fallback("concepts", ["concepts"]);
+  fallback("applies-to", ["applies-to"]);
+  fallback("not-applicable-to", ["not-applicable-to"]);
+  fallback("revision-of", ["supersedes"]);
+  if (k["type"] === void 0 || k["type"] === null) {
+    const pageType = asString(fmValue(fm, ["type"]));
+    const derived = pageType && Object.hasOwn(PAGE_TYPE_TO_TOPIC_TYPE, pageType) ? PAGE_TYPE_TO_TOPIC_TYPE[pageType] : void 0;
+    if (derived) k["type"] = derived;
+  }
+  return k;
+}
+function recordEntries(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (e) => !!e && typeof e === "object" && !Array.isArray(e)
+  );
+}
+function pointerSegments(pointer) {
+  return pointer.split("/").slice(1).map((s) => s.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function deriveGraph(docs, options) {
+  const { baseIri } = options;
+  const sources = new Set(options.derive);
+  const quads = [];
+  const add = (s, p, o) => quads.push({ s, p, o });
+  const mintedConcepts = /* @__PURE__ */ new Set();
+  const concept = (label) => {
+    const c = mintConceptIri(baseIri, label);
+    add(c, RDF_TYPE, iri(`${NS.skos}Concept`));
+    add(c, `${NS.skos}prefLabel`, lit(label));
+    add(c, `${NS.skos}inScheme`, iri(mintSchemeIri(baseIri)));
+    mintedConcepts.add(c);
+    return c;
+  };
+  const variantNode = (label) => {
+    const variant = mintProductIri(baseIri, label);
+    add(variant, RDF_TYPE, iri(IIRDS_PRODUCT_VARIANT));
+    add(variant, `${NS.dcterms}title`, lit(label));
+    return variant;
+  };
+  const emitIirdsTyping = (subjectIri, k) => {
+    const topicType = asString(k["type"]);
+    const topicTypeIri = topicType && TOPIC_TYPE_IRIS[topicType];
+    if (topicTypeIri) add(subjectIri, IIRDS_HAS_TOPIC_TYPE, iri(topicTypeIri));
+    for (const label of asStringArray(k["applies-to"])) {
+      add(
+        subjectIri,
+        IIRDS_RELATES_TO_PRODUCT_VARIANT,
+        iri(variantNode(label))
+      );
+    }
+    for (const label of asStringArray(k["not-applicable-to"])) {
+      add(subjectIri, GRAPH_NOT_APPLICABLE_TO_VARIANT, iri(variantNode(label)));
+    }
+    for (const value of asStringArray(k["about-product-lifecycle"])) {
+      const phase = SOFTWARE_LIFECYCLE_IRIS[value];
+      if (phase) add(subjectIri, IIRDS_RELATES_TO_LIFECYCLE_PHASE, iri(phase));
+    }
+    for (const value of asStringArray(k["about-product-aspect"])) {
+      const subject = SOFTWARE_SUBJECT_IRIS[value];
+      if (subject) add(subjectIri, IIRDS_HAS_SUBJECT, iri(subject));
+    }
+    for (const value of asStringArray(k["not-about-product-aspect"])) {
+      const subject = SOFTWARE_SUBJECT_IRIS[value];
+      if (subject) add(subjectIri, GRAPH_NOT_SOFTWARE_SUBJECT, iri(subject));
+    }
+  };
+  const docByPath = new Map(docs.map((d) => [normalizeDocPath(d.path), d]));
+  const prov = sources.has("provenance");
+  const agentNode = (name, type) => {
+    const a = mintAgentIri(baseIri, AGENT_KIND[type], name);
+    add(a, RDF_TYPE, iri(`${NS.prov}${type}`));
+    add(a, `${NS.foaf}name`, lit(name));
+    return a;
+  };
+  const qualified = options.qualified === true;
+  const qualifyAttribution = (docIri, agentIri, name) => {
+    if (!qualified) return;
+    const node = `${docIri}#prov.attribution.${conceptSlug(name)}`;
+    add(docIri, `${NS.prov}qualifiedAttribution`, iri(node));
+    add(node, RDF_TYPE, iri(`${NS.prov}Attribution`));
+    add(node, `${NS.prov}agent`, iri(agentIri));
+    add(node, `${NS.prov}hadRole`, iri(ROLE.author));
+  };
+  const qualifyAssociation = (activityIri, agentIri, role) => {
+    if (!qualified) return;
+    const agentSlug = agentIri.slice(agentIri.lastIndexOf("/") + 1);
+    const node = `${activityIri}.assoc.${agentSlug}`;
+    add(activityIri, `${NS.prov}qualifiedAssociation`, iri(node));
+    add(node, RDF_TYPE, iri(`${NS.prov}Association`));
+    add(node, `${NS.prov}agent`, iri(agentIri));
+    add(node, `${NS.prov}hadRole`, iri(role));
+  };
+  const attributeAuthor = (docIri, name) => {
+    const a = agentNode(name, "Person");
+    add(docIri, `${NS.dcterms}creator`, iri(a));
+    add(docIri, `${NS.prov}wasAttributedTo`, iri(a));
+    qualifyAttribution(docIri, a, name);
+  };
+  const provTargetEdge = (doc, docIri, raw, predicate, inverse) => {
+    if (hasScheme(raw)) {
+      add(docIri, predicate, iri(raw));
+      return;
+    }
+    const target = resolveProvDocPath(
+      normalizeDocPath(doc.path),
+      raw,
+      docByPath
+    );
+    if (target) {
+      const targetIri = mintDocIri(baseIri, target);
+      add(docIri, predicate, iri(targetIri));
+      if (inverse) add(targetIri, inverse, iri(docIri));
+    } else {
+      add(docIri, `${NS.graph}brokenLink`, lit(raw));
+    }
+  };
+  for (const doc of docs) {
+    const docIri = mintDocIri(baseIri, doc.path);
+    const fm = doc.frontmatter;
+    const block = graphBlock(fm);
+    const harvested = resolveGraph(block, fm);
+    let createdEmitted = false;
+    let modifiedEmitted = false;
+    add(docIri, RDF_TYPE, iri(`${NS.graph}Document`));
+    if (prov) add(docIri, RDF_TYPE, iri(`${NS.prov}Entity`));
+    add(docIri, `${NS.graph}path`, lit(normalizeDocPath(doc.path)));
+    add(docIri, `${NS.graph}contentHash`, lit(doc.contentHash));
+    if (sources.has("frontmatter")) {
+      const title = asString(fmValue(fm, ["title"])) ?? doc.firstH1;
+      if (title) add(docIri, `${NS.dcterms}title`, lit(title));
+      const description = asString(fmValue(fm, ["description"]));
+      if (description)
+        add(docIri, `${NS.dcterms}description`, lit(description));
+      for (const author of asPersonNames(fmValue(fm, ["author", "authors"]))) {
+        if (prov) {
+          attributeAuthor(docIri, author);
+        } else {
+          add(docIri, `${NS.dcterms}creator`, lit(author));
+        }
+      }
+      const created = asString(fmValue(fm, ["created", "date"]));
+      if (created) {
+        add(docIri, `${NS.dcterms}created`, dateTerm(created));
+        if (prov) add(docIri, `${NS.prov}generatedAtTime`, dateTerm(created));
+        createdEmitted = true;
+      }
+      const modified = asString(
+        fmValue(fm, ["last-updated", "updated", "lastmod", "modified"])
+      );
+      if (modified) {
+        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)));
+      }
+      for (const raw of asStringArray(fmValue(fm, ["translation-of"]))) {
+        provTargetEdge(
+          doc,
+          docIri,
+          raw,
+          `${NS.schema}translationOfWork`,
+          `${NS.schema}workTranslation`
+        );
+      }
+      if (block) {
+        const label = asString(block["label"]);
+        if (label) {
+          const topic = concept(label);
+          add(docIri, `${NS.foaf}primaryTopic`, iri(topic));
+          for (const alt of asStringArray(block["alt-labels"])) {
+            add(topic, `${NS.skos}altLabel`, lit(alt));
+          }
+          for (const [key, predicate] of [
+            ["broader", "broader"],
+            ["narrower", "narrower"],
+            ["related-concepts", "related"]
+          ]) {
+            for (const value of asStringArray(block[key])) {
+              add(topic, `${NS.skos}${predicate}`, iri(concept(value)));
+            }
+          }
+        }
+      }
+      emitIirdsTyping(docIri, harvested);
+    }
+    if (sources.has("tags")) {
+      const labels = [
+        ...asStringArray(fmValue(fm, ["tags", "keywords"])),
+        ...asStringArray(harvested["concepts"])
+      ];
+      for (const label of labels) {
+        add(docIri, `${NS.dcterms}subject`, iri(concept(label)));
+      }
+    }
+    if (sources.has("sections")) {
+      const sectionMeta = asRecord(block?.["sections"]);
+      const sectionSlugs = new Set(doc.sections.map((s) => s.slug));
+      for (const section of doc.sections) {
+        const secIri = mintSectionIri(docIri, section.slug);
+        const parentIri = section.parentSlug ? mintSectionIri(docIri, section.parentSlug) : docIri;
+        add(secIri, RDF_TYPE, iri(`${NS.graph}Section`));
+        add(secIri, `${NS.dcterms}title`, lit(section.title));
+        add(
+          secIri,
+          `${NS.graph}level`,
+          typedLit(String(section.level), `${NS.xsd}integer`)
+        );
+        add(
+          secIri,
+          `${NS.graph}order`,
+          typedLit(String(section.order), `${NS.xsd}integer`)
+        );
+        add(parentIri, `${NS.dcterms}hasPart`, iri(secIri));
+        const meta = asRecord(sectionMeta[section.slug]);
+        emitIirdsTyping(secIri, meta);
+        for (const label of asStringArray(meta["concepts"])) {
+          add(secIri, `${NS.dcterms}subject`, iri(concept(label)));
+        }
+      }
+      for (const slug of Object.keys(sectionMeta)) {
+        if (!sectionSlugs.has(slug)) {
+          add(docIri, `${NS.graph}brokenSectionRef`, lit(slug));
+        }
+      }
+    }
+    if (sources.has("links")) {
+      for (const link of doc.links) {
+        if (link.kind === "external" && link.url) {
+          add(docIri, `${NS.dcterms}references`, iri(link.url));
+        } else if (link.kind === "internal" && link.resolvedPath) {
+          const targetIri = mintDocIri(baseIri, link.resolvedPath);
+          const target = docByPath.get(link.resolvedPath);
+          const anchor = link.anchor;
+          const anchorResolves = anchor !== void 0 && target !== void 0 && target.sections.some((s) => s.slug === anchor);
+          add(
+            docIri,
+            `${NS.dcterms}references`,
+            iri(
+              anchorResolves ? mintSectionIri(targetIri, anchor) : targetIri
+            )
+          );
+        } else if (link.kind === "broken") {
+          add(docIri, `${NS.graph}brokenLink`, lit(link.raw));
+        }
+      }
+    }
+    if (sources.has("images")) {
+      for (const image of doc.images) {
+        const target = image.external ? image.target : `${baseIri}file/${normalizeDocPath(image.target).split("/").map(encodeSegment).join("/")}`;
+        add(docIri, `${NS.schema}image`, iri(target));
+      }
+    }
+    if (sources.has("code")) {
+      for (const language of doc.codeLanguages) {
+        add(docIri, `${NS.graph}codeLanguage`, lit(language));
+      }
+    }
+    if (prov) {
+      for (const raw of block ? asStringArray(block["derived-from"]) : []) {
+        provTargetEdge(doc, docIri, raw, `${NS.prov}wasDerivedFrom`);
+      }
+      for (const raw of asStringArray(harvested["revision-of"])) {
+        provTargetEdge(doc, docIri, raw, `${NS.prov}wasRevisionOf`);
+      }
+      const gitFile = options.gitHistory?.files.get(normalizeDocPath(doc.path));
+      if (gitFile) {
+        if (!createdEmitted && gitFile.created) {
+          add(docIri, `${NS.dcterms}created`, dateTerm(gitFile.created));
+          add(docIri, `${NS.prov}generatedAtTime`, dateTerm(gitFile.created));
+        }
+        if (!modifiedEmitted && gitFile.modified) {
+          add(docIri, `${NS.dcterms}modified`, dateTerm(gitFile.modified));
+        }
+        for (const author of gitFile.authors) {
+          attributeAuthor(docIri, author);
+        }
+        for (const oldPath of gitFile.renamedFrom) {
+          const oldIri = mintDocIri(baseIri, oldPath);
+          add(docIri, `${NS.prov}wasRevisionOf`, iri(oldIri));
+          add(oldIri, RDF_TYPE, iri(`${NS.prov}Entity`));
+        }
+      }
+      const machines = [
+        ...new Set(
+          recordEntries(fmValue(fm, ["provenance"])).flatMap((e) => {
+            const m = asString(e["generated-by"]);
+            return m === void 0 ? [] : [m];
+          })
+        )
+      ].sort(byCodeUnit);
+      if (machines.length > 0) {
+        const activity = `${docIri}#prov.generation`;
+        add(docIri, `${NS.prov}wasGeneratedBy`, iri(activity));
+        add(activity, RDF_TYPE, iri(`${NS.prov}Activity`));
+        for (const machine of machines) {
+          const model = agentNode(machine, "SoftwareAgent");
+          add(activity, `${NS.prov}wasAssociatedWith`, iri(model));
+          qualifyAssociation(activity, model, ROLE.generator);
+        }
+      }
+      for (const entry of recordEntries(fmValue(fm, ["meta-provenance"]))) {
+        const model = asString(entry["generated-by"]);
+        if (!model) continue;
+        const pointers = asStringArray(entry["fields"]);
+        const confidence = asRecord(entry["confidence"]);
+        const filled = /* @__PURE__ */ new Map();
+        for (const pointer of pointers) {
+          if (!pointer.startsWith("/graph/")) continue;
+          const field = pointerSegments(pointer)[1];
+          if (field === void 0 || field === "") continue;
+          if (!filled.has(field)) filled.set(field, pointer);
+        }
+        if (filled.size === 0) continue;
+        const activity = `${docIri}#prov.graph-fill.${conceptSlug(model)}`;
+        const modelAgent = agentNode(model, "SoftwareAgent");
+        add(activity, RDF_TYPE, iri(`${NS.prov}Activity`));
+        add(activity, `${NS.prov}wasAssociatedWith`, iri(modelAgent));
+        qualifyAssociation(activity, modelAgent, ROLE.generator);
+        for (const [field, pointer] of filled) {
+          const fieldNode = `${activity}.field.${field}`;
+          add(activity, `${NS.graph}filledFieldEntry`, iri(fieldNode));
+          add(fieldNode, `${NS.graph}filledField`, lit(field));
+          const c = confidence[pointer];
+          if (typeof c === "number") {
+            add(
+              fieldNode,
+              `${NS.graph}confidence`,
+              typedLit(String(Math.round(c * 100) / 100), `${NS.xsd}decimal`)
+            );
+          }
+        }
+        const label = block ? asString(block["label"]) : void 0;
+        if (label && filled.has("label")) {
+          add(
+            activity,
+            `${NS.prov}generated`,
+            iri(mintConceptIri(baseIri, label))
+          );
+        }
+      }
+    }
+  }
+  if (prov) {
+    const graphIri = mintGraphIri(baseIri);
+    const activity = mintBuildActivityIri(baseIri);
+    const tool = agentNode("manni", "SoftwareAgent");
+    add(graphIri, RDF_TYPE, iri(`${NS.prov}Entity`));
+    add(graphIri, `${NS.prov}wasGeneratedBy`, iri(activity));
+    add(activity, RDF_TYPE, iri(`${NS.prov}Activity`));
+    add(activity, `${NS.prov}wasAssociatedWith`, iri(tool));
+    qualifyAssociation(activity, tool, ROLE.tool);
+    if (options.toolVersion) {
+      add(tool, `${NS.graph}version`, lit(options.toolVersion));
+    }
+    for (const doc of docs) {
+      add(activity, `${NS.prov}used`, iri(mintDocIri(baseIri, doc.path)));
+    }
+    const headTime = options.gitHistory?.headTime;
+    if (headTime) {
+      add(
+        activity,
+        `${NS.prov}endedAtTime`,
+        typedLit(headTime, `${NS.xsd}dateTime`)
+      );
+    }
+  }
+  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"));
+  }
+  return dedupe(quads);
+}
+function quadKey(q) {
+  const o = q.o.kind === "iri" ? `i:${q.o.value}` : `l:${q.o.value}|${q.o.datatype ?? ""}`;
+  return `${q.s}|${q.p}|${o}`;
+}
+function dedupe(quads) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const q of quads) {
+    const key = quadKey(q);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(q);
+  }
+  return out;
+}
+
+// src/graph/core/discover.ts
+import { statSync } from "node:fs";
+import { extname, 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 SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".markdown", ".mdx"]);
+var DEFAULT_EXTENSIONS = [".md", ".mdx", ".markdown"];
+var STDIN = "-";
+function assertInputFormat(paths, as) {
+  if (as !== void 0 && !DOC_FORMATS.includes(as)) {
+    throw new GraphError(
+      `Unknown format "${as}". Known formats: ${DOC_FORMATS.join(", ")}.`
+    );
+  }
+  if (paths.includes(STDIN) && as === void 0) {
+    throw new GraphError(STDIN_REQUIRES_AS);
+  }
+  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) => format !== void 0 || SUPPORTED_EXTENSIONS.has(extname(p).toLowerCase());
+  const keepWalked = (p) => exts.has(extname(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 = '<>"{}|^`\\';
+function sanitizeIri(iriValue) {
+  let out = "";
+  for (const ch of iriValue) {
+    const code = ch.codePointAt(0);
+    const illegal = code <= 32 || ILLEGAL_IRI_CHARS.includes(ch);
+    out += illegal ? "%" + code.toString(16).toUpperCase().padStart(2, "0") : ch;
+  }
+  return out;
+}
+var shortenMemo = /* @__PURE__ */ new Map();
+function shorten(iriValue) {
+  const memoized = shortenMemo.get(iriValue);
+  if (memoized !== void 0) return memoized;
+  let result;
+  for (const [prefix, ns] of PREFIXES) {
+    if (iriValue.startsWith(ns)) {
+      const local = iriValue.slice(ns.length);
+      if (SAFE_LOCAL.test(local)) {
+        result = `${prefix}:${local}`;
+        break;
+      }
+    }
+  }
+  result ??= `<${sanitizeIri(iriValue)}>`;
+  shortenMemo.set(iriValue, result);
+  return result;
+}
+function escapeLiteral(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+var INTEGER = `${NS.xsd}integer`;
+var INTEGER_RE = /^-?\d+$/;
+function renderTerm(term) {
+  if (term.kind === "iri") return shorten(term.value);
+  if (term.datatype === INTEGER && INTEGER_RE.test(term.value))
+    return term.value;
+  const quoted = `"${escapeLiteral(term.value)}"`;
+  return term.datatype ? `${quoted}^^${shorten(term.datatype)}` : quoted;
+}
+function compareTerms(a, b) {
+  if (a.kind !== b.kind) return a.kind === "iri" ? -1 : 1;
+  const byValue = byCodeUnit(a.value, b.value);
+  if (byValue !== 0) return byValue;
+  const da = a.kind === "literal" ? a.datatype ?? "" : "";
+  const db = b.kind === "literal" ? b.datatype ?? "" : "";
+  return byCodeUnit(da, db);
+}
+function emitTurtle(quads) {
+  shortenMemo.clear();
+  const lines = [];
+  for (const [prefix, ns] of PREFIXES) {
+    lines.push(`@prefix ${prefix}: <${ns}> .`);
+  }
+  const subjects = /* @__PURE__ */ new Map();
+  for (const quad of quads) {
+    let preds = subjects.get(quad.s);
+    if (!preds) {
+      preds = /* @__PURE__ */ new Map();
+      subjects.set(quad.s, preds);
+    }
+    let terms = preds.get(quad.p);
+    if (!terms) {
+      terms = [];
+      preds.set(quad.p, terms);
+    }
+    terms.push(quad.o);
+  }
+  const sortedSubjects = [...subjects.entries()].sort(
+    ([a], [b]) => byCodeUnit(a, b)
+  );
+  for (const [subject, preds] of sortedSubjects) {
+    const sortedPreds = [...preds.entries()].sort(([a], [b]) => {
+      if (a === RDF_TYPE) return b === RDF_TYPE ? 0 : -1;
+      if (b === RDF_TYPE) return 1;
+      return byCodeUnit(a, b);
+    });
+    const entries = sortedPreds.map(([p, terms], i) => {
+      const objects = [...terms].sort(compareTerms).map(renderTerm).join(", ");
+      const pred = p === RDF_TYPE ? "a" : shorten(p);
+      const terminator = i === sortedPreds.length - 1 ? " ." : " ;";
+      return { pred, objects, terminator };
+    });
+    const [first, ...rest] = entries;
+    if (first === void 0) continue;
+    lines.push("");
+    lines.push(
+      `${shorten(subject)} ${first.pred} ${first.objects}${first.terminator}`
+    );
+    for (const entry of rest) {
+      lines.push(`  ${entry.pred} ${entry.objects}${entry.terminator}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/graph/core/harvest.ts
+var HARVESTED_KEYS = [
+  "applies-to",
+  "concepts",
+  "lang",
+  "language",
+  "not-applicable-to",
+  "supersedes",
+  "translation-of",
+  "type"
+];
+function distance(a, b, max) {
+  if (a === b) return 0;
+  if (Math.abs(a.length - b.length) > max) return max + 1;
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const row = [i];
+    for (let j = 1; j <= b.length; j++) {
+      row[j] = Math.min(
+        (prev[j] ?? 0) + 1,
+        (row[j - 1] ?? 0) + 1,
+        (prev[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+    }
+    prev = row;
+  }
+  return prev[b.length] ?? max + 1;
+}
+function nearestKnown(candidate, known) {
+  const normalize = (s) => s.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/[_\s]+/g, "-");
+  const c = normalize(candidate);
+  for (const k of known) {
+    if (c === normalize(k) && candidate !== k) return k;
+  }
+  let best;
+  for (const k of known) {
+    const max = k.length > 8 ? 2 : 1;
+    const d = distance(c, normalize(k), max);
+    if (d > max) continue;
+    if (!best || d < best.d) best = { key: k, d };
+  }
+  return best?.key;
+}
+function harvestWarnings(docs) {
+  const out = [];
+  const mappedTypes = Object.keys(PAGE_TYPE_TO_TOPIC_TYPE);
+  for (const doc of docs) {
+    const fm = doc.frontmatter;
+    const present = new Set(Object.keys(fm));
+    for (const key of present) {
+      if (HARVESTED_KEYS.includes(key)) continue;
+      const meant = nearestKnown(key, HARVESTED_KEYS);
+      if (meant === void 0 || present.has(meant)) continue;
+      out.push(
+        `${doc.path}: page key "${key}" is not read by manni graph and looks like "${meant}" \u2014 nothing was derived from it`
+      );
+    }
+    const type = fm["type"];
+    if (typeof type === "string" && !Object.hasOwn(PAGE_TYPE_TO_TOPIC_TYPE, type)) {
+      const meant = nearestKnown(type, mappedTypes);
+      if (meant !== void 0) {
+        out.push(
+          `${doc.path}: page type "${type}" maps to no iiRDS topic type and looks like "${meant}" \u2014 no graph.type was derived`
+        );
+      }
+    }
+  }
+  return out.sort(byCodeUnit);
+}
+
+// src/graph/core/git.ts
+import { realExec } from "@hawkeyexl/inference";
+import { posix } from "node:path";
+function canonicalGitTime(time) {
+  return time.replace(/[+-]00:00$/, "Z");
+}
+var RECORD = "
";
+var STATUS_LINE = /^([AMDRC])\d*\t(.+)$/;
+function unquoteGitPath(path) {
+  if (path.length < 2 || !path.startsWith('"') || !path.endsWith('"')) {
+    return path;
+  }
+  const inner = path.slice(1, -1);
+  const bytes = [];
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i] ?? "";
+    if (ch !== "\\") {
+      for (const byte of Buffer.from(ch, "utf8")) bytes.push(byte);
+      continue;
+    }
+    const next = inner[++i];
+    if (next === void 0) break;
+    if (next >= "0" && next <= "7") {
+      let octal = next;
+      while (octal.length < 3) {
+        const digit = inner[i + 1];
+        if (digit === void 0 || digit < "0" || digit > "7") break;
+        octal += digit;
+        i++;
+      }
+      bytes.push(Number.parseInt(octal, 8));
+    } else {
+      const map = { n: "\n", t: "	", r: "\r" };
+      for (const byte of Buffer.from(map[next] ?? next, "utf8"))
+        bytes.push(byte);
+    }
+  }
+  return Buffer.from(bytes).toString("utf8");
+}
+function clearedGitEnv() {
+  const cleared = {};
+  for (const key of Object.keys(process.env)) {
+    if (key.startsWith("GIT_")) cleared[key] = void 0;
+  }
+  return cleared;
+}
+async function collectGitHistory(cwd, exec = realExec) {
+  const git = async (args) => {
+    const result = await exec(["git", ...args], {
+      cwd,
+      timeoutMs: 6e4,
+      env: clearedGitEnv()
+    });
+    if (result.spawnError) {
+      throw new GraphError(
+        `git could not be run: ${result.spawnError} (is git installed and on PATH?)`
+      );
+    }
+    if (result.timedOut) {
+      throw new GraphError(
+        "`git log` timed out after 60s \u2014 the repo history may be too large for whole-history provenance"
+      );
+    }
+    if (result.code !== 0) {
+      const detail = result.stderr.trim().slice(-300);
+      throw new GraphError(
+        `git history could not be read (is ${cwd} a git repo with at least one commit?)${detail ? ` \u2014 git said: ${detail}` : ""}`
+      );
+    }
+    return result.stdout;
+  };
+  const prefix = `/${(await git(["rev-parse", "--show-prefix"])).trim()}`;
+  const label = (raw) => posix.relative(prefix, `/${normalizeDocPath(unquoteGitPath(raw))}`);
+  const stdout = await git([
+    "-c",
+    "core.quotepath=off",
+    "log",
+    `--format=${RECORD}%H%x09%an%x09%cI`,
+    "--name-status",
+    "-M"
+  ]);
+  if (stdout.trim() === "") {
+    throw new GraphError(
+      `git history could not be read (is ${cwd} a git repo with at least one commit?)`
+    );
+  }
+  const files = /* @__PURE__ */ new Map();
+  const currentName = /* @__PURE__ */ new Map();
+  let headTime;
+  let commitAuthor = "";
+  let commitTime = "";
+  const entry = (path) => {
+    let file = files.get(path);
+    if (!file) {
+      file = { authors: [], renamedFrom: [] };
+      files.set(path, file);
+    }
+    return file;
+  };
+  const touch = (pathThen) => {
+    const path = label(pathThen);
+    const current = currentName.get(path) ?? path;
+    const file = entry(current);
+    file.modified ??= commitTime;
+    file.created = commitTime;
+    if (!file.authors.includes(commitAuthor)) file.authors.push(commitAuthor);
+    return file;
+  };
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith(RECORD)) {
+      const [, author = "", rawTime = ""] = line.slice(1).split("	");
+      const time = canonicalGitTime(rawTime);
+      commitAuthor = author;
+      commitTime = time;
+      headTime ??= time;
+      continue;
+    }
+    const match = STATUS_LINE.exec(line);
+    const status = match?.[1];
+    const rest = match?.[2];
+    if (status === void 0 || rest === void 0) continue;
+    if (status === "R" || status === "C") {
+      const [oldPath, newPath] = rest.split("	");
+      if (!oldPath || !newPath) continue;
+      if (status === "C") {
+        touch(newPath);
+        continue;
+      }
+      const file = touch(newPath);
+      const normalizedOld = label(oldPath);
+      file.renamedFrom.push(normalizedOld);
+      const normalizedNew = label(newPath);
+      currentName.set(
+        normalizedOld,
+        currentName.get(normalizedNew) ?? normalizedNew
+      );
+    } else {
+      touch(rest);
+    }
+  }
+  return { headTime, files };
+}
+
+// src/graph/core/graph-output.ts
+async function suppressGraphOutput(docs, sets) {
+  const out = [];
+  for (const doc of docs) {
+    let preferences;
+    try {
+      const refs = sets.refsFor(doc.path, doc.frontmatter);
+      preferences = await sets.validator.graphOutputPreferences(doc.frontmatter, refs);
+    } catch (e) {
+      throw new GraphError(
+        `${doc.path}: cannot read which fields the graph may carry: ${errorMessage(e)}`
+      );
+    }
+    const suppressed = [...preferences].filter(([, allowed]) => !allowed).map(([key]) => key);
+    if (suppressed.length === 0) {
+      out.push(doc);
+      continue;
+    }
+    const frontmatter = { ...doc.frontmatter };
+    for (const key of suppressed) Reflect.deleteProperty(frontmatter, key);
+    out.push({ ...doc, frontmatter });
+  }
+  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;
+}
+function ownMetadata(content) {
+  const meta = extractFrontmatter(content, "markdown");
+  return { data: meta.data, present: meta.present };
+}
+
+// src/graph/commands/build.ts
+var GIT_ABSENT_WARNING = "the graph has no revision history or commit agents";
+function gitAbsentWarning(reason) {
+  return `${GIT_ABSENT_WARNING}: ${reason}`;
+}
+async function runBuild(opts = {}) {
+  const { turtle, ...result } = await buildGraph(opts);
+  mkdirSync(dirname(result.outPath), { recursive: true });
+  writeFileSync(result.outPath, turtle, "utf8");
+  return result;
+}
+async function buildGraph(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const config = loadRunConfig(
+    {
+      ...opts.config === void 0 ? {} : { configPath: opts.config },
+      ...opts.noConfig === void 0 ? {} : { noConfig: opts.noConfig },
+      ...opts.paths === void 0 ? {} : { paths: opts.paths },
+      ...opts.collection === void 0 ? {} : { collection: opts.collection }
+    },
+    cwd
+  );
+  const format = assertInputFormat(opts.paths ?? [], opts.as);
+  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);
+  if (files.length === 0 && !usingStdin) {
+    if (opts.allowEmpty) {
+      return { outPath, docs: 0, quads: 0, warnings: [], turtle: emitTurtle([]) };
+    }
+    throw new GraphError(
+      `No input files matched: ${documentSetPatterns(config, opts).join(", ")} (cwd: ${cwd})`
+    );
+  }
+  if (usingStdin && opts.stdinContent === void 0) {
+    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 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)
+  );
+  if (usingStdin && opts.stdinContent !== void 0) {
+    read.push(analyzeDoc(opts.stdinContent, STDIN_PATH, allPaths, analyzeOptions));
+  }
+  const view = await openMetaView(
+    {
+      ...opts.config === void 0 ? {} : { configPath: opts.config },
+      ...opts.noConfig === void 0 ? {} : { noConfig: opts.noConfig }
+    },
+    cwd,
+    files,
+    base
+  );
+  const merged = await withExternalMetadata(read, view);
+  const docs = await suppressGraphOutput(merged, view);
+  const warnings = harvestWarnings(docs);
+  let gitHistory;
+  if (config.build.derive.includes("provenance")) {
+    try {
+      gitHistory = await collectGitHistory(base);
+    } catch (e) {
+      warnings.push(gitAbsentWarning(errorMessage(e)));
+    }
+  }
+  const quads = deriveGraph(docs, {
+    baseIri: config.baseIri,
+    derive: config.build.derive,
+    // The package version, stamped on the build agent (graph:version). One
+    // package, one version: the tool no longer has one of its own.
+    toolVersion: package_default.version,
+    gitHistory,
+    qualified: config.provenance.qualified
+  });
+  const turtle = emitTurtle(quads);
+  await cache.flush();
+  return { outPath, docs: docs.length, quads: quads.length, warnings, turtle };
+}
+
+export {
+  formatOf,
+  analyzeDoc,
+  discoverFiles,
+  DEFAULT_EXTENSIONS,
+  STDIN,
+  assertInputFormat,
+  resolveDocumentSet,
+  documentBase,
+  routesFrom,
+  documentSetPatterns,
+  LOCALIZATIONS_FILENAME,
+  UNDETERMINED,
+  isLanguageTag,
+  canonicalLanguageTag,
+  searchIndexFilename,
+  vectorIndexFilename,
+  emitLocalizations,
+  parseLocalizations,
+  isSafeRelativePath,
+  deriveGraph,
+  emitTurtle,
+  collectGitHistory,
+  openMetaView,
+  mergePage,
+  ownMetadata,
+  GIT_ABSENT_WARNING,
+  gitAbsentWarning,
+  runBuild,
+  buildGraph
+};
+//# sourceMappingURL=chunk-NLXTXE5Y.js.map