@glossarist/concept-browser 0.7.135 → 0.7.136

package/data/concept-model/SOURCE.json

@@ -1,6 +1,5 @@
 {
   "repo": "glossarist/concept-model",
-  "ref": "v3.1.0",
-  "commit": "49e4dc40dca52ebd783c92a9ff534a62439b236e",
-  "syncedAt": "2026-07-05T15:10:00Z"
+  "ref": "v3.1.1",
+  "syncedAt": "2026-09-17T11:21:06.256Z"
 }

package/data/concept-model/glossarist.context.jsonld

@@ -34,6 +34,9 @@
     "ConceptRef":          "gloss:ConceptRef",
     "Reference":           "gloss:Reference",
     "RelatedConcept":      "gloss:RelatedConcept",
+    "PartitiveHyperedge":      "gloss:PartitiveHyperedge",
+    "PartitiveEnumeration":    "gloss:PartitiveEnumeration",
+    "PluralityMarker":         "gloss:PluralityMarker",
     "DesignationRelationship": "gloss:DesignationRelationship",
     "ConceptDate":         "gloss:ConceptDate",
     "NonVerbalRepresentation": "gloss:NonVerbalRepresentation",
@@ -54,6 +57,7 @@
     "isLocalizationOf":    { "@id": "gloss:isLocalizationOf", "@type": "@id" },
     "hasStatus":           { "@id": "gloss:hasStatus",     "@type": "@id" },
     "hasDomain":           { "@id": "gloss:hasDomain",     "@type": "@id" },
+    "tag":                 { "@id": "gloss:tag",           "@type": "xsd:string" },
     "hasRelatedConcept":   { "@id": "gloss:hasRelatedConcept", "@type": "@id" },
     "hasDate":             { "@id": "gloss:hasDate",       "@type": "@id" },
     "hasSource":           { "@id": "gloss:hasSource",     "@type": "@id" },
@@ -112,8 +116,18 @@
     "relationshipType":    { "@id": "gloss:relationshipType", "@type": "@id" },
     "relationshipContent": { "@id": "gloss:relationshipContent", "@type": "xsd:string" },
     "relationshipRef":     { "@id": "gloss:relationshipRef", "@type": "@id" },
+    "relatedConceptBroader":  { "@id": "gloss:relatedConceptBroader",  "@type": "@id" },
+    "relatedConceptNarrower": { "@id": "gloss:relatedConceptNarrower", "@type": "@id" },
+
+    "hasPartitiveHyperedge": { "@id": "gloss:hasPartitiveHyperedge", "@type": "@id" },
+    "comprehensive":         { "@id": "gloss:comprehensive",         "@type": "@id" },
+    "hasPart":               { "@id": "gloss:hasPart",               "@type": "@id" },
+    "enumeration":           { "@id": "gloss:enumeration",           "@type": "@id" },
+    "hasPluralityMarker":    { "@id": "gloss:hasPluralityMarker",    "@type": "@id" },
+    "hyperedgeContent":      { "@id": "gloss:hyperedgeContent",      "@type": "xsd:string" },
 
     "refType":             { "@id": "gloss:refType",       "@type": "xsd:string" },
+    "source":              { "@id": "gloss:source",        "@type": "xsd:string" },
     "urn":                 { "@id": "gloss:urn",           "@type": "xsd:anyURI" },
     "term":                { "@id": "gloss:term",          "@type": "xsd:string" },
     "refId":               { "@id": "gloss:refId",         "@type": "xsd:string" },
@@ -125,6 +139,7 @@
     "sourceId":            { "@id": "gloss:sourceId",      "@type": "xsd:string" },
     "sourceOrigin":        { "@id": "gloss:sourceOrigin",  "@type": "@id" },
     "modification":        { "@id": "gloss:modification",  "@type": "xsd:string" },
+    "sourcedFrom":         { "@id": "gloss:sourcedFrom",   "@type": "@id" },
 
     "hasCitationRef":      { "@id": "gloss:hasCitationRef", "@type": "@id" },
     "hasCitationLocality": { "@id": "gloss:hasCitationLocality", "@type": "@id" },

package/data/concept-model/glossarist.ttl

