@hawkeyexl/manni 4.3.1 → 4.4.0

package/dist/chunk-M2JCK5F6.js

@@ -0,0 +1,805 @@
+#!/usr/bin/env node
+import {
+  PROVIDERS_KEY,
+  assertKnownProvider,
+  findConfigFileSync,
+  parseCollections,
+  parseProviders,
+  readConfigFileSync
+} from "./chunk-Q35YIDBV.js";
+import {
+  ToolError,
+  errorMessage
+} from "./chunk-G3T47CFV.js";
+
+// src/graph/types.ts
+var GraphError = class extends ToolError {
+  constructor(message) {
+    super(message);
+    this.name = "GraphError";
+  }
+};
+
+// src/graph/core/iri.ts
+import { slug as githubSlug } from "github-slugger";
+var DEFAULT_BASE_IRI = "urn:manni:graph:";
+function resolveBaseIri(base) {
+  if (!base) return DEFAULT_BASE_IRI;
+  if (base.endsWith("/") || base.endsWith(":")) return base;
+  return `${base}/`;
+}
+function normalizeDocPath(p) {
+  let out = p.replace(/\\/g, "/");
+  while (out.startsWith("./")) out = out.slice(2);
+  return out;
+}
+function encodeSegment(segment) {
+  return encodeURIComponent(segment).replace(
+    /[!'()*]/g,
+    (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+var STDIN_PATH = "<stdin>";
+function mintDocIri(base, relPath) {
+  if (relPath === STDIN_PATH) return `${base}stdin`;
+  const path = normalizeDocPath(relPath).split("/").map(encodeSegment).join("/");
+  return `${base}doc/${path}`;
+}
+function mintSectionIri(docIri, slugValue) {
+  return `${docIri}#${slugValue}`;
+}
+function conceptSlug(label) {
+  return githubSlug(label);
+}
+function mintConceptIri(base, label) {
+  return `${base}concept/${encodeSegment(conceptSlug(label))}`;
+}
+function mintProductIri(base, label) {
+  return `${base}product/${encodeSegment(conceptSlug(label))}`;
+}
+function mintSchemeIri(base) {
+  return `${base}scheme`;
+}
+function mintAgentIri(base, kind, name) {
+  return `${base}agent/${kind}/${encodeSegment(conceptSlug(name))}`;
+}
+function mintGraphIri(base) {
+  return `${base}graph`;
+}
+function mintBuildActivityIri(base) {
+  return `${base}activity/build`;
+}
+
+// src/graph/core/config.ts
+import { dirname, resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { Ajv2020 } from "ajv/dist/2020.js";
+
+// src/graph/core/config-schema.json
+var config_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "manni:graph:config",
+  title: "manni graph configuration",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    provider: {
+      type: "string",
+      minLength: 1,
+      description: "Which provider `manni graph fill` sends pages to: auto | anthropic | openai | claude-cli | llama-cpp. Unset, the family's top-level providers.provider decides, then auto, detected exactly as manni meta fill detects: an Anthropic key, then an OpenAI key, then the Claude CLI, then a local model. --provider wins over it, and --local overrides both. Connection settings live in the family's top-level providers: map."
+    },
+    model: {
+      type: "string",
+      minLength: 1,
+      description: "The model, within the provider named beside it. A model is carried only to the provider its own level names: a differing --provider or providers.provider takes its own default instead. With no provider here, it goes to whichever provider is in force, which must not be auto, because a model name does not say which provider owns it. Unset (the default) takes the provider's default model from the inference library; manni pins none. --model wins over it. This is not `embed.model`, which is a local embedding model id."
+    },
+    baseIri: {
+      type: "string",
+      minLength: 1
+    },
+    out: {
+      type: "string",
+      minLength: 1
+    },
+    routes: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["root"],
+        properties: {
+          basePath: {
+            type: "string"
+          },
+          root: {
+            type: "string"
+          },
+          extensions: {
+            type: "array",
+            items: {
+              type: "string",
+              pattern: "^\\."
+            }
+          },
+          language: {
+            type: "string",
+            pattern: "^[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}))*$"
+          },
+          indexFiles: {
+            type: "array",
+            items: {
+              type: "string",
+              minLength: 1
+            }
+          }
+        }
+      }
+    },
+    build: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        derive: {
+          type: "array",
+          uniqueItems: true,
+          items: {
+            enum: [
+              "frontmatter",
+              "sections",
+              "links",
+              "tags",
+              "images",
+              "code",
+              "provenance"
+            ]
+          }
+        }
+      }
+    },
+    check: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        shapes: {
+          type: "array",
+          items: {
+            type: "string",
+            minLength: 1
+          }
+        }
+      }
+    },
+    provenance: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        qualified: {
+          type: "boolean"
+        }
+      }
+    },
+    stats: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        coverageThreshold: {
+          anyOf: [
+            {
+              type: "number",
+              minimum: 0,
+              maximum: 100
+            },
+            {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                title: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                description: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                creator: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                created: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                modified: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                subject: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                label: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                language: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                type: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                "applies-to": {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                "about-product-lifecycle": {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                },
+                "about-product-aspect": {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 100
+                }
+              }
+            }
+          ]
+        }
+      }
+    },
+    fill: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        temperature: {
+          type: "number",
+          minimum: 0,
+          maximum: 2
+        },
+        maxTurns: {
+          type: ["integer", "null"],
+          minimum: 1,
+          description: "Stop after this many inference calls. One page is one turn, and a cached proposal spends none. Null (the default) is unbounded. Replaces the maxCostUsd ceiling, which read as zero for every model outside the library's price table \u2014 see graph ADR 01027 and docevals ADR 01019."
+        },
+        cacheDir: {
+          type: "string",
+          minLength: 1
+        },
+        confidenceThreshold: {
+          type: "number",
+          minimum: 0,
+          maximum: 1,
+          description: "Minimum model self-confidence (0..1) to write a proposed field; below it the field is reported and not written. Default 0.7. `--confidence` wins over it."
+        },
+        writeProvenance: {
+          type: "boolean"
+        },
+        validateGraph: {
+          type: "boolean"
+        },
+        fields: {
+          type: "array",
+          uniqueItems: true,
+          items: {
+            enum: [
+              "label",
+              "alt-labels",
+              "broader",
+              "narrower",
+              "related-concepts",
+              "concepts",
+              "type",
+              "applies-to",
+              "about-product-lifecycle",
+              "about-product-aspect",
+              "not-applicable-to",
+              "not-about-product-aspect"
+            ]
+          }
+        },
+        sections: {
+          type: "boolean"
+        }
+      }
+    },
+    embed: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        model: {
+          type: "string",
+          minLength: 1
+        },
+        dtype: {
+          type: "string",
+          minLength: 1
+        },
+        out: {
+          type: "string",
+          minLength: 1
+        },
+        cacheDir: {
+          type: "string",
+          minLength: 1
+        },
+        byLanguage: {
+          type: "object",
+          additionalProperties: false,
+          patternProperties: {
+            "^[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}))*$": {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                model: {
+                  type: "string",
+                  minLength: 1
+                },
+                dtype: {
+                  type: "string",
+                  minLength: 1
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    export: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        iirds: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            title: {
+              type: "string",
+              minLength: 1
+            },
+            creator: {
+              type: "string",
+              minLength: 1
+            },
+            version: {
+              enum: ["1.2", "1.3"]
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/graph/core/vocab.ts
+var NS = {
+  dcterms: "http://purl.org/dc/terms/",
+  foaf: "http://xmlns.com/foaf/0.1/",
+  graph: "https://hawkeyexl.github.io/manni/graph/ns#",
+  iirds: "http://iirds.tekom.de/iirds#",
+  iirdsSft: "http://iirds.tekom.de/iirds/domain/software#",
+  prov: "http://www.w3.org/ns/prov#",
+  rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+  schema: "https://schema.org/",
+  skos: "http://www.w3.org/2004/02/skos/core#",
+  xsd: "http://www.w3.org/2001/XMLSchema#"
+};
+var PREFIXES = Object.entries(NS).sort(([a], [b]) => a < b ? -1 : 1);
+var RDF_TYPE = `${NS.rdf}type`;
+var ROLE = {
+  author: `${NS.graph}authorRole`,
+  generator: `${NS.graph}generatorRole`,
+  tool: `${NS.graph}toolRole`
+};
+
+// src/graph/core/iirds.ts
+var IIRDS_HAS_TOPIC_TYPE = `${NS.iirds}has-topic-type`;
+var IIRDS_RELATES_TO_PRODUCT_VARIANT = `${NS.iirds}relates-to-product-variant`;
+var IIRDS_RELATES_TO_LIFECYCLE_PHASE = `${NS.iirds}relates-to-product-lifecycle-phase`;
+var IIRDS_HAS_SUBJECT = `${NS.iirds}has-subject`;
+var IIRDS_PRODUCT_VARIANT = `${NS.iirds}ProductVariant`;
+var IIRDS_PACKAGE = `${NS.iirds}Package`;
+var IIRDS_IIRDS_VERSION = `${NS.iirds}iiRDSVersion`;
+var IIRDS_TOPIC = `${NS.iirds}Topic`;
+var IIRDS_IS_PART_OF_PACKAGE = `${NS.iirds}is-part-of-package`;
+var IIRDS_HAS_RENDITION = `${NS.iirds}has-rendition`;
+var IIRDS_RENDITION = `${NS.iirds}Rendition`;
+var IIRDS_SOURCE = `${NS.iirds}source`;
+var IIRDS_FORMAT = `${NS.iirds}format`;
+var IIRDS_TITLE = `${NS.iirds}title`;
+var IIRDS_LANGUAGE = `${NS.iirds}language`;
+var IIRDS_PARTY = `${NS.iirds}Party`;
+var IIRDS_HAS_PARTY_ROLE = `${NS.iirds}has-party-role`;
+var IIRDS_CREATOR = `${NS.iirds}Creator`;
+var IIRDS_RELATES_TO_PARTY = `${NS.iirds}relates-to-party`;
+var IIRDS_RELATES_TO_VCARD = `${NS.iirds}relates-to-vcard`;
+var VCARD_NS = "http://www.w3.org/2006/vcard/ns#";
+var VCARD_ORGANIZATION = `${VCARD_NS}Organization`;
+var VCARD_ORGANIZATION_NAME = `${VCARD_NS}organization-name`;
+var GRAPH_NOT_APPLICABLE_TO_VARIANT = `${NS.graph}notApplicableToVariant`;
+var GRAPH_NOT_SOFTWARE_SUBJECT = `${NS.graph}notSoftwareSubject`;
+var PAGE_TYPE_TO_TOPIC_TYPE = {
+  "how-to": "task",
+  tutorial: "learning",
+  explanation: "concept",
+  reference: "reference",
+  troubleshooting: "troubleshooting"
+};
+var TOPIC_TYPE_IRIS = {
+  task: `${NS.iirds}GenericTask`,
+  concept: `${NS.iirds}GenericConcept`,
+  reference: `${NS.iirds}GenericReference`,
+  learning: `${NS.iirds}GenericLearning`,
+  troubleshooting: `${NS.iirds}GenericTroubleshooting`,
+  form: `${NS.iirds}GenericForm`
+};
+var SOFTWARE_LIFECYCLE_IRIS = {
+  administration: `${NS.iirdsSft}Administration`,
+  customization: `${NS.iirdsSft}Customization`,
+  update: `${NS.iirdsSft}Update`,
+  deployment: `${NS.iirdsSft}Deployment`,
+  integration: `${NS.iirdsSft}Integration`,
+  deinstallation: `${NS.iirdsSft}Deinstallation`
+};
+var SOFTWARE_SUBJECT_IRIS = {
+  architecture: `${NS.iirdsSft}Architecture`,
+  interface: `${NS.iirdsSft}Interface`,
+  "system-requirement": `${NS.iirdsSft}SystemRequirement`
+};
+
+// src/graph/core/coverage.ts
+var COVERAGE_FIELDS = [
+  { field: "title", iri: `${NS.dcterms}title` },
+  { field: "description", iri: `${NS.dcterms}description` },
+  { field: "creator", iri: `${NS.dcterms}creator` },
+  { field: "created", iri: `${NS.dcterms}created` },
+  { field: "modified", iri: `${NS.dcterms}modified` },
+  { field: "subject", iri: `${NS.dcterms}subject` },
+  { field: "label", iri: `${NS.foaf}primaryTopic` },
+  // Dropped by ADR 01011 as "near-universally 0% noise", which was true on the
+  // monolingual corpora it was measured against and false the moment language
+  // means something. Restored by ADR 01037, which made it a scope dimension:
+  // an unlabelled document in a translated corpus cannot be filtered, indexed
+  // per locale, or counted against the right audience.
+  { field: "language", iri: `${NS.dcterms}language` },
+  // The iiRDS typing added in Phases 2–4. Coverage predates all of it, so the
+  // measure of "what a graph-side consumer can see" was silent about the
+  // vocabulary the project spent four phases adding (ADR 01029).
+  { field: "type", iri: IIRDS_HAS_TOPIC_TYPE },
+  { field: "applies-to", iri: IIRDS_RELATES_TO_PRODUCT_VARIANT },
+  {
+    field: "about-product-lifecycle",
+    iri: IIRDS_RELATES_TO_LIFECYCLE_PHASE
+  },
+  { field: "about-product-aspect", iri: IIRDS_HAS_SUBJECT }
+];
+var SECTION_FIELD_NAMES = [
+  "type",
+  "applies-to",
+  "about-product-lifecycle",
+  "about-product-aspect",
+  "subject"
+];
+var SECTION_COVERAGE_FIELDS = SECTION_FIELD_NAMES.map((name) => {
+  const field = COVERAGE_FIELDS.find((f) => f.field === name);
+  if (field === void 0) {
+    throw new Error(
+      `SECTION_FIELD_NAMES names ${name}, which COVERAGE_FIELDS does not define`
+    );
+  }
+  return field;
+});
+var COVERAGE_FIELD_NAMES = COVERAGE_FIELDS.map(
+  (f) => f.field
+);
+
+// src/graph/embed/types.ts
+var DEFAULT_PROFILE = {
+  id: "onnx-community/granite-embedding-small-english-r2-ONNX",
+  note: "Default. 384-d, 8192-token context so sections are never truncated; no prefixes."
+};
+var MODEL_PROFILES = [
+  DEFAULT_PROFILE,
+  {
+    id: "Xenova/gte-small",
+    note: "Lighter (~34 MB). 384-d, 512-token context; no prefixes."
+  },
+  {
+    id: "Xenova/bge-small-en-v1.5",
+    queryPrefix: "Represent this sentence for searching relevant passages: ",
+    note: "384-d. Needs a query prefix \u2014 applied automatically here, since omitting it degrades retrieval silently."
+  },
+  {
+    id: "Xenova/all-MiniLM-L6-v2",
+    note: "Smallest (~23 MB) but truncates at 256 wordpieces (~190 words), so long sections lose their tail."
+  }
+];
+var DEFAULT_MODEL = DEFAULT_PROFILE.id;
+function profileFor(id) {
+  return MODEL_PROFILES.find((p) => p.id === id) ?? { id };
+}
+function withPrefix(profile, role, text) {
+  const prefix = role === "query" ? profile.queryPrefix : profile.passagePrefix;
+  return prefix ? `${prefix}${text}` : text;
+}
+
+// src/graph/core/config.ts
+var ALL_FILL_FIELDS = [
+  "label",
+  "alt-labels",
+  "broader",
+  "narrower",
+  "related-concepts",
+  "concepts",
+  "type",
+  "applies-to",
+  "about-product-lifecycle",
+  "about-product-aspect",
+  "not-applicable-to",
+  "not-about-product-aspect"
+];
+var DEFAULT_CONFIG_FILENAME = "manni.config.yaml";
+var CONFIG_SECTION = "graph";
+var COLLECTIONS_KEY = "collections";
+var CONFIG_REF = "https://hawkeyexl.github.io/manni/meta/reference/configuration/";
+var MOVED_KEYS = ["inputs", "exclude"];
+var ALL_DERIVE_SOURCES = [
+  "frontmatter",
+  "sections",
+  "links",
+  "tags",
+  "images",
+  "code",
+  "provenance"
+];
+var DEFAULT_LINK_EXTENSIONS = [".md", ".mdx", ".markdown"];
+var DEFAULT_INDEX_FILES = ["index", "README"];
+function normalizeBasePath(basePath) {
+  let out = basePath.trim();
+  if (!out.startsWith("/")) out = `/${out}`;
+  out = out.replace(/\/+$/, "");
+  return out;
+}
+var ajv = new Ajv2020({ allErrors: true, allowUnionTypes: true });
+var validateConfig = ajv.compile(config_schema_default);
+function configErrorLine(e) {
+  const extra = e.keyword === "additionalProperties" ? e.params.additionalProperty : void 0;
+  const where = `/${CONFIG_SECTION}${e.instancePath}`;
+  return extra === void 0 ? `  ${where}: ${e.message ?? "is invalid"}` : `  ${where}: unknown key "${extra}"`;
+}
+function resolveCoverageThreshold(raw) {
+  if (raw == null) return {};
+  if (typeof raw === "number")
+    return Object.fromEntries(COVERAGE_FIELD_NAMES.map((f) => [f, raw]));
+  return { ...raw };
+}
+function parseConfig(text, configPath) {
+  let raw;
+  try {
+    raw = parseYaml(text);
+  } catch (e) {
+    throw new GraphError(
+      `Invalid YAML in ${configPath}: ${errorMessage(e)}`
+    );
+  }
+  if (raw == null) return parseConfigSection(null, configPath);
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new GraphError(`Invalid config in ${configPath}: root must be an object`);
+  }
+  const doc = raw;
+  const wrapped = Object.hasOwn(doc, CONFIG_SECTION);
+  const toError = (message) => new GraphError(message);
+  const collections = Object.hasOwn(doc, COLLECTIONS_KEY) ? parseCollections(doc[COLLECTIONS_KEY], configPath, toError) : [];
+  const providers = Object.hasOwn(doc, PROVIDERS_KEY) ? parseProviders(
+    doc[PROVIDERS_KEY],
+    configPath,
+    dirname(resolve(configPath)),
+    toError
+  ) : {};
+  return parseConfigSection(wrapped ? doc[CONFIG_SECTION] : doc, configPath, {
+    source: configPath,
+    collections,
+    providers
+  });
+}
+function parseConfigSection(raw, configPath, file = { source: configPath, collections: [] }) {
+  if (raw == null) raw = {};
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new GraphError(
+      `Invalid config in ${configPath}: root must be an object`
+    );
+  }
+  for (const key of MOVED_KEYS) {
+    if (Object.hasOwn(raw, key)) {
+      throw new GraphError(
+        `${file.source}: "${key}" is no longer a graph key. Document sets are declared once for every tool, under a top-level collections: list. See ${CONFIG_REF}#${COLLECTIONS_KEY}`
+      );
+    }
+  }
+  if (!validateConfig(raw)) {
+    const details = (validateConfig.errors ?? []).map((e) => configErrorLine(e)).join("\n");
+    throw new GraphError(`Invalid config in ${configPath}:
+${details}`);
+  }
+  const r = raw;
+  const abs = resolve(configPath);
+  const dir = dirname(abs);
+  const provider = r.provider ?? null;
+  if (provider !== null) {
+    assertKnownProvider(provider, (message) => new GraphError(message));
+  }
+  return {
+    collections: file.collections,
+    configSource: file.source,
+    provider,
+    model: r.model ?? null,
+    providers: file.providers ?? {},
+    baseIri: resolveBaseIri(r.baseIri),
+    out: r.out ?? "graph/graph.ttl",
+    routes: (r.routes ?? []).map((m) => ({
+      basePath: normalizeBasePath(m.basePath ?? "/"),
+      root: m.root.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, ""),
+      extensions: m.extensions ?? [...DEFAULT_LINK_EXTENSIONS],
+      indexFiles: m.indexFiles ?? [...DEFAULT_INDEX_FILES],
+      ...m.language === void 0 ? {} : { language: m.language }
+    })),
+    build: {
+      derive: r.build?.derive ?? [...ALL_DERIVE_SOURCES]
+    },
+    check: {
+      // Empty means: use the shapes bundled with manni (see bundledShapesPath).
+      shapes: r.check?.shapes ?? []
+    },
+    provenance: {
+      qualified: r.provenance?.qualified ?? true
+    },
+    stats: {
+      coverageThreshold: resolveCoverageThreshold(r.stats?.coverageThreshold)
+    },
+    fill: {
+      temperature: r.fill?.temperature ?? 0,
+      maxTurns: r.fill?.maxTurns ?? null,
+      cacheDir: r.fill?.cacheDir ?? ".manni/graph/cache",
+      fields: r.fill?.fields ?? [...ALL_FILL_FIELDS],
+      confidenceThreshold: r.fill?.confidenceThreshold ?? 0.7,
+      writeProvenance: r.fill?.writeProvenance ?? true,
+      validateGraph: r.fill?.validateGraph ?? true,
+      sections: r.fill?.sections ?? false
+    },
+    embed: {
+      model: r.embed?.model ?? DEFAULT_MODEL,
+      dtype: r.embed?.dtype ?? "q8",
+      out: r.embed?.out,
+      cacheDir: r.embed?.cacheDir ?? ".manni/graph/embed-cache",
+      byLanguage: r.embed?.byLanguage ?? {}
+    },
+    export: {
+      iirds: {
+        title: r.export?.iirds?.title,
+        creator: r.export?.iirds?.creator,
+        version: r.export?.iirds?.version ?? "1.3"
+      }
+    },
+    configPath: abs,
+    configDir: dir
+  };
+}
+var CONFIG_FILE = {
+  section: CONFIG_SECTION,
+  // The tool was `dockg` before it joined the family (proposal 0051 §7), but
+  // it published no config file under that old name, so — like cite, a11y and
+  // docevals — there is no pre-family filename to read (proposal 0051 §2).
+  legacyNames: [],
+  toError: (message) => new GraphError(message)
+};
+function loadConfig(path, cwd = process.cwd()) {
+  const file = path ? readConfigFileSync(path, cwd, CONFIG_FILE) : findConfigFileSync(cwd, CONFIG_FILE);
+  if (file === null) return defaultConfig(cwd);
+  return parseConfigSection(file.value, file.path, {
+    source: file.source,
+    collections: file.collections,
+    ...file.providers === void 0 ? {} : { providers: file.providers }
+  });
+}
+function defaultConfig(cwd = process.cwd()) {
+  return {
+    ...parseConfigSection(null, resolve(cwd, DEFAULT_CONFIG_FILENAME)),
+    configSource: null
+  };
+}
+function loadRunConfig(opts, cwd = process.cwd()) {
+  assertCollectionWithoutPaths(opts.collection, opts.paths);
+  return opts.noConfig ? defaultConfig(cwd) : loadConfig(opts.configPath, cwd);
+}
+function assertCollectionWithoutPaths(collection, paths) {
+  if ((collection ?? []).length > 0 && (paths ?? []).length > 0) {
+    throw new GraphError(
+      "--collection selects a configured collection; it cannot be combined with paths."
+    );
+  }
+}
+
+// src/graph/core/sort.ts
+function byCodeUnit(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+export {
+  GraphError,
+  resolveBaseIri,
+  normalizeDocPath,
+  encodeSegment,
+  STDIN_PATH,
+  mintDocIri,
+  mintSectionIri,
+  conceptSlug,
+  mintConceptIri,
+  mintProductIri,
+  mintSchemeIri,
+  mintAgentIri,
+  mintGraphIri,
+  mintBuildActivityIri,
+  NS,
+  PREFIXES,
+  RDF_TYPE,
+  ROLE,
+  IIRDS_HAS_TOPIC_TYPE,
+  IIRDS_RELATES_TO_PRODUCT_VARIANT,
+  IIRDS_RELATES_TO_LIFECYCLE_PHASE,
+  IIRDS_HAS_SUBJECT,
+  IIRDS_PRODUCT_VARIANT,
+  IIRDS_PACKAGE,
+  IIRDS_IIRDS_VERSION,
+  IIRDS_TOPIC,
+  IIRDS_IS_PART_OF_PACKAGE,
+  IIRDS_HAS_RENDITION,
+  IIRDS_RENDITION,
+  IIRDS_SOURCE,
+  IIRDS_FORMAT,
+  IIRDS_TITLE,
+  IIRDS_LANGUAGE,
+  IIRDS_PARTY,
+  IIRDS_HAS_PARTY_ROLE,
+  IIRDS_CREATOR,
+  IIRDS_RELATES_TO_PARTY,
+  IIRDS_RELATES_TO_VCARD,
+  VCARD_NS,
+  VCARD_ORGANIZATION,
+  VCARD_ORGANIZATION_NAME,
+  GRAPH_NOT_APPLICABLE_TO_VARIANT,
+  GRAPH_NOT_SOFTWARE_SUBJECT,
+  PAGE_TYPE_TO_TOPIC_TYPE,
+  TOPIC_TYPE_IRIS,
+  SOFTWARE_LIFECYCLE_IRIS,
+  SOFTWARE_SUBJECT_IRIS,
+  COVERAGE_FIELDS,
+  SECTION_COVERAGE_FIELDS,
+  COVERAGE_FIELD_NAMES,
+  MODEL_PROFILES,
+  DEFAULT_MODEL,
+  profileFor,
+  withPrefix,
+  ALL_FILL_FIELDS,
+  DEFAULT_CONFIG_FILENAME,
+  CONFIG_SECTION,
+  DEFAULT_LINK_EXTENSIONS,
+  DEFAULT_INDEX_FILES,
+  parseConfig,
+  loadConfig,
+  defaultConfig,
+  loadRunConfig,
+  assertCollectionWithoutPaths,
+  byCodeUnit
+};
+//# sourceMappingURL=chunk-M2JCK5F6.js.map