@hawkeyexl/manni 4.11.0 → 4.12.0

package/dist/{chunk-J6IDQGJL.js → chunk-FKAZUZQU.js}

@@ -1,7 +1,4 @@
 #!/usr/bin/env node
-import {
-  SEVERITIES
-} from "./chunk-77AINBYM.js";
 import {
   codeEndAt,
   codeRegions
@@ -10,7 +7,7 @@ import {
   CONCEPT_FIELDS,
   fieldPointer,
   valueAt
-} from "./chunk-6HWBRZIN.js";
+} from "./chunk-PS257NIU.js";
 import {
   STDIN_LABEL,
   STDIN_TOKEN,
@@ -21,13 +18,16 @@ import {
   locateFrontmatter,
   resolveTargetSet,
   supportedExtensions
-} from "./chunk-VSEBFHAY.js";
+} from "./chunk-RGLFV4KO.js";
+import {
+  SEVERITIES
+} from "./chunk-77AINBYM.js";
 import {
   findConfigFile,
   readConfigFile,
   selectCollections,
   valeConfigPath
-} from "./chunk-QLWC7MKD.js";
+} from "./chunk-OTJOBZJ5.js";
 import {
   ToolError,
   errorMessage
@@ -53,6 +53,12 @@ var TERM_FIELDS = [
   "related-terms",
   "see",
   "scope-note",
+  "notation",
+  "exact-matches",
+  "close-matches",
+  "broad-matches",
+  "narrow-matches",
+  "related-matches",
   "subject-field",
   "contexts",
   "notes",
@@ -75,6 +81,13 @@ var TERM_LIST_FIELDS = [
   "narrower",
   "related-terms"
 ];
+var TERM_MATCH_FIELDS = [
+  "exact-matches",
+  "close-matches",
+  "broad-matches",
+  "narrow-matches",
+  "related-matches"
+];
 var TERM_AUX_FIELDS = [
   "definition",
   "subject-field",
@@ -112,6 +125,7 @@ var TERM_WRITE_FORMATS = [
   "tbx",
   "tbx3",
   "skos",
+  "skos-ttl",
   "csv",
   "json",
   "vale"
@@ -121,12 +135,24 @@ var TERM_RULES = [
   "duplicate-id",
   "label-collision",
   "alt-label-collision",
+  "label-overlap",
   "dangling-reference",
   "broader-cycle",
   "see-not-empty",
+  "missing-definition",
+  "conflicting-matches",
   "asymmetric-hierarchy",
+  "asymmetric-related",
+  "related-in-hierarchy",
+  "alt-label-reference",
+  "ambiguous-alt-label",
+  "deprecated-label",
   "abstract-too-long",
-  "unused-term"
+  "unused-term",
+  "hierarchy-outside-termbase",
+  "related-siblings",
+  "orphan-term",
+  "keyword-candidate"
 ];
 
 // src/term/core/config.ts
@@ -140,8 +166,16 @@ var CONFIG_KEYS = [
   "baseline",
   "severity",
   "allowEmpty",
-  "respectGitignore"
+  "respectGitignore",
+  "provider",
+  "model",
+  "fill"
 ];
+var FILL_KEYS = ["out", "confidenceThreshold", "maxTurns", "cacheDir", "crawl"];
+var CRAWL_KEYS = ["minPages"];
+var DEFAULT_FILL_CONFIDENCE = 0.7;
+var DEFAULT_FILL_CACHE_DIR = ".manni/term/cache";
+var DEFAULT_CRAWL_MIN_PAGES = 2;
 var COLLECTION_KEYS = ["paths", "exclude"];
 var TOOL_KEYS = ["vale"];
 var SEVERITY_LEVELS = [...SEVERITIES, "off"];
@@ -191,6 +225,40 @@ function asNonNegativeInteger(value, key, source) {
   }
   return value;
 }
+function parseFill(value, source) {
+  if (!isMapping(value)) throw wrongType("fill", "a mapping", source);
+  rejectUnknownKeys(value, FILL_KEYS, "term.fill", source);
+  const fill = {};
+  if (value.out !== void 0) fill.out = asString(value.out, "fill.out", source);
+  if (value.cacheDir !== void 0) fill.cacheDir = asString(value.cacheDir, "fill.cacheDir", source);
+  const threshold = value.confidenceThreshold;
+  if (threshold !== void 0) {
+    if (typeof threshold !== "number" || !(threshold >= 0 && threshold <= 1)) {
+      throw wrongType("fill.confidenceThreshold", "a number from 0 to 1", source);
+    }
+    fill.confidenceThreshold = threshold;
+  }
+  const turns = value.maxTurns;
+  if (turns !== void 0) {
+    if (turns !== null && (typeof turns !== "number" || !Number.isInteger(turns) || turns < 1)) {
+      throw wrongType("fill.maxTurns", "a positive integer or null", source);
+    }
+    fill.maxTurns = turns;
+  }
+  if (value.crawl !== void 0) {
+    if (!isMapping(value.crawl)) throw wrongType("fill.crawl", "a mapping", source);
+    rejectUnknownKeys(value.crawl, CRAWL_KEYS, "term.fill.crawl", source);
+    const minPages = value.crawl.minPages;
+    fill.crawl = {};
+    if (minPages !== void 0) {
+      if (typeof minPages !== "number" || !Number.isInteger(minPages) || minPages < 1) {
+        throw wrongType("fill.crawl.minPages", "a positive integer", source);
+      }
+      fill.crawl.minPages = minPages;
+    }
+  }
+  return fill;
+}
 function parseSeverity(value, source) {
   if (!isMapping(value)) throw wrongType("severity", "a mapping", source);
   rejectUnknownKeys(value, TERM_RULES, "term.severity", source);
@@ -238,6 +306,9 @@ function parseTermConfig(raw, source) {
   if (raw.respectGitignore !== void 0) {
     config.respectGitignore = asBoolean(raw.respectGitignore, "respectGitignore", source);
   }
+  if (raw.provider !== void 0) config.provider = asString(raw.provider, "provider", source);
+  if (raw.model !== void 0) config.model = asString(raw.model, "model", source);
+  if (raw.fill !== void 0) config.fill = parseFill(raw.fill, source);
   return config;
 }
 function readTermConfigFile(explicitPath, cwd) {
@@ -320,6 +391,8 @@ import { isAbsolute, relative, resolve as resolve3 } from "node:path";
 // src/term/core/load-set.ts
 import { readFile } from "node:fs/promises";
 import { extname, resolve as resolve2 } from "node:path";
+import { pathToFileURL } from "node:url";
+import { DataFactory, Writer } from "n3";
 
 // src/term/core/writers/markup.ts
 function xmlText(value) {
@@ -486,6 +559,9 @@ function collapse(text) {
 function isListField(field) {
   return TERM_LIST_FIELDS.includes(field);
 }
+function isListOfText(field) {
+  return isListField(field) || field === "tbx-markup" || TERM_MATCH_FIELDS.includes(field);
+}
 function isAuxField(field) {
   return TERM_AUX_FIELDS.includes(field);
 }
@@ -620,7 +696,7 @@ function recordOf(raw, issues) {
   for (const field of TERM_FIELDS) {
     const value = raw[field];
     if (field === "label") continue;
-    if (isListField(field) || field === "tbx-markup") {
+    if (isListOfText(field)) {
       const list = listOf(value);
       if (list !== void 0) record[field] = list;
     } else if (isAuxField(field)) {
@@ -692,9 +768,9 @@ function indentAt(content, offset) {
   const lineStart = content.lastIndexOf("\n", offset - 1) + 1;
   return /^[ \t]*/.exec(content.slice(lineStart, offset))?.[0] ?? "";
 }
-function applyEntries(input, read8, terms, write) {
+function applyEntries(input, read9, terms, write) {
   const { content } = input;
-  const current = read8(input).terms;
+  const current = read9(input).terms;
   const eol = lineEnding(content);
   const edits = [];
   for (const term of terms) {
@@ -900,9 +976,9 @@ function readEntry(input, xml, entry, construct, label) {
 function collect(input, xml, entries, construct, label) {
   const result = nothing();
   for (const entry of entries) {
-    const read8 = readEntry(input, xml, entry, construct, label);
-    if (typeof read8 === "string") result.notices.push(read8);
-    else result.terms.push(read8);
+    const read9 = readEntry(input, xml, entry, construct, label);
+    if (typeof read9 === "string") result.notices.push(read9);
+    else result.terms.push(read9);
   }
   return result;
 }
@@ -1488,6 +1564,173 @@ var pageReader = {
   apply
 };
 
+// src/term/core/readers/skos.ts
+import { Parser } from "n3";
+var SKOS = "http://www.w3.org/2004/02/skos/core#";
+var RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+var CONCEPT = `${SKOS}Concept`;
+var SKOS_PROPERTIES = [
+  { property: "prefLabel", field: "label", kind: "text" },
+  { property: "altLabel", field: "alt-labels", kind: "texts" },
+  { property: "hiddenLabel", field: "hidden-labels", kind: "texts" },
+  { property: "definition", field: "definition", kind: "text" },
+  { property: "scopeNote", field: "scope-note", kind: "text" },
+  { property: "notation", field: "notation", kind: "code" },
+  { property: "broader", field: "broader", kind: "concepts" },
+  { property: "narrower", field: "narrower", kind: "concepts" },
+  { property: "related", field: "related-terms", kind: "concepts" },
+  { property: "exactMatch", field: "exact-matches", kind: "iris" },
+  { property: "closeMatch", field: "close-matches", kind: "iris" },
+  { property: "broadMatch", field: "broad-matches", kind: "iris" },
+  { property: "narrowMatch", field: "narrow-matches", kind: "iris" },
+  { property: "relatedMatch", field: "related-matches", kind: "iris" },
+  { property: "note", field: "notes", kind: "texts" },
+  { property: "example", field: "contexts", kind: "texts" }
+];
+var BY_IRI = new Map(SKOS_PROPERTIES.map((p) => [`${SKOS}${p.property}`, p]));
+var UNDERSTOOD = /* @__PURE__ */ new Set([RDF_TYPE, `${SKOS}inScheme`, `${SKOS}topConceptOf`]);
+var PREFIXES = [
+  ["skos", SKOS],
+  ["rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"],
+  ["rdfs", "http://www.w3.org/2000/01/rdf-schema#"],
+  ["dcterms", "http://purl.org/dc/terms/"],
+  ["owl", "http://www.w3.org/2002/07/owl#"]
+];
+var LABEL4 = "SKOS concept";
+function nameOf2(iri) {
+  for (const [prefix, namespace] of PREFIXES) {
+    if (iri.startsWith(namespace)) return `${prefix}:${iri.slice(namespace.length)}`;
+  }
+  return `<${iri}>`;
+}
+function localName(iri) {
+  const tail = iri.slice(Math.max(iri.lastIndexOf("#"), iri.lastIndexOf("/")) + 1);
+  if (tail === "") return void 0;
+  try {
+    return decodeURIComponent(tail);
+  } catch {
+    return tail;
+  }
+}
+var Unread = class {
+  counts = /* @__PURE__ */ new Map();
+  add(reason) {
+    this.counts.set(reason, (this.counts.get(reason) ?? 0) + 1);
+  }
+  notices(file) {
+    return [...this.counts].map(
+      ([reason, n]) => `${file}: ${reason}, so ${n === 1 ? "1 value was" : `${String(n)} values were`} not read.`
+    );
+  }
+};
+function parse2(input) {
+  try {
+    return new Parser().parse(input.content);
+  } catch (error) {
+    throw new TermError(`${input.file}: could not be read as SKOS: ${errorMessage(error)}`);
+  }
+}
+function concepts(quads) {
+  const typed = new Set(
+    quads.filter((q) => q.predicate.value === RDF_TYPE && q.object.value === CONCEPT).map((q) => q.subject.id)
+  );
+  const found = /* @__PURE__ */ new Map();
+  for (const quad of quads) {
+    if (!typed.has(quad.subject.id)) continue;
+    const entry = found.get(quad.subject.id) ?? { subject: quad.subject, quads: [] };
+    entry.quads.push(quad);
+    found.set(quad.subject.id, entry);
+  }
+  return found;
+}
+function append(raw, field, value) {
+  const current = raw[field];
+  raw[field] = Array.isArray(current) ? [...current, value] : [value];
+}
+function readConcept(input, subject, quads, unread, notices) {
+  const id = subject.termType === "NamedNode" ? localName(subject.value) : void 0;
+  const name = id ?? subject.value;
+  const languages = /* @__PURE__ */ new Map();
+  for (const quad of quads) {
+    if (quad.predicate.value === `${SKOS}prefLabel` && quad.object.termType === "Literal") {
+      languages.set(quad.object.language, languages.get(quad.object.language) ?? {});
+    }
+  }
+  if (languages.size === 0) {
+    notices.push(`${input.file}: skipped SKOS concept "${name}", which has no skos:prefLabel.`);
+    return [];
+  }
+  const shared = {};
+  for (const { predicate, object } of quads) {
+    if (UNDERSTOOD.has(predicate.value)) continue;
+    const property = BY_IRI.get(predicate.value);
+    const spelled = nameOf2(predicate.value);
+    if (property === void 0) {
+      unread.add(`${spelled} is not a term field`);
+      continue;
+    }
+    if (property.kind === "concepts" || property.kind === "iris") {
+      if (object.termType === "Literal") {
+        unread.add(`${spelled} on "${name}" is not an IRI`);
+        continue;
+      }
+      const value = property.kind === "concepts" ? localName(object.value) ?? object.value : object.value;
+      append(shared, property.field, value);
+      continue;
+    }
+    if (object.termType !== "Literal") {
+      unread.add(`${spelled} on "${name}" is not text`);
+      continue;
+    }
+    if (property.kind === "code") {
+      if (shared[property.field] === void 0) shared[property.field] = object.value;
+      else unread.add(`"${name}" holds one ${spelled}`);
+      continue;
+    }
+    const language = object.language;
+    const raw = languages.get(language);
+    if (raw === void 0) {
+      unread.add(language === "" ? `"${name}" has no untagged skos:prefLabel` : `"${name}" has no skos:prefLabel in ${language}`);
+      continue;
+    }
+    if (property.kind === "texts") {
+      append(raw, property.field, object.value);
+    } else if (raw[property.field] === void 0) {
+      raw[property.field] = object.value;
+    } else {
+      unread.add(`"${name}" holds one ${spelled} per language`);
+    }
+  }
+  const terms = [];
+  for (const language of [...languages.keys()].sort()) {
+    const record = recordOf({ ...languages.get(language), ...shared });
+    if (record === void 0) continue;
+    terms.push(
+      termOf(input, { record, recordId: id, construct: "skos", line: 1, lines: {}, language: language === "" ? void 0 : language })
+    );
+  }
+  return terms;
+}
+function read4(input) {
+  const unread = new Unread();
+  const notices = [];
+  const entries = [...concepts(parse2(input)).values()].map(({ subject, quads }) => ({
+    subject: subject.value,
+    terms: readConcept(input, subject, quads, unread, notices)
+  }));
+  entries.sort((a, b) => {
+    const [x, y] = [a.terms[0]?.id ?? "", b.terms[0]?.id ?? ""];
+    return x === y ? a.subject < b.subject ? -1 : 1 : x < y ? -1 : 1;
+  });
+  return { terms: entries.flatMap((entry) => entry.terms), notices: [...notices, ...unread.notices(input.file)] };
+}
+var skosReader = {
+  construct: "skos",
+  label: LABEL4,
+  formats: ["skos"],
+  read: read4
+};
+
 // src/term/core/readers/tbx.ts
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 import { DOMParser as DOMParser3 } from "@xmldom/xmldom";
@@ -1792,7 +2035,7 @@ function tbxEntryLines(terms, format, shape) {
 }
 
 // src/term/core/readers/tbx.ts
-var LABEL4 = "TBX entry";
+var LABEL5 = "TBX entry";
 var parsed = /* @__PURE__ */ new WeakMap();
 function parseTbx(input) {
   const cached = parsed.get(input);
@@ -2030,13 +2273,13 @@ function statusOf(text) {
   for (const [status, value] of Object.entries(TBX_STATUS_VALUES)) if (value === text) return status;
   return text in TBX_STATUS_VALUES || text === TBX_NO_STATUS ? void 0 : text;
 }
-function readLevel(doc, children, level, read8) {
-  let { aux } = read8;
+function readLevel(doc, children, level, read9) {
+  let { aux } = read9;
   const items = [];
   const seen = [];
   const keep = (value) => {
     seen.push(value);
-    if (value.markup !== void 0) read8.markup.push(value.markup);
+    if (value.markup !== void 0) read9.markup.push(value.markup);
     return value.text;
   };
   const definitionEl = children.find(
@@ -2126,12 +2369,12 @@ function readLevel(doc, children, level, read8) {
     return false;
   };
   for (const child of children) {
-    const saved = read8.fits === void 0 ? void 0 : { aux: structuredClone(aux), markup: read8.markup.length };
+    const saved = read9.fits === void 0 ? void 0 : { aux: structuredClone(aux), markup: read9.markup.length };
     seen.length = 0;
-    if (mapped(child) && (read8.fits === void 0 || seen.every(read8.fits))) continue;
+    if (mapped(child) && (read9.fits === void 0 || seen.every(read9.fits))) continue;
     if (saved !== void 0) {
-      aux = read8.aux = saved.aux;
-      read8.markup.length = saved.markup;
+      aux = read9.aux = saved.aux;
+      read9.markup.length = saved.markup;
     }
     items.push(itemOf(doc, child));
   }
@@ -2150,14 +2393,14 @@ function readDesignation(doc, el, fits) {
   const term = termEl === void 0 ? void 0 : valueOf(doc, termEl, true, true);
   const text = termEl === void 0 ? void 0 : textOf(lf(termEl.textContent ?? ""));
   if (termEl === void 0 || text === void 0) return void 0;
-  const read8 = { aux: { term: text }, markup: term?.markup === void 0 ? [] : [term.markup], ...fits === void 0 ? {} : { fits } };
+  const read9 = { aux: { term: text }, markup: term?.markup === void 0 ? [] : [term.markup], ...fits === void 0 ? {} : { fits } };
   readLevel(
     doc,
     children.filter((child) => child !== termEl),
     "term",
-    read8
+    read9
   );
-  const { "administrative-status": status, ...designation } = read8.aux;
+  const { "administrative-status": status, ...designation } = read9.aux;
   const shape = {
     term: text,
     attributes: attributesOf(el),
@@ -2167,21 +2410,21 @@ function readDesignation(doc, el, fits) {
   return {
     designation,
     term: term ?? { text },
-    markup: read8.markup,
+    markup: read9.markup,
     status: status ?? TBX_NO_STATUS,
     line: lineOfElement(termEl),
     shape
   };
 }
-function labelsOf2(read8) {
-  const preferred = read8.findIndex((d) => d.status === "preferred");
+function labelsOf2(read9) {
+  const preferred = read9.findIndex((d) => d.status === "preferred");
   const labelAt = preferred === -1 ? 0 : preferred;
   const alts = [];
   const hiddens = [];
   const order = [];
   const altOrder = [];
   const hiddenOrder = [];
-  const designations = read8.map((d, i) => {
+  const designations = read9.map((d, i) => {
     const { status } = d;
     let kind;
     if (i === labelAt) kind = "label";
@@ -2201,7 +2444,7 @@ function labelsOf2(read8) {
   const reordered = order.some((at, i) => at !== i);
   const detailed = designations.some((d) => Object.keys(d).length > 1);
   return {
-    label: read8[labelAt]?.designation.term ?? "",
+    label: read9[labelAt]?.designation.term ?? "",
     alts,
     hiddens,
     designations: reordered || detailed ? designations : void 0
@@ -2258,7 +2501,7 @@ function readEntry2(doc, entry, result) {
   const { term: _none, ...conceptAux } = concept.aux;
   const span = spanOfElement(doc.xml, entry);
   const rootLanguage = doc.xml.root.getAttribute("xml:lang");
-  const read8 = [];
+  const read9 = [];
   let entryId = textOf(entry.getAttribute("id"));
   const shape = { attributes: attributesOf(entry, ["id"]), languages: [] };
   for (const part of parts.languages) {
@@ -2298,9 +2541,9 @@ function readEntry2(doc, entry, result) {
       attributes: attributesOf(langEl, ["xml:lang"]),
       designations: designations.map((d) => d.shape)
     });
-    read8.push(term);
+    read9.push(term);
   }
-  result.terms.push(...read8);
+  result.terms.push(...read9);
 }
 function readTbx(input) {
   const doc = parseTbx(input);
@@ -2387,17 +2630,17 @@ function spliceEntries(input, terms, exporting) {
 function withEditedConcept(written, current) {
   const [head, ...rest] = written;
   if (head === void 0) return { terms: written, conflicts: [] };
-  const read8 = current[0]?.record["concept-entry"] ?? {};
-  const concepts = written.map((t) => t.record["concept-entry"] ?? {});
-  const edits = (concept2) => TERM_AUX_FIELDS.filter((field) => !isDeepStrictEqual2(concept2[field], read8[field]));
+  const read9 = current[0]?.record["concept-entry"] ?? {};
+  const concepts2 = written.map((t) => t.record["concept-entry"] ?? {});
+  const edits = (concept2) => TERM_AUX_FIELDS.filter((field) => !isDeepStrictEqual2(concept2[field], read9[field]));
   const { conflicts } = mergeFirst(
     head.id,
-    concepts.map((c) => Object.fromEntries(edits(c).map((field) => [field, { value: c[field] }]))),
+    concepts2.map((c) => Object.fromEntries(edits(c).map((field) => [field, { value: c[field] }]))),
     "concept-entry."
   );
   const concept = {};
   for (const field of TERM_AUX_FIELDS) {
-    copyField(concept, concepts.find((c) => edits(c).includes(field)) ?? read8, field);
+    copyField(concept, concepts2.find((c) => edits(c).includes(field)) ?? read9, field);
   }
   const { "concept-entry": _old, ...record } = head.record;
   const joined = Object.keys(concept).length === 0 ? record : { ...record, "concept-entry": concept };
@@ -2416,7 +2659,7 @@ function merge(current, given) {
 }
 var tbxEntryReader = {
   construct: "tbx-entry",
-  label: LABEL4,
+  label: LABEL5,
   formats: ["tbx"],
   read: readTbx,
   apply: applyTbx
@@ -2431,7 +2674,8 @@ var STRUCTURED_READERS = [
   docbookGlossaryReader,
   htmlDlReader,
   htmlDfnReader,
-  tbxEntryReader
+  tbxEntryReader,
+  skosReader
 ];
 
 // src/term/core/readers/body.ts
@@ -2512,7 +2756,7 @@ function skippedNotice(input, line, label, missing) {
 }
 
 // src/term/core/readers/asciidoc-glossary.ts
-var LABEL5 = "[glossary] list";
+var LABEL6 = "[glossary] list";
 var ATTRIBUTE = /^\[glossary\][ \t]*$/;
 var ITEM = /^[ \t]*(.*?[^:\s])::(?:[ \t]+(.*))?$/;
 var BLOCK_TITLE = /^\.[^.\s]/;
@@ -2524,7 +2768,7 @@ function item(line) {
   const text = match[2]?.trim();
   return { term, text: text === "" ? void 0 : text };
 }
-function read4(input) {
+function read5(input) {
   const terms = [];
   const notices = [];
   const lines = bodyLines(input);
@@ -2561,13 +2805,13 @@ function readList(input, lines, at, terms, notices) {
           })
         );
       } else if (firstLabel !== void 0) {
-        notices.push(skippedNotice(input, firstLabel.line, LABEL5, "definition"));
+        notices.push(skippedNotice(input, firstLabel.line, LABEL6, "definition"));
       }
       open = void 0;
     }
     const [firstPending] = pending;
     if (firstPending !== void 0) {
-      notices.push(skippedNotice(input, firstPending.line, LABEL5, "definition"));
+      notices.push(skippedNotice(input, firstPending.line, LABEL6, "definition"));
       pending = [];
     }
   };
@@ -2619,14 +2863,14 @@ function itemTerm(line) {
 }
 var asciidocGlossaryReader = {
   construct: "asciidoc-glossary",
-  label: LABEL5,
+  label: LABEL6,
   formats: ["asciidoc"],
-  read: read4,
-  apply: (input, terms) => applyEntries(input, read4, terms, { holds: LIST_HOLDS, id: false, serialize: (term) => asciidocEntry(term.record) })
+  read: read5,
+  apply: (input, terms) => applyEntries(input, read5, terms, { holds: LIST_HOLDS, id: false, serialize: (term) => asciidocEntry(term.record) })
 };
 
 // src/term/core/readers/markdown-deflist.ts
-var LABEL6 = "definition list";
+var LABEL7 = "definition list";
 var DEFINITION = /^:(?:[ \t]+(.*))?$/;
 var INDENTED = /^(?: {4}|\t)/;
 var HEADING = /^#{1,6}(?:[ \t]|$)/;
@@ -2635,7 +2879,7 @@ function definitionStart(line) {
   const match = DEFINITION.exec(line.text);
   return match === null ? void 0 : match[1] ?? "";
 }
-function read5(input) {
+function read6(input) {
   const terms = [];
   const notices = [];
   if (input.metadata["type"] !== "term-set") return { terms, notices };
@@ -2663,7 +2907,7 @@ function read5(input) {
     }
     if (labels.length === 0 || labels.some((l) => HEADING.test(l.text))) {
       const orphan = lines[j];
-      if (orphan !== void 0) notices.push(skippedNotice(input, orphan.line, LABEL6, "term"));
+      if (orphan !== void 0) notices.push(skippedNotice(input, orphan.line, LABEL7, "term"));
       i = readDefinitions(lines, j, []);
       continue;
     }
@@ -2674,7 +2918,7 @@ function read5(input) {
     if (firstLabel === void 0 || kept === void 0) continue;
     const text = definitionText(kept.paragraphs);
     if (text === void 0) {
-      notices.push(skippedNotice(input, firstLabel.line, LABEL6, "definition"));
+      notices.push(skippedNotice(input, firstLabel.line, LABEL7, "definition"));
       continue;
     }
     for (const extra of definitions.slice(1)) {
@@ -2735,14 +2979,14 @@ function readDefinitions(lines, at, out) {
 }
 var markdownDeflistReader = {
   construct: "markdown-deflist",
-  label: LABEL6,
+  label: LABEL7,
   formats: ["markdown", "mdx"],
-  read: read5,
-  apply: (input, terms) => applyEntries(input, read5, terms, { holds: LIST_HOLDS, id: false, serialize: (term) => markdownEntry(term.record) })
+  read: read6,
+  apply: (input, terms) => applyEntries(input, read6, terms, { holds: LIST_HOLDS, id: false, serialize: (term) => markdownEntry(term.record) })
 };
 
 // src/term/core/readers/rst-glossary.ts
-var LABEL7 = ".. glossary::";
+var LABEL8 = ".. glossary::";
 var DIRECTIVE = /^[ \t]*\.\.[ \t]+glossary::[ \t]*$/;
 var CODE_DIRECTIVE = /^[ \t]*\.\.[ \t]+(?:code-block|code|sourcecode)::/;
 var EXPLICIT_MARKUP = /^[ \t]*\.\.(?:[ \t]|$)/;
@@ -2761,7 +3005,7 @@ function opensLiteral(line) {
   if (CODE_DIRECTIVE.test(line.text)) return true;
   return !EXPLICIT_MARKUP.test(line.text) && line.text.trimEnd().endsWith("::");
 }
-function read6(input) {
+function read7(input) {
   const terms = [];
   const notices = [];
   const lines = bodyLines(input);
@@ -2811,7 +3055,7 @@ function readGlossary(input, lines, at, terms, notices) {
           })
         );
       } else {
-        notices.push(skippedNotice(input, first.line, LABEL7, "definition"));
+        notices.push(skippedNotice(input, first.line, LABEL8, "definition"));
       }
     }
     labels = [];
@@ -2846,7 +3090,7 @@ function readGlossary(input, lines, at, terms, notices) {
     } else if (labels.length > 0) {
       definition = { line: line.line, paragraphs: [[line.text]], last: line, gap: false };
     } else if (!orphan) {
-      notices.push(skippedNotice(input, line.line, LABEL7, "term"));
+      notices.push(skippedNotice(input, line.line, LABEL8, "term"));
       orphan = true;
     }
   }
@@ -2860,10 +3104,10 @@ function termText(line) {
 }
 var rstGlossaryReader = {
   construct: "rst-glossary",
-  label: LABEL7,
+  label: LABEL8,
   formats: ["rst"],
-  read: read6,
-  apply: (input, terms) => applyEntries(input, read6, terms, { holds: LIST_HOLDS, id: false, serialize: (term) => rstEntry(term.record) })
+  read: read7,
+  apply: (input, terms) => applyEntries(input, read7, terms, { holds: LIST_HOLDS, id: false, serialize: (term) => rstEntry(term.record) })
 };
 
 // src/term/core/readers/text.ts
@@ -2890,6 +3134,74 @@ var TBX_EXTENSION = ".tbx";
 function tbxInput(content, file, path) {
   return { content, file, ...path === void 0 ? {} : { path }, format: TBX_FORMAT, metadata: {}, lineFor: () => void 0 };
 }
+var SKOS_FORMAT = "skos";
+var SKOS_EXTENSIONS = /* @__PURE__ */ new Set([".ttl", ".jsonld"]);
+function isSkos(file) {
+  return SKOS_EXTENSIONS.has(extname(file).toLowerCase());
+}
+var XSD_STRING = "http://www.w3.org/2001/XMLSchema#string";
+async function jsonLdToNQuads(content, file, path, parsed2) {
+  let document = parsed2;
+  if (document === void 0) {
+    try {
+      document = JSON.parse(content);
+    } catch (error) {
+      throw new TermError(`${file}: could not be read as SKOS: ${errorMessage(error)}`);
+    }
+  }
+  const { default: jsonld } = await import("jsonld");
+  let remote;
+  let dataset;
+  try {
+    dataset = await jsonld.toRDF(document, {
+      base: pathToFileURL(path ?? resolve2(file)).href,
+      documentLoader: (url) => {
+        remote = url;
+        return Promise.reject(new Error(`${url} is not fetched`));
+      }
+    });
+  } catch (error) {
+    if (remote !== void 0) {
+      throw new TermError(
+        `${file}: names the remote @context ${remote}, which is not fetched. Inline the context to read it.`
+      );
+    }
+    throw new TermError(`${file}: could not be read as SKOS: ${errorMessage(error)}`);
+  }
+  const node = (t) => t.termType === "BlankNode" ? DataFactory.blankNode(t.value.replace(/^_:/, "")) : DataFactory.namedNode(t.value);
+  const literal = (t) => DataFactory.literal(
+    t.value,
+    t.language !== void 0 && t.language !== "" ? t.language : DataFactory.namedNode(t.datatype?.value ?? XSD_STRING)
+  );
+  const quads = dataset.map(
+    (q) => DataFactory.quad(
+      node(q.subject),
+      DataFactory.namedNode(q.predicate.value),
+      q.object.termType === "Literal" ? literal(q.object) : node(q.object)
+    )
+  );
+  return new Writer({ format: "N-Quads" }).quadsToString(quads);
+}
+function parseJson(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+}
+async function skosInput(content, file, path) {
+  const ext = extname(file).toLowerCase();
+  const parsed2 = ext === ".ttl" ? void 0 : parseJson(content);
+  const jsonLd = ext === ".jsonld" || parsed2 !== void 0;
+  return {
+    content: jsonLd ? await jsonLdToNQuads(content, file, path, parsed2) : content,
+    file,
+    ...path === void 0 ? {} : { path },
+    format: SKOS_FORMAT,
+    metadata: {},
+    lineFor: () => void 0
+  };
+}
 function defaultExtensions() {
   return [...supportedExtensions(), TBX_EXTENSION];
 }
@@ -2903,18 +3215,72 @@ function labelsOf3(value) {
   }
   return [];
 }
+function languageOf3(input) {
+  const language = input.metadata["language"];
+  return typeof language === "string" && language !== "" ? { language } : {};
+}
+function lineAt(input, path) {
+  const line = input.lineFor(fieldPointer(path));
+  return line === void 0 ? {} : { line };
+}
 function referencesOf(input) {
   const references = [];
-  const add = (value, pointer) => {
-    for (const label of labelsOf3(value)) {
-      const line = input.lineFor(pointer);
-      references.push({ file: input.file, label, ...line === void 0 ? {} : { line } });
+  for (const path of CONCEPT_FIELDS) {
+    for (const label of labelsOf3(valueAt(input.metadata, path))) {
+      references.push({
+        file: input.file,
+        label,
+        ...lineAt(input, path),
+        ...path.length > 1 ? { field: path.join(".") } : {},
+        ...languageOf3(input)
+      });
     }
-  };
-  for (const path of CONCEPT_FIELDS) add(valueAt(input.metadata, path), fieldPointer(path));
+  }
   return references;
 }
-function read7(input, readers, set) {
+var BLOCK_HIERARCHY_FIELDS = ["broader", "narrower", "related-concepts"];
+function blocksOf(input) {
+  const label = valueAt(input.metadata, ["graph", "label"]);
+  if (typeof label !== "string" || label.trim() === "") return [];
+  const edges = BLOCK_HIERARCHY_FIELDS.flatMap(
+    (field) => labelsOf3(valueAt(input.metadata, ["graph", field])).map((value) => ({
+      field,
+      value,
+      ...lineAt(input, ["graph", field])
+    }))
+  );
+  const altLabels = labelsOf3(valueAt(input.metadata, ["graph", "alt-labels"]));
+  const definition = valueAt(input.metadata, ["graph", "definition"]);
+  return [
+    {
+      file: input.file,
+      ...lineAt(input, ["graph"]),
+      ...languageOf3(input),
+      label,
+      edges,
+      ...altLabels.length > 0 ? { altLabels } : {},
+      ...typeof definition === "string" && definition.trim() !== "" ? { definition } : {}
+    }
+  ];
+}
+function keywordsOf(input) {
+  const type = input.metadata["type"];
+  if (type === "term" || type === "term-set") return [];
+  return labelsOf3(input.metadata["keywords"]).map((label) => ({
+    file: input.file,
+    ...lineAt(input, ["keywords"]),
+    label,
+    field: "keywords",
+    ...languageOf3(input)
+  }));
+}
+function pageFacts(input, set, onPage) {
+  set.references.push(...referencesOf(input));
+  set.blocks.push(...blocksOf(input));
+  (set.keywords ??= []).push(...keywordsOf(input));
+  onPage?.(input);
+}
+function read8(input, readers, set) {
   for (const reader of readersForFormat(input.format, readers)) {
     const result = reader.read(input);
     set.terms.push(...result.terms);
@@ -2963,7 +3329,7 @@ async function loadTermSet(opts) {
       "No files to read. Pass paths/globs, or declare a collection under `collections:` in manni.config.yaml."
     );
   }
-  const set = { terms: [], references: [], notices: [] };
+  const set = { terms: [], references: [], blocks: [], keywords: [], notices: [] };
   if (inputs.length > 0) {
     const { files, gitignoreSkipped, named } = await resolveTargetSet({
       inputs,
@@ -2991,11 +3357,15 @@ async function loadTermSet(opts) {
     for (const file of files) {
       const path = resolve2(run.base, file);
       if (namedFiles.has(file) && MANIFEST_EXTENSIONS.has(extname(file).toLowerCase())) {
-        read7(manifestInput(await readInput(path, file), file, path), readers, set);
+        read8(manifestInput(await readInput(path, file), file, path), readers, set);
+        continue;
+      }
+      if (namedFiles.has(file) && isSkos(file)) {
+        read8(await skosInput(await readInput(path, file), file, path), readers, set);
         continue;
       }
       if (extname(file).toLowerCase() === TBX_EXTENSION) {
-        read7(tbxInput(await readInput(path, file), file, path), readers, set);
+        read8(tbxInput(await readInput(path, file), file, path), readers, set);
         continue;
       }
       const extractor = extractorForExtension(extname(file));
@@ -3003,14 +3373,16 @@ async function loadTermSet(opts) {
         throw new TermError(`${file}: no reader for its extension. Pass --as <format> through stdin to read it.`);
       }
       const input = extractInput(await readInput(path, file), file, path, extractor.name);
-      set.references.push(...referencesOf(input));
-      read7(input, readers, set);
+      pageFacts(input, set, opts.onPage);
+      read8(input, readers, set);
     }
   }
-  if (usingStdin && opts.as !== void 0) {
+  if (usingStdin && opts.as?.toLowerCase() === SKOS_FORMAT) {
+    read8(await skosInput(opts.stdin ?? "", STDIN_LABEL), readers, set);
+  } else if (usingStdin && opts.as !== void 0) {
     const input = opts.as.toLowerCase() === TBX_FORMAT ? tbxInput(opts.stdin ?? "", STDIN_LABEL) : extractInput(opts.stdin ?? "", STDIN_LABEL, void 0, opts.as);
-    set.references.push(...referencesOf(input));
-    read7(input, readers, set);
+    pageFacts(input, set, opts.onPage);
+    read8(input, readers, set);
   }
   for (const { path, written } of run.manifests) {
     let content;
@@ -3020,8 +3392,12 @@ async function loadTermSet(opts) {
       const source = run.configSource ?? "manni.config.yaml";
       throw new TermError(`${source}: term.manifests "${written}" does not exist.`);
     }
+    if (isSkos(path)) {
+      read8(await skosInput(content, path, path), readers, set);
+      continue;
+    }
     const isTbx = extname(path).toLowerCase() === TBX_EXTENSION;
-    read7(isTbx ? tbxInput(content, path, path) : manifestInput(content, path, path), readers, set);
+    read8(isTbx ? tbxInput(content, path, path) : manifestInput(content, path, path), readers, set);
   }
   if (set.terms.length === 0 && !allowEmpty) {
     throw new TermError(
@@ -3059,7 +3435,8 @@ async function loadSet(run, opts) {
     ...opts.stdin === void 0 ? {} : { stdin: opts.stdin },
     ...opts.as === void 0 ? {} : { as: opts.as },
     ...opts.onNotice === void 0 ? {} : { onNotice: opts.onNotice },
-    ...opts.readers === void 0 ? {} : { readers: opts.readers }
+    ...opts.readers === void 0 ? {} : { readers: opts.readers },
+    ...opts.onPage === void 0 ? {} : { onPage: opts.onPage }
   });
   for (const message of set.notices) opts.onNotice?.(message);
   return set;
@@ -3092,19 +3469,17 @@ function plural(n, one, many = `${one}s`) {
 export {
   TermError,
   TERM_FIELDS,
+  TERM_MATCH_FIELDS,
   TERM_AUX_FIELDS,
   TERM_DESIGNATION_FIELDS,
   TERM_WRITE_FORMATS,
   TERM_RULES,
   DEFAULT_TERM_BASELINE_PATH,
   DEFAULT_ABSTRACT_MAX_LENGTH,
+  DEFAULT_FILL_CONFIDENCE,
+  DEFAULT_FILL_CACHE_DIR,
+  DEFAULT_CRAWL_MIN_PAGES,
   resolveTermRun,
-  DEFAULT_LANGUAGE,
-  languageOf,
-  languageKey,
-  isMultilingual,
-  droppedFields,
-  requireShape,
   xmlText,
   xmlAttribute,
   sharedLanguage,
@@ -3119,8 +3494,17 @@ export {
   htmlDlEntry,
   ditaEntry,
   docbookEntry,
+  slugOf,
+  SKOS,
+  SKOS_PROPERTIES,
   conceptGroups,
   mergeFirst,
+  DEFAULT_LANGUAGE,
+  languageOf,
+  languageKey,
+  isMultilingual,
+  droppedFields,
+  requireShape,
   TBX_V3_NAMESPACE,
   tbxSourceOf,
   lf,
@@ -3138,4 +3522,4 @@ export {
   valeConfigFor,
   plural
 };
-//# sourceMappingURL=chunk-J6IDQGJL.js.map
+//# sourceMappingURL=chunk-FKAZUZQU.js.map