@@ -193,6 +193,44 @@ gloss:RelatedConcept a owl:Class ;
   rdfs:label "Related Concept"@en ;
   rdfs:comment """
     A concept with a typed relationship (deprecates, broader, equivalent, etc.).
+    Binary: one source concept, one target concept via a ConceptRef.
+    For one-to-many partitive decompositions with plurality markers or
+    open/closed enumeration, use gloss:PartitiveHyperedge.
+  """@en .
+
+gloss:PartitiveHyperedge a owl:Class ;
+  rdfs:label "Partitive Hyperedge"@en ;
+  rdfs:comment """
+    A one-to-many partitive decomposition: one comprehensive (whole)
+    concept related to one or more parts as a SINGLE relationship.
+
+    Used when the source diagram depicts a partitive rake whose
+    membership or notation is jointly significant — i.e. the
+    decomposition cannot be faithfully split into binary
+    RelatedConcept edges without losing invariants (which
+    comprehensive a part belongs to, the plurality of the rake,
+    the completeness of the enumeration).
+
+    Independent of gloss:hasRelatedConcept. A concept may have both
+    binary related entries and partitive hyperedges.
+  """@en .
+
+gloss:PartitiveEnumeration a owl:Class ;
+  rdfs:label "Partitive Enumeration"@en ;
+  rdfs:comment """
+    Whether the parts array of a PartitiveHyperedge constitutes the
+    COMPLETE decomposition of the comprehensive (closed) or only a
+    PARTIAL one (open). Orthogonal to PluralityMarker.
+  """@en .
+
+gloss:PluralityMarker a owl:Class ;
+  rdfs:label "Plurality Marker"@en ;
+  rdfs:comment """
+    Diagram notation flags that travel with a PartitiveHyperedge so
+    the rendering layer can reproduce the source diagram's notation
+    (close-set double line, dashed line). Originates from VIM
+    (International Vocabulary of Metrology) concept-relationship
+    diagrams. Orthogonal to PartitiveEnumeration.
   """@en .
 
 gloss:DesignationRelationship a owl:Class ;
@@ -312,7 +350,37 @@ gloss:hasRelatedConcept a owl:ObjectProperty ;
   ] ;
   rdfs:range gloss:RelatedConcept ;
   rdfs:label "has related concept"@en ;
