@glossarist/concept-browser 0.7.58 → 0.7.60

package/data/glossarist-vocab.json

@@ -0,0 +1,130 @@
+{
+  "_comment": "Single source of truth for the Glossarist vocabulary. Consumed by vocabulary-emitter.ts (view-time) and vocab-turtle.mjs (build-time). Sourced from glossarist-ruby config.yml — keep in sync when concept-model expands the enum.",
+  "schemes": [
+    {
+      "schemeIri": "gloss:status-scheme",
+      "label": "Concept status",
+      "terms": [
+        { "iri": "gloss:status/valid",      "label": "valid" },
+        { "iri": "gloss:status/superseded", "label": "superseded" },
+        { "iri": "gloss:status/withdrawn",  "label": "withdrawn" },
+        { "iri": "gloss:status/draft",      "label": "draft" }
+      ]
+    },
+    {
+      "schemeIri": "gloss:entstatus-scheme",
+      "label": "Entry status",
+      "terms": [
+        { "iri": "gloss:entstatus/valid",      "label": "valid" },
+        { "iri": "gloss:entstatus/superseded", "label": "superseded" },
+        { "iri": "gloss:entstatus/withdrawn",  "label": "withdrawn" },
+        { "iri": "gloss:entstatus/draft",      "label": "draft" }
+      ]
+    },
+    {
+      "schemeIri": "gloss:norm-scheme",
+      "label": "Normative status",
+      "terms": [
+        { "iri": "gloss:norm/preferred",  "label": "preferred" },
+        { "iri": "gloss:norm/admitted",   "label": "admitted" },
+        { "iri": "gloss:norm/deprecated", "label": "deprecated" },
+        { "iri": "gloss:norm/superseded", "label": "superseded" }
+      ]
+    },
+    {
+      "schemeIri": "gloss:srcstatus-scheme",
+      "label": "Source status",
+      "terms": [
+        { "iri": "gloss:srcstatus/identical",       "label": "identical" },
+        { "iri": "gloss:srcstatus/similar",         "label": "similar" },
+        { "iri": "gloss:srcstatus/modified",        "label": "modified" },
+        { "iri": "gloss:srcstatus/restyle",         "label": "restyle" },
+        { "iri": "gloss:srcstatus/context_added",   "label": "context_added" },
+        { "iri": "gloss:srcstatus/generalisation",  "label": "generalisation" },
+        { "iri": "gloss:srcstatus/specialisation",  "label": "specialisation" },
+        { "iri": "gloss:srcstatus/unspecified",     "label": "unspecified" },
+        { "iri": "gloss:srcstatus/related",         "label": "related" },
+        { "iri": "gloss:srcstatus/not_equal",       "label": "not_equal" },
+        { "iri": "gloss:srcstatus/restyled",        "label": "restyled" },
+        { "iri": "gloss:srcstatus/adapted",         "label": "adapted" }
+      ]
+    },
+    {
+      "schemeIri": "gloss:srctype-scheme",
+      "label": "Source type",
+      "terms": [
+        { "iri": "gloss:srctype/authoritative", "label": "authoritative" },
+        { "iri": "gloss:srctype/lineage",       "label": "lineage" }
+      ]
+    },
+    {
+      "schemeIri": "gloss:datetype-scheme",
+      "label": "Date type",
+      "terms": [
+        { "iri": "gloss:datetype/accepted",    "label": "accepted" },
+        { "iri": "gloss:datetype/amended",     "label": "amended" },
+        { "iri": "gloss:datetype/retired",     "label": "retired" },
+        { "iri": "gloss:datetype/deprecated",  "label": "deprecated" },
+        { "iri": "gloss:datetype/superseded",  "label": "superseded" }
+      ]
+    },
+    {
+      "schemeIri": "gloss:rel-scheme",
+      "label": "Relationship type",
+      "_source": "glossarist-ruby config.yml related_concept.type — 52 types",
+      "terms": [
+        { "iri": "gloss:rel/deprecates",                 "label": "deprecates",                 "group": "lifecycle" },
+        { "iri": "gloss:rel/deprecated_by",              "label": "deprecated_by",              "group": "lifecycle" },
+        { "iri": "gloss:rel/supersedes",                 "label": "supersedes",                 "group": "lifecycle" },
+        { "iri": "gloss:rel/superseded_by",              "label": "superseded_by",              "group": "lifecycle" },
+        { "iri": "gloss:rel/replaces",                   "label": "replaces",                   "group": "lifecycle" },
+        { "iri": "gloss:rel/replaced_by",                "label": "replaced_by",                "group": "lifecycle" },
+        { "iri": "gloss:rel/invalidates",                "label": "invalidates",                "group": "lifecycle" },
+        { "iri": "gloss:rel/invalidated_by",             "label": "invalidated_by",             "group": "lifecycle" },
+        { "iri": "gloss:rel/retires",                    "label": "retires",                    "group": "lifecycle" },
+        { "iri": "gloss:rel/retired_by",                 "label": "retired_by",                 "group": "lifecycle" },
+        { "iri": "gloss:rel/narrower",                   "label": "narrower",                   "group": "hierarchical" },
+        { "iri": "gloss:rel/broader",                    "label": "broader",                    "group": "hierarchical" },
+        { "iri": "gloss:rel/broader_generic",            "label": "broader_generic",            "group": "hierarchical" },
+        { "iri": "gloss:rel/narrower_generic",           "label": "narrower_generic",           "group": "hierarchical" },
+        { "iri": "gloss:rel/broader_partitive",          "label": "broader_partitive",          "group": "hierarchical" },
+        { "iri": "gloss:rel/narrower_partitive",         "label": "narrower_partitive",         "group": "hierarchical" },
+        { "iri": "gloss:rel/has_part",                   "label": "has_part",                   "group": "hierarchical" },
+        { "iri": "gloss:rel/is_part_of",                 "label": "is_part_of",                 "group": "hierarchical" },
+        { "iri": "gloss:rel/broader_instantial",         "label": "broader_instantial",         "group": "hierarchical" },
+        { "iri": "gloss:rel/narrower_instantial",        "label": "narrower_instantial",        "group": "hierarchical" },
+        { "iri": "gloss:rel/instance_of",                "label": "instance_of",                "group": "hierarchical" },
+        { "iri": "gloss:rel/has_instance",               "label": "has_instance",               "group": "hierarchical" },
+        { "iri": "gloss:rel/equivalent",                 "label": "equivalent",                 "group": "equivalence" },
+        { "iri": "gloss:rel/exact_match",                "label": "exact_match",                "group": "equivalence" },
+        { "iri": "gloss:rel/close_match",                "label": "close_match",                "group": "equivalence" },
+        { "iri": "gloss:rel/broad_match",                "label": "broad_match",                "group": "equivalence" },
+        { "iri": "gloss:rel/narrow_match",               "label": "narrow_match",               "group": "equivalence" },
+        { "iri": "gloss:rel/related_match",              "label": "related_match",              "group": "equivalence" },
+        { "iri": "gloss:rel/compare",                    "label": "compare",                    "group": "comparative" },
+        { "iri": "gloss:rel/contrast",                   "label": "contrast",                   "group": "comparative" },
+        { "iri": "gloss:rel/see",                        "label": "see",                        "group": "associative" },
+        { "iri": "gloss:rel/references",                 "label": "references",                 "group": "associative" },
+        { "iri": "gloss:rel/related_concept",            "label": "related_concept",            "group": "associative" },
+        { "iri": "gloss:rel/related_concept_broader",    "label": "related_concept_broader",    "group": "associative" },
+        { "iri": "gloss:rel/related_concept_narrower",   "label": "related_concept_narrower",   "group": "associative" },
+        { "iri": "gloss:rel/sequentially_related",       "label": "sequentially_related",       "group": "associative" },
+        { "iri": "gloss:rel/spatially_related",          "label": "spatially_related",          "group": "associative" },
+        { "iri": "gloss:rel/temporally_related",         "label": "temporally_related",         "group": "associative" },
+        { "iri": "gloss:rel/homograph",                  "label": "homograph",                  "group": "lexical" },
+        { "iri": "gloss:rel/false_friend",               "label": "false_friend",               "group": "lexical" },
+        { "iri": "gloss:rel/has_concept",                "label": "has_concept",                "group": "register" },
+        { "iri": "gloss:rel/is_concept_of",              "label": "is_concept_of",              "group": "register" },
+        { "iri": "gloss:rel/has_definition",             "label": "has_definition",             "group": "register" },
+        { "iri": "gloss:rel/definition_of",              "label": "definition_of",              "group": "register" },
+        { "iri": "gloss:rel/inherits",                   "label": "inherits",                   "group": "versioning" },
+        { "iri": "gloss:rel/inherited_by",               "label": "inherited_by",               "group": "versioning" },
+        { "iri": "gloss:rel/has_version",                "label": "has_version",                "group": "versioning" },
+        { "iri": "gloss:rel/version_of",                 "label": "version_of",                 "group": "versioning" },
+        { "iri": "gloss:rel/current_version",            "label": "current_version",            "group": "versioning" },
+        { "iri": "gloss:rel/current_version_of",         "label": "current_version_of",         "group": "versioning" },
+        { "iri": "gloss:rel/derived",                    "label": "derived",                    "group": "legacy" }
+      ]
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.58",
+  "version": "0.7.60",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {
@@ -31,7 +31,7 @@
     "autoprefixer": "^10.4.21",
     "d3": "^7.9.0",
     "favicons": "^7.2.0",
-    "glossarist": "^0.4.5",
+    "glossarist": "^0.4.9",
     "js-yaml": "^4.1.0",
     "jszip": "^3.10.1",
     "pinia": "^2.3.1",
@@ -85,6 +85,7 @@
     "cli",
     "scripts",
     "src",
+    "data",
     "public/favicon.svg",
     "index.html",
     "vite.config.ts",

package/scripts/generate-data.mjs

@@ -1612,7 +1612,7 @@ for (const [id, count] of Object.entries(counts)) {
 
 writeBuildActivity(total, registry.map(r => r.id));
 
-fs.writeFileSync(path.join(DATA, '_vocab.ttl'), buildVocabularyTurtle());
+fs.writeFileSync(path.join(DATA, '_vocab.ttl'), await buildVocabularyTurtle());
 console.log('Emitted vocabulary graph: data/_vocab.ttl');
 
 const contributors = config.contributors ?? [];

package/scripts/lib/vocab-turtle.mjs

@@ -1,6 +1,21 @@
+// Vocab turtle builder — emits SKOS ConceptSchemes for the
+// glossarist enumeration IRIs.
+//
+// Delegates to glossarist-js's vocabulary emitter + writeTurtle so the
+// canonical prefix list, CURIE handling, and serialization stay in one
+// place. The output is byte-equivalent in semantics ( CURIEs resolved
+// to absolute IRIs, then re-rendered via glossarist-js's n3 writer with
+// the canonical prefix map ).
+
 import { readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import {
+  vocabularyToQuads,
+  collectQuads,
+  writeTurtle,
+  PREFIXES,
+} from 'glossarist/rdf';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VOCAB_PATH = join(__dirname, '..', '..', 'data', 'glossarist-vocab.json');
@@ -9,54 +24,20 @@ function loadVocab(path = VOCAB_PATH) {
   return JSON.parse(readFileSync(path, 'utf8'));
 }
 
-function ttlLit(s) {
-  if (s == null) return '""';
-  const escaped = String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"')
-    .replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t');
-  return `"${escaped}"`;
-}
-
-function ttlPrefixed(qname) {
-  const colonIdx = qname.indexOf(':');
-  if (colonIdx < 0) return qname;
-  const local = qname.slice(colonIdx + 1);
-  const escaped = local.replace(/([/])/g, '\\$1');
-  return `${qname.slice(0, colonIdx + 1)}${escaped}`;
+// n3's writer prefixes must omit the trailing # or / — those go in
+// the local name. Build the prefix-only map for writeTurtle.
+function writerPrefixes() {
+  const out = {};
+  for (const [k, v] of Object.entries(PREFIXES)) {
+    out[k] = v;
+  }
+  return out;
 }
 
-export function buildVocabularyTurtle() {
+export async function buildVocabularyTurtle() {
   const vocab = loadVocab();
-  const lines = [
-    '@prefix skos: <http://www.w3.org/2004/02/skos/core#> .',
-    '@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .',
-    '@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .',
-    '@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .',
-    '@prefix dcterms: <http://purl.org/dc/terms/> .',
-    '@prefix gloss: <https://www.glossarist.org/ontologies/> .',
-    '',
-  ];
-
-  for (const scheme of vocab.schemes) {
-    const schemeLines = [
-      `${ttlPrefixed(scheme.schemeIri)} a skos:ConceptScheme ;`,
-      `  rdfs:label ${ttlLit(scheme.label)} ;`,
-    ];
-    for (const term of scheme.terms) {
-      schemeLines.push(`  skos:hasTopConcept ${ttlPrefixed(term.iri)} ;`);
-    }
-    schemeLines[schemeLines.length - 1] = schemeLines[schemeLines.length - 1].replace(/ ;$/, ' .');
-    lines.push(...schemeLines);
-
-    for (const term of scheme.terms) {
-      lines.push(`${ttlPrefixed(term.iri)} a skos:Concept ;`);
-      lines.push(`  rdfs:label ${ttlLit(term.label)} ;`);
-      lines.push(`  skos:inScheme ${ttlPrefixed(scheme.schemeIri)} .`);
-      lines.push('');
-    }
-    lines.push('');
-  }
-
-  return lines.join('\n') + '\n';
+  const quads = collectQuads(vocabularyToQuads(vocab.schemes));
+  return writeTurtle(quads, { prefixes: writerPrefixes() });
 }
 
 export function listVocabSchemes() {

package/src/__tests__/scripts/build-integration.test.ts

@@ -15,7 +15,7 @@ function runInline(code: string): string {
 
 describe('WS F Layer 8 — build pipeline integration', () => {
   it('vocab-turtle.mjs produces parseable Turtle with 7 schemes', () => {
-    const out = runInline(`import { buildVocabularyTurtle } from './scripts/lib/vocab-turtle.mjs'; console.log(buildVocabularyTurtle());`);
+    const out = runInline(`import { buildVocabularyTurtle } from './scripts/lib/vocab-turtle.mjs'; console.log(await buildVocabularyTurtle());`);
     const store = parseTurtle(out);
     const schemes = [...store].filter(q =>
       q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type' &&
@@ -119,7 +119,7 @@ describe('WS F Layer 8 — build pipeline integration', () => {
       import { buildBibliographyTurtle } from './scripts/lib/bibliography-turtle.mjs';
       import { buildVersionHistoryTurtle } from './scripts/lib/version-turtle.mjs';
       const parts = [
-        buildVocabularyTurtle(),
+        await buildVocabularyTurtle(),
         buildDatasetTurtle({ datasetIri: 'https://glossarist.org/test/', registerId: 'test', title: 't', modified: '2026-01-01', languages: ['eng'], distributions: [], topConceptUris: [], sections: [] }),
         buildActivityTurtle({ runId: 'r', startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:05:00Z', toolId: 'cb', toolVersion: '0', datasetRegisters: [], conceptCount: 0 }),
         buildAgentsTurtle([{ name: 'Ada' }]),

package/src/__tests__/scripts/vocab-turtle.test.ts

@@ -13,22 +13,22 @@ const SKOS = 'http://www.w3.org/2004/02/skos/core#';
 const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
 
 describe('buildVocabularyTurtle (mjs)', () => {
-  it('parses without errors and produces a non-empty graph', () => {
-    const ttl = buildVocabularyTurtle();
+  it('parses without errors and produces a non-empty graph', async () => {
+    const ttl = await buildVocabularyTurtle();
     const store = parse(ttl);
     expect(store.size).toBeGreaterThan(0);
   });
 
-  it('declares at least one skos:ConceptScheme', () => {
-    const store = parse(buildVocabularyTurtle());
+  it('declares at least one skos:ConceptScheme', async () => {
+    const store = parse(await buildVocabularyTurtle());
     const schemes = [...store].filter(q =>
       q.predicate.value === RDF_TYPE && q.object.value === `${SKOS}ConceptScheme`,
     );
     expect(schemes.length).toBeGreaterThan(0);
   });
 
-  it('declares enumeration IRIs as skos:Concept instances', () => {
-    const store = parse(buildVocabularyTurtle());
+  it('declares enumeration IRIs as skos:Concept instances', async () => {
+    const store = parse(await buildVocabularyTurtle());
     const concepts = [...store].filter(q =>
       q.predicate.value === RDF_TYPE && q.object.value === `${SKOS}Concept`,
     );
@@ -53,8 +53,8 @@ describe('buildVocabularyTurtle (mjs)', () => {
     expect(schemes.length).toBe(7);
   });
 
-  it('emits skos:hasTopConcept and skos:inScheme bidirectionally', () => {
-    const store = parse(buildVocabularyTurtle());
+  it('emits skos:hasTopConcept and skos:inScheme bidirectionally', async () => {
+    const store = parse(await buildVocabularyTurtle());
     const hasTopConcept = [...store].filter(q => q.predicate.value === `${SKOS}hasTopConcept`);
     const inScheme = [...store].filter(q => q.predicate.value === `${SKOS}inScheme`);
     expect(hasTopConcept.length).toBeGreaterThan(0);

package/src/components/concept-rdf/rdf-prefixes.ts

@@ -1,9 +1,18 @@
 // Prefix bindings for concept-browser's RDF emission.
 //
-// The canonical SSOT for prefix bindings is `data/concept-model/prefixes.ttl`
-// (vendored from glossarist/concept-model). This list is the runtime subset
-// actually emitted by concept-browser. Keep it aligned with prefixes.ttl
-// whenever the upstream file changes.
+// Sources PREFIXES (the canonical prefix→IRI map) from glossarist/rdf
+// so the runtime list stays in sync with the upstream concept-model
+// `prefixes.ttl` SSOT automatically. The per-prefix `description`
+// strings remain local because they are presentation metadata, not
+// part of the canonical bindings.
+//
+// glossarist-js's PREFIXES is generated from the JSON-LD context,
+// which omits some well-known prefixes that ARE in `prefixes.ttl`
+// and ARE used in instance data (dcat, foaf, sh). We supplement
+// locally until upstream glossarist-js regenerates from the full
+// prefixes.ttl.
+
+import { PREFIXES as GLOSSARIST_PREFIXES } from 'glossarist/rdf/prefixes';
 
 export interface PrefixEntry {
   prefix: string;
@@ -11,22 +20,53 @@ export interface PrefixEntry {
   description: string;
 }
 
-export const RDF_PREFIXES: readonly PrefixEntry[] = [
-  { prefix: 'gloss',     iri: 'https://www.glossarist.org/ontologies/',                description: 'Glossarist ontology' },
-  { prefix: 'skos',      iri: 'http://www.w3.org/2004/02/skos/core#',                  description: 'Simple Knowledge Organization System' },
-  { prefix: 'skosxl',    iri: 'http://www.w3.org/2008/05/skos-xl#',                    description: 'SKOS eXtension for Labels' },
-  { prefix: 'iso-thes',  iri: 'http://purl.org/iso25964/skos-thes#',                   description: 'ISO 25964 SKOS thesaurus extensions' },
-  { prefix: 'rdf',       iri: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',           description: 'RDF core vocabulary' },
-  { prefix: 'rdfs',      iri: 'http://www.w3.org/2000/01/rdf-schema#',                 description: 'RDF Schema' },
-  { prefix: 'owl',       iri: 'http://www.w3.org/2002/07/owl#',                        description: 'Web Ontology Language' },
-  { prefix: 'dcterms',   iri: 'http://purl.org/dc/terms/',                             description: 'Dublin Core terms' },
-  { prefix: 'prov',      iri: 'http://www.w3.org/ns/prov#',                            description: 'PROV-O provenance' },
-  { prefix: 'dcat',      iri: 'http://www.w3.org/ns/dcat#',                            description: 'Data Catalog vocabulary' },
-  { prefix: 'foaf',      iri: 'http://xmlns.com/foaf/0.1/',                            description: 'Friend-of-a-Friend agents' },
-  { prefix: 'vann',      iri: 'http://purl.org/vocab/vann/',                           description: 'Vocabulary annotations' },
-  { prefix: 'xsd',       iri: 'http://www.w3.org/2001/XMLSchema#',                     description: 'XML Schema datatypes' },
-  { prefix: 'sh',        iri: 'http://www.w3.org/ns/shacl#',                           description: 'SHACL shapes vocabulary' },
-] as const;
+// Prefixes declared in concept-model's canonical prefixes.ttl that
+// glossarist-js's PREFIXES does not yet export (because they are
+// absent from the JSON-LD context, even though they appear in
+// instance data — dcat:Dataset, foaf:Person, sh:NodeShape).
+const SUPPLEMENTAL_PREFIXES: Record<string, string> = {
+  dcat: 'http://www.w3.org/ns/dcat#',
+  foaf: 'http://xmlns.com/foaf/0.1/',
+  sh:   'http://www.w3.org/ns/shacl#',
+};
+
+const PREFIX_DESCRIPTIONS: Record<string, string> = {
+  gloss:     'Glossarist ontology',
+  skos:      'Simple Knowledge Organization System',
+  skosxl:    'SKOS eXtension for Labels',
+  'iso-thes': 'ISO 25964 SKOS thesaurus extensions',
+  rdf:       'RDF core vocabulary',
+  rdfs:      'RDF Schema',
+  owl:       'Web Ontology Language',
+  dcterms:   'Dublin Core terms',
+  prov:      'PROV-O provenance',
+  dcat:      'Data Catalog vocabulary',
+  foaf:      'Friend-of-a-Friend agents',
+  vann:      'Vocabulary annotations',
+  xsd:       'XML Schema datatypes',
+  sh:        'SHACL shapes vocabulary',
+};
+
+function descriptionFor(prefix: string): string {
+  return PREFIX_DESCRIPTIONS[prefix] ?? '';
+}
+
+// Merge glossarist-js's canonical PREFIXES with the supplemental
+// bindings. Order: glossarist PREFIXES first (canonical order), then
+// any supplemental prefixes not already present.
+const MERGED: Record<string, string> = {
+  ...GLOSSARIST_PREFIXES,
+  ...SUPPLEMENTAL_PREFIXES,
+};
+
+// Derive RDF_PREFIXES at module load.
+export const RDF_PREFIXES: readonly PrefixEntry[] = Object.freeze(
+  Object.entries(MERGED).map(([prefix, iri]) => ({
+    prefix,
+    iri,
+    description: descriptionFor(prefix),
+  })),
+);
 
 export function findPrefix(prefix: string): PrefixEntry | undefined {
   return RDF_PREFIXES.find(p => p.prefix === prefix);

package/src/utils/dataset-style.ts

@@ -1,6 +1,7 @@
 import { useVocabularyStore } from '../stores/vocabulary';
 import type { DatasetColorSpec } from '../config/types';
 import { createColorTheme } from './color-theme';
+import { resolveColor as resolveColorGlossarist } from 'glossarist/models';
 
 const PALETTE = [
   '#3366ff', '#0d9488', '#d97706', '#8b5cf6',
@@ -45,10 +46,17 @@ function normalizeSpec(spec: DatasetColorSpec | undefined, fallback: string): {
     return { light: fallback, dark };
   }
   if (typeof spec === 'string') {
+    // Single hex applies to both modes, but dark mode needs the
+    // alpha-blended fallback for contrast on dark surfaces.
     const dark = hexToRgba(spec, 0.85);
     return { light: spec, dark };
   }
-  return { light: spec.light, dark: spec.dark };
+  // Pair case: delegate to glossarist-js's resolveColor so the canonical
+  // "missing mode returns null" rule stays in one place. concept-browser
+  // then fills in any null with the other mode's value.
+  const light = resolveColorGlossarist(spec, 'light') ?? spec.dark ?? fallback;
+  const dark = resolveColorGlossarist(spec, 'dark') ?? spec.light ?? hexToRgba(light, 0.85);
+  return { light, dark };
 }
 
 export function paletteColor(index: number): string {