-  rdfs:comment "DATA: Typed semantic relationship — applicable at concept and localization levels."@en .
+  rdfs:comment "DATA: Typed binary semantic relationship — applicable at concept and localization levels."@en .
+
+gloss:hasPartitiveHyperedge a owl:ObjectProperty ;
+  rdfs:domain gloss:Concept ;
+  rdfs:range gloss:PartitiveHyperedge ;
+  rdfs:label "has partitive hyperedge"@en ;
+  rdfs:comment "DATA: One-to-many partitive decomposition on a managed concept. Concept-level only — hyperedges are not localized."@en .
+
+gloss:comprehensive a owl:ObjectProperty ;
+  rdfs:domain gloss:PartitiveHyperedge ;
+  rdfs:range gloss:ConceptRef ;
+  rdfs:label "comprehensive"@en ;
+  rdfs:comment "The whole concept that owns the parts in a partitive hyperedge. Exactly one per hyperedge."@en .
+
+gloss:hasPart a owl:ObjectProperty ;
+  rdfs:domain gloss:PartitiveHyperedge ;
+  rdfs:range gloss:ConceptRef ;
+  rdfs:label "has part"@en ;
+  rdfs:comment "A partitive member of a hyperedge. A hyperedge has one or more parts."@en .
+
+gloss:enumeration a owl:ObjectProperty ;
+  rdfs:domain gloss:PartitiveHyperedge ;
+  rdfs:range gloss:PartitiveEnumeration ;
+  rdfs:label "enumeration"@en ;
+  rdfs:comment "Whether the encoded parts constitute a complete (closed) or partial (open) decomposition."@en .
+
+gloss:hasPluralityMarker a owl:ObjectProperty ;
+  rdfs:domain gloss:PartitiveHyperedge ;
+  rdfs:range gloss:PluralityMarker ;
+  rdfs:label "has plurality marker"@en ;
+  rdfs:comment "Diagram notation flag on a hyperedge (double for close-set double line, dashed for uncertainty)."@en .
 
 gloss:hasDate a owl:ObjectProperty ;
   rdfs:domain [
@@ -632,6 +700,12 @@ gloss:relationshipContent a owl:DatatypeProperty ;
   rdfs:label "relationship content"@en ;
   rdfs:comment "Free-text description of the relationship."@en .
 
+gloss:hyperedgeContent a owl:DatatypeProperty ;
+  rdfs:domain gloss:PartitiveHyperedge ;
+  rdfs:range xsd:string ;
+  rdfs:label "hyperedge content"@en ;
+  rdfs:comment "Free-form text associated with a PartitiveHyperedge, e.g. a diagram caption or label."@en .
+
 gloss:relationshipRef a owl:ObjectProperty ;
   rdfs:domain gloss:RelatedConcept ;
   rdfs:range gloss:ConceptRef ;
@@ -720,6 +794,17 @@ gloss:modification a owl:DatatypeProperty ;
   rdfs:label "modification"@en ;
   rdfs:comment "How the concept was modified from the source."@en .
 
+gloss:sourcedFrom a owl:ObjectProperty ;
+  rdfs:domain gloss:ConceptSource ;
+  rdfs:range gloss:Citation ;
+  rdfs:label "sourced from"@en ;
+  rdfs:comment """
+    Citations to the documents that this source was itself sourced
+    from. Only valid on lineage sources; authoritative sources are
+    terminal. When present, status and modification describe how
+    origin relates to these upstream sources.
+  """@en .
+
 # ── Citation resolution ────────────────────────────────────────────────────
 #
 # An inline `{{cite:id}}` mention in a concept's text

package/data/concept-model/shapes/glossarist.shacl.ttl

@@ -43,13 +43,17 @@ gloss:ConceptShape a sh:NodeShape ;
   sh:property [
     sh:path gloss:hasStatus ;
     sh:class skos:Concept ;
-    sh:valuesFrom <https://www.glossarist.org/ontologies/conceptstatus> ;
+    sh:valuesFrom <https://www.glossarist.org/ontologies/status> ;
     sh:maxCount 1 ;
   ] ;
   sh:property [
     sh:path gloss:hasRelatedConcept ;
     sh:class gloss:RelatedConcept ;
   ] ;
+  sh:property [
+    sh:path gloss:hasPartitiveHyperedge ;
+    sh:class gloss:PartitiveHyperedge ;
+  ] ;
   sh:property [
     sh:path gloss:hasDate ;
     sh:class gloss:ConceptDate ;
@@ -391,6 +395,24 @@ gloss:ConceptSourceShape a sh:NodeShape ;
     sh:path gloss:modification ;
     sh:datatype xsd:string ;
     sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path gloss:sourcedFrom ;
+    sh:class gloss:Citation ;
+  ] ;
+  sh:sparql [
+    sh:message "sourced_from is only allowed on sources of type lineage"@en ;
+    sh:select """
+      PREFIX gloss: <https://www.glossarist.org/ontologies/>
+      PREFIX srctype: <https://www.glossarist.org/ontologies/srctype/>
+      SELECT $this
+      WHERE {
+        $this gloss:sourcedFrom ?target .
+        FILTER NOT EXISTS {
+          $this gloss:sourceType srctype:lineage .
+        }
+      }
+    """ ;
   ] .
 
 gloss:ConceptDateShape a sh:NodeShape ;
@@ -699,6 +721,152 @@ gloss:RelatedConceptShape a sh:NodeShape ;
     sh:maxCount 1 ;
   ] .
 
+# ══════════════════════════════════════════════════════════════════════════
+# Partitive Hyperedge shapes
+# ══════════════════════════════════════════════════════════════════════════
+
+gloss:PartitiveHyperedgeShape a sh:NodeShape ;
+  sh:targetClass gloss:PartitiveHyperedge ;
+  sh:property [
+    sh:path gloss:comprehensive ;
+    sh:class gloss:ConceptRef ;
+    sh:minCount 1 ;
+    sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path gloss:hasPart ;
+    sh:class gloss:ConceptRef ;
+    sh:minCount 1 ;
+  ] ;
+  sh:property [
+    sh:path gloss:enumeration ;
+    sh:class skos:Concept ;
+    sh:valuesFrom <https://www.glossarist.org/ontologies/partitiveEnumeration> ;
+    sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path gloss:hasPluralityMarker ;
+    sh:class skos:Concept ;
+    sh:valuesFrom <https://www.glossarist.org/ontologies/pluralityMarker> ;
+  ] ;
+  sh:property [
+    sh:path gloss:hyperedgeContent ;
+    sh:datatype xsd:string ;
+    sh:maxCount 1 ;
+  ] .
+
+# Ownership invariant — soft (warning severity). A PartitiveHyperedge
+# is *conventionally* carried by its comprehensive's own concept entry:
+#   <concept/X> gloss:hasPartitiveHyperedge [
+#     gloss:comprehensive [ a gloss:ConceptRef ; gloss:ref-id "X" ]
+#   ] .
+#
+# Datasets in the wild may legitimately cross-reference (a concept
+# carries a hyperedge whose comprehensive points elsewhere — e.g. for
+# indexing). We do not forbid this; we warn so reviewers can confirm
+# the cross-reference is intentional.
+#
+# The SPARQL constraint matches when the carrying concept's URI-ending
+# identifier differs from the comprehensive ConceptRef's `gloss:id`
+# literal.
+gloss:PartitiveHyperedgeOwnershipShape a sh:NodeShape ;
+  sh:targetClass gloss:PartitiveHyperedge ;
+  sh:severity sh:Warning ;
+  sh:message "partitive_hyperedge is carried by a concept that is not its comprehensive — confirm the cross-reference is intentional."@en ;
+  sh:sparql [
+    a sh:SPARQLConstraint ;
+    sh:prefixes [
+      sh:declare [
+        sh:prefix "gloss" ;
+        sh:namespace "https://www.glossarist.org/ontologies/"^^xsd:anyURI ;
+      ] ;
+      sh:declare [
+        sh:prefix "xsd" ;
+        sh:namespace "http://www.w3.org/2001/XMLSchema#"^^xsd:anyURI ;
+      ] ;
+    ] ;
+    sh:select """
+      SELECT $this ?carryingConcept ?compRef
+      WHERE {
+        ?carryingConcept gloss:hasPartitiveHyperedge $this .
+        $this gloss:comprehensive ?compRef .
+        # Two encoding shapes exist:
+        #   (a) ?compRef is a gloss:ConceptRef node with gloss:conceptRefId
+        #   (b) ?compRef is a direct URI ending in /<concept_id>
+        # We bind ?compKey to whichever form is present, then compare
+        # against the URI suffix of the carrying concept.
+        OPTIONAL { ?compRef gloss:conceptRefId ?literalId . }
+        BIND(COALESCE(?literalId, STRAFTER(STR(?compRef), CONCAT(STR(?carryingConcept), "/"))) AS ?compKey)
+        FILTER (BOUND(?compKey) && !STRENDS(STR(?carryingConcept), CONCAT("/", ?compKey)))
+      }
+    """ ;
+  ] .
+
+# ── Enum scheme shapes ───────────────────────────────────────────────────
+# PartitiveEnumeration and PluralityMarker are modelled as owl:Class
+# but functionally are SKOS ConceptSchemes. The shape asserts the
+# scheme contract: every instance must be a skos:ConceptScheme.
+
+gloss:PartitiveEnumerationShape a sh:NodeShape ;
+  sh:targetClass gloss:PartitiveEnumeration ;
+  sh:class skos:ConceptScheme .
+
+gloss:PluralityMarkerShape a sh:NodeShape ;
+  sh:targetClass gloss:PluralityMarker ;
+  sh:class skos:ConceptScheme .
+
+# ── Non-verbal entity hierarchy ──────────────────────────────────────────
+# Abstract base + shared dataset-wide entity. Concrete shapes
+# (Figure, Table, Formula) live elsewhere in this file.
+
+gloss:NonVerbalEntityShape a sh:NodeShape ;
+  sh:targetClass gloss:NonVerbalEntity ;
+  sh:property [
+    sh:path gloss:caption ;
+    sh:datatype xsd:string ;
+    sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path gloss:altText ;
+    sh:datatype xsd:string ;
+    sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path gloss:description ;
+    sh:datatype xsd:string ;
+  ] ;
+  sh:property [
+    sh:path gloss:hasSource ;
+    sh:class gloss:ConceptSource ;
+  ] .
+
+gloss:SharedNonVerbalEntityShape a sh:NodeShape ;
+  sh:targetClass gloss:SharedNonVerbalEntity ;
+  sh:class gloss:NonVerbalEntity ;
+  sh:property [
+    sh:path gloss:role ;
+    sh:datatype xsd:string ;
+    sh:maxCount 1 ;
+  ] .
+
+gloss:FigureImageShape a sh:NodeShape ;
+  sh:targetClass gloss:FigureImage ;
+  sh:property [
+    sh:path gloss:src ;
+    sh:datatype xsd:string ;
+    sh:minCount 1 ;
+    sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path gloss:format ;
+    sh:datatype xsd:string ;
+    sh:maxCount 1 ;
+  ] ;
+  sh:property [
+    sh:path gloss:hasSubfigure ;
+    sh:class gloss:FigureImage ;
+  ] .
+
 gloss:GrammarInfoShape a sh:NodeShape ;
   sh:targetClass gloss:GrammarInfo ;
   sh:property [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.135",
+  "version": "0.7.136",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {
@@ -43,7 +43,7 @@
     "astro": "^7.0.7",
     "d3": "^7.9.0",
     "favicons": "^7.2.0",
-    "glossarist": "^0.4.56",
+    "glossarist": "^0.4.58",
     "js-yaml": "^4.1.0",
     "jszip": "^3.10.1",
     "n3": "^1.26.0",

package/scripts/__tests__/doctor.test.ts

@@ -55,24 +55,64 @@ describe('doctor — runDoctor on synthetic projects', () => {
 
   it('fails on missing datasets.yml', async () => {
     const { results } = await runDoctor(root);
-    const ymlCheck = results.find((r) => r.id === 'datasets-yml');
+    const ymlCheck = results.find((r) => r.id === 'datasets-registered');
     expect(ymlCheck.status).toBe('warn');
   });
 
   it('fails on malformed datasets.yml', async () => {
     writeFileSync(join(root, 'datasets.yml'), 'datasets: [this is broken');
     const { results, exitCode } = await runDoctor(root);
-    const ymlCheck = results.find((r) => r.id === 'datasets-yml');
+    const ymlCheck = results.find((r) => r.id === 'datasets-registered');
     expect(ymlCheck.status).toBe('fail');
     expect(exitCode).toBe(1);
   });
 
-  it('passes datasets-yml when the file parses and lists entries', async () => {
+  it('passes datasets-registered when the file parses and lists entries', async () => {
     writeDatasetsYml(root, ['foo', 'bar']);
     const { results } = await runDoctor(root);
-    const ymlCheck = results.find((r) => r.id === 'datasets-yml');
+    const ymlCheck = results.find((r) => r.id === 'datasets-registered');
     expect(ymlCheck.status).toBe('pass');
     expect(ymlCheck.label).toContain('2 dataset(s)');
+    expect(ymlCheck.label).toContain('datasets.yml');
+  });
+
+  it('registers datasets from site-config.yml when datasets.yml is absent', async () => {
+    writeFileSync(join(root, 'site-config.yml'), 'datasets:\n  - id: viml-2022\n    local_path: datasets/viml-2022\n');
+    mkdirSync(join(root, 'datasets', 'viml-2022'), { recursive: true });
+    stubGenerated(root, ['viml-2022']);
+    const { results, exitCode } = await runDoctor(root);
+    const reg = results.find((r) => r.id === 'datasets-registered');
+    expect(reg.status).toBe('pass');
+    expect(reg.label).toContain('site-config.yml');
+    const fetched = results.find((r) => r.id === 'datasets-fetched');
+    expect(fetched.status).toBe('pass');
+    expect(exitCode).toBe(0);
+  });
+
+  it('fails datasets-fetched when a site-config local_path is missing', async () => {
+    writeFileSync(join(root, 'site-config.yml'), 'datasets:\n  - id: viml-2022\n    local_path: datasets/viml-2022\n');
+    const { results, exitCode } = await runDoctor(root);
+    const fetched = results.find((r) => r.id === 'datasets-fetched');
+    expect(fetched.status).toBe('fail');
+    expect(fetched.detail).toContain('viml-2022');
+    expect(exitCode).toBe(1);
+  });
+
+  it('reports generated manifests for site-config datasets', async () => {
+    writeFileSync(join(root, 'site-config.yml'), 'datasets:\n  - id: viml-2022\n    local_path: datasets/viml-2022\n');
+    mkdirSync(join(root, 'datasets', 'viml-2022'), { recursive: true });
+    stubGenerated(root, ['viml-2022']);
+    const { results } = await runDoctor(root);
+    const gen = results.find((r) => r.id === 'datasets-generated');
+    expect(gen.status).toBe('pass');
+  });
+
+  it('fails on malformed site-config.yml', async () => {
+    writeFileSync(join(root, 'site-config.yml'), 'datasets: [broken');
+    const { results, exitCode } = await runDoctor(root);
+    const reg = results.find((r) => r.id === 'datasets-registered');
+    expect(reg.status).toBe('fail');
+    expect(exitCode).toBe(1);
   });
 
   it('fails when registered datasets are not fetched', async () => {
@@ -125,7 +165,7 @@ describe('doctor — runDoctor on synthetic projects', () => {
   it('does not crash when datasets.yml lists zero datasets', async () => {
     writeFileSync(join(root, 'datasets.yml'), 'datasets: []\n');
     const { results } = await runDoctor(root);
-    const ymlCheck = results.find((r) => r.id === 'datasets-yml');
+    const ymlCheck = results.find((r) => r.id === 'datasets-registered');
     expect(ymlCheck.status).toBe('warn');
   });
 });

package/scripts/doctor.js

@@ -35,8 +35,8 @@ function nodeVersionCheck() {
   };
 }
 function packageDepsCheck(ctx) {
-  const nm = resolve(ctx.pkgRoot, "node_modules");
-  if (!existsSync(nm)) {
+  const roots = [resolve(ctx.cwd, "node_modules"), resolve(ctx.pkgRoot, "node_modules")];
+  if (!roots.some((nm) => existsSync(nm))) {
     return {
       id: "package-deps",
       label: "Dependencies installed",
@@ -46,7 +46,7 @@ function packageDepsCheck(ctx) {
     };
   }
   const required = ["vue", "vue-router", "pinia", "vite", "n3", "glossarist", "@rdfjs/dataset"];
-  const missing = required.filter((p) => !existsSync(join(nm, p)));
+  const missing = required.filter((p) => !roots.some((nm) => existsSync(join(nm, p))));
   if (missing.length) {
     return {
       id: "package-deps",
@@ -58,63 +58,86 @@ function packageDepsCheck(ctx) {
   }
   return { id: "package-deps", label: "Dependencies installed", status: "pass" };
 }
-function datasetsYmlCheck(ctx) {
-  const path = resolve(ctx.cwd, "datasets.yml");
-  if (!existsSync(path)) {
-    return {
-      id: "datasets-yml",
-      label: "datasets.yml present",
-      status: "warn",
-      detail: "file not found at project root",
-      hint: "datasets.yml registers every dataset the browser serves"
-    };
+function resolveDatasetRegistry(cwd, fileError = void 0) {
+  if (fileError) return { registered: [], source: "datasets.yml", error: fileError };
+  const ymlPath = resolve(cwd, "datasets.yml");
+  if (existsSync(ymlPath)) {
+    const list = normalizeRegistry(yaml.load(readFileSync(ymlPath, "utf8")));
+    return { registered: list, source: "datasets.yml" };
+  }
+  const sitePath = resolve(cwd, "site-config.yml");
+  if (existsSync(sitePath)) {
+    try {
+      const list = normalizeRegistry(yaml.load(readFileSync(sitePath, "utf8")));
+      return { registered: list, source: "site-config.yml" };
+    } catch (err) {
+      return { registered: [], source: "site-config.yml", error: err.message };
+    }
   }
-  if (ctx.datasetsYmlError) {
+  return { registered: [], source: null };
+}
+function normalizeRegistry(doc) {
+  const datasets = doc?.datasets;
+  if (!Array.isArray(datasets)) return [];
+  return datasets.filter((d) => d && typeof d === "object" && d.id).map((d) => ({ id: String(d.id), localPath: d.local_path ?? d.localPath }));
+}
+function datasetsRegisteredCheck(ctx) {
+  if (ctx.registry.error) {
     return {
-      id: "datasets-yml",
-      label: "datasets.yml parses",
+      id: "datasets-registered",
+      label: `${ctx.registry.source} parses`,
       status: "fail",
-      detail: ctx.datasetsYmlError,
+      detail: ctx.registry.error,
       hint: "fix the YAML syntax error"
     };
   }
-  const datasets = ctx.datasetsYml?.datasets;
-  if (!Array.isArray(datasets) || datasets.length === 0) {
+  if (!ctx.registry.source) {
     return {
-      id: "datasets-yml",
-      label: "datasets.yml lists datasets",
+      id: "datasets-registered",
+      label: "Dataset registry present",
       status: "warn",
-      detail: "`datasets` key is empty or missing",
+      detail: "neither datasets.yml nor site-config.yml found at project root",
+      hint: "datasets.yml / site-config.yml register every dataset the browser serves"
+    };
+  }
+  if (ctx.registry.registered.length === 0) {
+    return {
+      id: "datasets-registered",
+      label: "Dataset registry lists datasets",
+      status: "warn",
+      detail: `\`datasets\` key is empty or missing in ${ctx.registry.source}`,
       hint: "add at least one dataset entry; see docs/adding-a-dataset.md"
     };
   }
   return {
-    id: "datasets-yml",
-    label: `datasets.yml lists ${datasets.length} dataset(s)`,
+    id: "datasets-registered",
+    label: `${ctx.registry.source} lists ${ctx.registry.registered.length} dataset(s)`,
     status: "pass"
   };
 }
 function datasetsFetchedCheck(ctx) {
-  const datasets = ctx.datasetsYml?.datasets ?? [];
-  if (!datasets.length) {
+  const datasets = ctx.registry.registered;
+  if (!ctx.registry.source || !datasets.length) {
     return { id: "datasets-fetched", label: "Source datasets fetched", status: "warn", detail: "no datasets registered" };
   }
-  const dotDatasets = resolve(ctx.cwd, ".datasets");
-  const missing = datasets.filter((d) => !existsSync(join(dotDatasets, d.id, "concepts"))).map((d) => d.id);
+  const missing = datasets.filter((d) => {
+    if (d.localPath) return !existsSync(resolve(ctx.cwd, d.localPath));
+    return !existsSync(join(resolve(ctx.cwd, ".datasets"), d.id, "concepts"));
+  }).map((d) => d.id);
   if (missing.length) {
     return {
       id: "datasets-fetched",
       label: "Source datasets fetched",
       status: "fail",
-      detail: `.datasets/ missing: ${missing.join(", ")}`,
-      hint: "run `npm run fetch-datasets`"
+      detail: `dataset sources missing: ${missing.join(", ")}`,
+      hint: "run `npm run fetch-datasets` (or check local_path entries in site-config.yml)"
     };
   }
   return { id: "datasets-fetched", label: "Source datasets fetched", status: "pass" };
 }
 function datasetsGeneratedCheck(ctx) {
-  const datasets = ctx.datasetsYml?.datasets ?? [];
-  if (!datasets.length) {
+  const datasets = ctx.registry.registered;
+  if (!ctx.registry.source || !datasets.length) {
     return { id: "datasets-generated", label: "Generated data present", status: "warn", detail: "no datasets registered" };
   }
   const publicData = resolve(ctx.cwd, "public", "data");
@@ -216,7 +239,7 @@ function jsonldContextCheck(ctx) {
 var CHECKS = [
   safe("node-version", nodeVersionCheck),
   safe("package-deps", packageDepsCheck),
-  safe("datasets-yml", datasetsYmlCheck),
+  safe("datasets-registered", datasetsRegisteredCheck),
   safe("datasets-fetched", datasetsFetchedCheck),
   safe("datasets-generated", datasetsGeneratedCheck),
   safe("public-datasets-json", publicDatasetsJsonCheck),
@@ -234,7 +257,13 @@ async function runDoctor(cwd = process.cwd()) {
       datasetsYmlError = err.message;
     }
   }
-  const ctx = { cwd, pkgRoot: PKG_ROOT, datasetsYml, datasetsYmlError };
+  const ctx = {
+    cwd,
+    pkgRoot: PKG_ROOT,
+    datasetsYml,
+    datasetsYmlError,
+    registry: resolveDatasetRegistry(cwd, datasetsYmlError)
+  };
   const results = [];
   for (const check of CHECKS) {
     results.push(await check(ctx));
@@ -274,5 +303,6 @@ export {
   NODE_MIN_MAJOR,
   formatResults,
   main,
+  resolveDatasetRegistry,
   runDoctor
 };