@glossarist/concept-browser 0.7.137 → 0.7.139

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.137",
+  "version": "0.7.139",
   "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.60",
+    "glossarist": "^0.4.61",
     "js-yaml": "^4.1.0",
     "jszip": "^3.10.1",
     "n3": "^1.26.0",

package/scripts/__tests__/concept-uri.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import {
+  buildConceptUri,
+  buildConceptUriPrefix,
+  buildDatasetUriPrefix,
+  buildSiteOrigin,
+} from '../lib/concept-uri';
+
+describe('buildSiteOrigin — deployment hosting coordinate', () => {
+  it('prepends https:// to a scheme-less domain that carries a custom path', () => {
+    expect(buildSiteOrigin('oimlsmart.github.io/vocab', 'https://identity.example/viml'))
+      .toBe('https://oimlsmart.github.io/vocab');
+  });
+
+  it('keeps the configured path segment (/iala-vocab)', () => {
+    expect(buildSiteOrigin('www.glossarist.org/iala-vocab', 'https://identity.example/iala'))
+      .toBe('https://www.glossarist.org/iala-vocab');
+  });
+
+  it('handles an apex domain with no path', () => {
+    expect(buildSiteOrigin('isotc204.geolexica.org', 'https://isotc204.geolexica.org'))
+      .toBe('https://isotc204.geolexica.org');
+  });
+
+  it('normalizes a domain that already declares a scheme and trailing slash', () => {
+    expect(buildSiteOrigin('https://www.example.org/site/', 'https://identity.example'))
+      .toBe('https://www.example.org/site');
+  });
+
+  it('falls back to uriBase only when no domain is declared', () => {
+    expect(buildSiteOrigin(undefined, 'https://identity.example/reg')).toBe('https://identity.example/reg');
+    expect(buildSiteOrigin(null, 'https://identity.example/reg')).toBe('https://identity.example/reg');
+  });
+
+  it('keeps identity (uriBase) and hosting (domain) independent — /dataset/ routes build on either', () => {
+    const sitePrefix = buildConceptUriPrefix(buildSiteOrigin('oimlsmart.github.io/vocab', 'https://identity.example/viml'), 'viml-2013');
+    expect(sitePrefix).toBe('https://oimlsmart.github.io/vocab/dataset/viml-2013/concept/');
+    const identityPrefix = buildConceptUriPrefix('https://identity.example/viml', 'viml-2013');
+    expect(identityPrefix).toBe('https://identity.example/viml/dataset/viml-2013/concept/');
+    expect(buildConceptUri('https://identity.example/viml', 'viml-2013', '0.01'))
+      .toBe('https://identity.example/viml/dataset/viml-2013/concept/0.01');
+    expect(buildDatasetUriPrefix('https://identity.example/viml', 'viml-2013'))
+      .toBe('https://identity.example/viml/dataset/viml-2013/');
+  });
+});

package/scripts/build-edges.js

@@ -29,6 +29,26 @@ function extractSourceRefs(concept, registerId) {
 import { readFileSync, writeFileSync, readdirSync, existsSync, realpathSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
+
+// src/utils/slugify.ts
+var KEEP = /[^\p{L}\p{N}\p{M}_\s-]/gu;
+var HAS_WORD = /[\p{L}\p{N}]/u;
+function shortHash(text) {
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+function slugify(text) {
+  if (text === "") return "";
+  const folded = text.normalize("NFKC").toLowerCase();
+  const slug = folded.replace(KEEP, "").replace(/[\s/]+/g, "-");
+  return HAS_WORD.test(slug) ? slug : `x-${shortHash(folded.trim())}`;
+}
+
+// scripts/build-edges.ts
 var VALID_COMPLETENESS = /* @__PURE__ */ new Set(["complete", "partial"]);
 function validateCompleteness(value) {
   if (value == null) return "complete";
@@ -82,9 +102,6 @@ function normalizeLocalizedString(content) {
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var ROOT = process.cwd();
 var DATA_DIR = join(ROOT, "public", "data");
-function slugify(text) {
-  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s/]+/g, "-");
-}
 function extractReferences(concept, registerId) {
   const edges = [];
   const sourceUri = concept["@id"];

package/scripts/build-edges.ts

@@ -82,17 +82,12 @@ import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import yaml from 'js-yaml';
 import { Register } from 'glossarist';
+import { slugify } from '../src/utils/slugify';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = process.cwd();
 const DATA_DIR = join(ROOT, 'public', 'data');
 
-// --- Normalization ---
-
-function slugify(text) {
-  return text.toLowerCase().replace(/[^\w\s-]/g, '').replace(/[\s/]+/g, '-');
-}
-
 // --- Extractors (open/closed: add new extractors to EXTRACTORS array) ---
 
 function extractReferences(concept: Record<string, any>, registerId: string) {

package/scripts/generate-data.js

@@ -558,6 +558,13 @@ function buildConceptUri(uriBase, registerId, conceptId) {
 function buildConceptUriPrefix(uriBase, registerId) {
   return `${uriBase}/dataset/${registerId}/concept/`;
 }
+function buildSiteOrigin(domain, uriBase) {
+  if (domain) {
+    const trimmed = String(domain).trim().replace(/\/+$/, "");
+    return /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  }
+  return uriBase.replace(/\/+$/, "");
+}
 
 // scripts/lib/harmonize-concept.ts
 import fs from "fs";
@@ -931,7 +938,8 @@ function buildRefMaps(config2, registerCache2) {
   if (xref.refPrefixMap) Object.assign(refPrefixMap, xref.refPrefixMap);
   const uriBase = config2.uriBase;
   if (!uriBase) throw new Error("site-config.yml: uriBase is required");
-  return { patternIndex, refPrefixMap, uriBase, register: null };
+  const siteOrigin = buildSiteOrigin(config2.domain, uriBase);
+  return { patternIndex, refPrefixMap, uriBase, siteOrigin, register: null };
 }
 function resolveIevRef(display, term, refPrefixMap, uriBase) {
   if (!display.startsWith("IEV:")) return null;
@@ -1374,7 +1382,8 @@ async function processDataset(dir, register, opts) {
   const aggregate = await emitOutputSet(conceptInstances, {
     registerId: register,
     uriBase: refMaps.uriBase,
-    languageOrder: opts.languageOrder || opts.languages
+    languageOrder: opts.languageOrder || opts.languages,
+    conceptUriPrefix: buildConceptUriPrefix(refMaps.siteOrigin, register)
   });
   fs2.writeFileSync(path3.join(DATA, register, `${register}.csv`), aggregate.csv);
   fs2.writeFileSync(path3.join(DATA, register, `${register}.jsonld`), aggregate.jsonld);

package/scripts/generate-data.ts

@@ -35,7 +35,7 @@ import type {
   YamlNewsFrontmatter,
   YamlContentPage,
 } from './lib/yaml-types';
-import { buildConceptUri, buildConceptUriPrefix } from './lib/concept-uri';
+import { buildConceptUri, buildConceptUriPrefix, buildSiteOrigin } from './lib/concept-uri';
 import {
   loadConceptFile,
   readYaml,
@@ -246,7 +246,11 @@ function buildRefMaps(config, registerCache) {
 
   const uriBase = config.uriBase;
   if (!uriBase) throw new Error('site-config.yml: uriBase is required');
-  return { patternIndex, refPrefixMap, uriBase, register: null };
+  // Public hosting coordinate from the deployment's own configuration —
+  // `domain` carries any custom path (/vocab/, /iala-vocab). Used for
+  // human-facing links (CSV uri column); uriBase stays the RDF identity.
+  const siteOrigin = buildSiteOrigin(config.domain, uriBase);
+  return { patternIndex, refPrefixMap, uriBase, siteOrigin, register: null };
 }
 
 
@@ -857,10 +861,14 @@ async function processDataset(dir, register, opts) {
 
   // Aggregate distributions: single-file exports of the whole register,
   // emitted by glossarist's output-set API from the canonical model walk.
+  // The CSV uri column is a link a human opens — it carries the SPA route
+  // shape on the deployment's configured host (siteOrigin), not the
+  // RDF-canonical IRI.
   const aggregate = await emitOutputSet(conceptInstances, {
     registerId: register,
     uriBase: refMaps.uriBase,
     languageOrder: opts.languageOrder || opts.languages,
+    conceptUriPrefix: buildConceptUriPrefix(refMaps.siteOrigin, register),
   });
   fs.writeFileSync(path.join(DATA, register, `${register}.csv`), aggregate.csv!);
   fs.writeFileSync(path.join(DATA, register, `${register}.jsonld`), aggregate.jsonld!);

package/scripts/lib/concept-uri.ts

@@ -26,3 +26,21 @@ export function buildConceptUriPrefix(uriBase: string, registerId: string): stri
 export function buildDatasetUriPrefix(uriBase: string, registerId: string): string {
   return `${uriBase}/dataset/${registerId}/`;
 }
+
+/**
+ * Public site origin from the deployment's own configuration.
+ *
+ * site-config `domain` is the hosting coordinate and carries any custom
+ * path (e.g. "oimlsmart.github.io/vocab", "www.glossarist.org/iala-vocab",
+ * "isotc204.geolexica.org"). Links a human opens (CSV `uri` column) must
+ * use this — NOT uriBase, which is the RDF identity root and may differ
+ * from the deployed host. Falls back to uriBase only when a deployment
+ * declares no domain.
+ */
+export function buildSiteOrigin(domain: string | undefined | null, uriBase: string): string {
+  if (domain) {
+    const trimmed = String(domain).trim().replace(/\/+$/, '');
+    return /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  }
+  return uriBase.replace(/\/+$/, '');
+}

package/src/__fixtures__/isotc211-domain-slugs.json

@@ -0,0 +1,201 @@
+{
+ "DGGS": "dggs",
+ "Euclidean geometry": "euclidean-geometry",
+ "GML": "gml",
+ "GeoDRM": "geodrm",
+ "Geometrie": "geometrie",
+ "Georeferenzierung": "georeferenzierung",
+ "ICT": "ict",
+ "Koordinate": "koordinate",
+ "LIDAR": "lidar",
+ "OAIS": "oais",
+ "OWL": "owl",
+ "RDF": "rdf",
+ "Radar": "radar",
+ "SAR": "sar",
+ "SONAR": "sonar",
+ "UML": "uml",
+ "Verweisung": "verweisung",
+ "XML": "xml",
+ "XML Schema": "xml-schema",
+ "XMLSchema": "xmlschema",
+ "addressing": "addressing",
+ "allgemein": "allgemein",
+ "as a modifier": "as-a-modifier",
+ "cobertura": "cobertura",
+ "coordenadas": "coordenadas",
+ "coordinate": "coordinate",
+ "coordinate geometry": "coordinate-geometry",
+ "couverture": "couverture",
+ "coverage": "coverage",
+ "de un sistema": "de-un-sistema",
+ "differential geometry": "differential-geometry",
+ "differential geometry, calculus": "differential-geometry-calculus",
+ "differential geometry, geodesy": "differential-geometry-geodesy",
+ "earth observation": "earth-observation",
+ "einparametrige Menge von Geometrien": "einparametrige-menge-von-geometrien",
+ "general": "general",
+ "general vocabulary": "general-vocabulary",
+ "geodesia": "geodesia",
+ "geodesy": "geodesy",
+ "geometri": "geometri",
+ "geometria": "geometria",
+ "geometry": "geometry",
+ "geometry, metric spaces": "geometry-metric-spaces",
+ "geometry, navigation": "geometry-navigation",
+ "geometry, topology": "geometry-topology",
+ "geoposicionamiento": "geoposicionamiento",
+ "geopositioning": "geopositioning",
+ "iso-10241-1": "iso-10241-1",
+ "iso-10303-227": "iso-10303-227",
+ "iso-1087-1": "iso-1087-1",
+ "iso-12005": "iso-12005",
+ "iso-12620": "iso-12620",
+ "iso-12718": "iso-12718",
+ "iso-14055-1": "iso-14055-1",
+ "iso-14721": "iso-14721",
+ "iso-17123-1": "iso-17123-1",
+ "iso-19101": "iso-19101",
+ "iso-19101-1": "iso-19101-1",
+ "iso-19101-2": "iso-19101-2",
+ "iso-19103": "iso-19103",
+ "iso-19104": "iso-19104",
+ "iso-19105": "iso-19105",
+ "iso-19106": "iso-19106",
+ "iso-19107": "iso-19107",
+ "iso-19108": "iso-19108",
+ "iso-19109": "iso-19109",
+ "iso-19110": "iso-19110",
+ "iso-19111": "iso-19111",
+ "iso-19111-2": "iso-19111-2",
+ "iso-19112": "iso-19112",
+ "iso-19113": "iso-19113",
+ "iso-19114": "iso-19114",
+ "iso-19115": "iso-19115",
+ "iso-19115-1": "iso-19115-1",
+ "iso-19115-2": "iso-19115-2",
+ "iso-19115-3": "iso-19115-3",
+ "iso-19116": "iso-19116",
+ "iso-19117": "iso-19117",
+ "iso-19118": "iso-19118",
+ "iso-19119": "iso-19119",
+ "iso-19123": "iso-19123",
+ "iso-19123-1": "iso-19123-1",
+ "iso-19123-2": "iso-19123-2",
+ "iso-19123-3": "iso-19123-3",
+ "iso-19125-1": "iso-19125-1",
+ "iso-19125-2": "iso-19125-2",
+ "iso-19126": "iso-19126",
+ "iso-19128": "iso-19128",
+ "iso-19130-1": "iso-19130-1",
+ "iso-19131": "iso-19131",
+ "iso-19132": "iso-19132",
+ "iso-19133": "iso-19133",
+ "iso-19134": "iso-19134",
+ "iso-19135": "iso-19135",
+ "iso-19135-1": "iso-19135-1",
+ "iso-19136": "iso-19136",
+ "iso-19136-1": "iso-19136-1",
+ "iso-19136-2": "iso-19136-2",
+ "iso-19141": "iso-19141",
+ "iso-19142": "iso-19142",
+ "iso-19143": "iso-19143",
+ "iso-19144-1": "iso-19144-1",
+ "iso-19144-2": "iso-19144-2",
+ "iso-19145": "iso-19145",
+ "iso-19146": "iso-19146",
+ "iso-19147": "iso-19147",
+ "iso-19148": "iso-19148",
+ "iso-19150-2": "iso-19150-2",
+ "iso-19150-4": "iso-19150-4",
+ "iso-19152": "iso-19152",
+ "iso-19153": "iso-19153",
+ "iso-19154": "iso-19154",
+ "iso-19155": "iso-19155",
+ "iso-19155-2": "iso-19155-2",
+ "iso-19156": "iso-19156",
+ "iso-19157": "iso-19157",
+ "iso-19157-1": "iso-19157-1",
+ "iso-19160-1": "iso-19160-1",
+ "iso-19160-2": "iso-19160-2",
+ "iso-19160-4": "iso-19160-4",
+ "iso-19162": "iso-19162",
+ "iso-19165-2": "iso-19165-2",
+ "iso-19168-1": "iso-19168-1",
+ "iso-19168-2": "iso-19168-2",
+ "iso-19170-1": "iso-19170-1",
+ "iso-21000-5": "iso-21000-5",
+ "iso-22028-1": "iso-22028-1",
+ "iso-22300": "iso-22300",
+ "iso-24619": "iso-24619",
+ "iso-2859-1": "iso-2859-1",
+ "iso-2859-5": "iso-2859-5",
+ "iso-31-2": "iso-31-2",
+ "iso-3534-1": "iso-3534-1",
+ "iso-3534-2": "iso-3534-2",
+ "iso-5127": "iso-5127",
+ "iso-6709": "iso-6709",
+ "iso-8000-2": "iso-8000-2",
+ "iso-80000-7": "iso-80000-7",
+ "iso-860": "iso-860",
+ "iso-8601": "iso-8601",
+ "iso-8601-1": "iso-8601-1",
+ "iso-9000": "iso-9000",
+ "iso-9241-5": "iso-9241-5",
+ "iso-dis-19123-1": "iso-dis-19123-1",
+ "iso-iec-10746-2": "iso-iec-10746-2",
+ "iso-iec-10746-3": "iso-iec-10746-3",
+ "iso-iec-18477-4": "iso-iec-18477-4",
+ "iso-iec-19501": "iso-iec-19501",
+ "iso-iec-2382": "iso-iec-2382",
+ "iso-iec-2382-1": "iso-iec-2382-1",
+ "iso-iec-2382-15": "iso-iec-2382-15",
+ "iso-iec-25001": "iso-iec-25001",
+ "iso-iec-25012": "iso-iec-25012",
+ "iso-iec-9075-2": "iso-iec-9075-2",
+ "iso-iec-guide-2": "iso-iec-guide-2",
+ "iso-iec-guide-98-3": "iso-iec-guide-98-3",
+ "iso-iec-guide-99": "iso-iec-guide-99",
+ "iso-iec-ieee-24765": "iso-iec-ieee-24765",
+ "iso-iec-ieee-9945": "iso-iec-ieee-9945",
+ "iso-tr-19120": "iso-tr-19120",
+ "iso-ts-19104": "iso-ts-19104",
+ "iso-ts-19124-1": "iso-ts-19124-1",
+ "iso-ts-19129": "iso-ts-19129",
+ "iso-ts-19130": "iso-ts-19130",
+ "iso-ts-19130-2": "iso-ts-19130-2",
+ "iso-ts-19138": "iso-ts-19138",
+ "iso-ts-19158": "iso-ts-19158",
+ "iso-ts-19159-1": "iso-ts-19159-1",
+ "iso-ts-19159-2": "iso-ts-19159-2",
+ "iso-ts-19159-3": "iso-ts-19159-3",
+ "iso-ts-19159-4": "iso-ts-19159-4",
+ "iso-ts-19163-1": "iso-ts-19163-1",
+ "iso-ts-27790": "iso-ts-27790",
+ "matematicas": "matematicas",
+ "mathematics": "mathematics",
+ "mathematics, computer science": "mathematics-computer-science",
+ "mathematics, programming": "mathematics-programming",
+ "metric": "metric",
+ "metric, topology, geometry": "metric-topology-geometry",
+ "moving features": "moving-features",
+ "one parameter set of geometries": "one-parameter-set-of-geometries",
+ "ontology": "ontology",
+ "paikkatieto": "paikkatieto",
+ "paikkatietojakauma": "paikkatietojakauma",
+ "postal": "postal",
+ "postal address": "postal-address",
+ "programming": "programming",
+ "reference": "reference",
+ "referencia": "referencia",
+ "register": "register",
+ "registro": "registro",
+ "temporal": "temporal",
+ "topology": "topology",
+ "topology, geometry": "topology-geometry",
+ "topology, graph theory": "topology-graph-theory",
+ "topology, metric spaces": "topology-metric-spaces",
+ "user": "user",
+ "vector geometry": "vector-geometry",
+ "vocabulario general": "vocabulario-general"
+}

package/src/__tests__/dataset-adapter.test.ts

@@ -548,7 +548,7 @@ describe('DatasetAdapter', () => {
       expect(edges.length).toBe(2);
       expect(edges.every(e => e.type === 'domain')).toBe(true);
       expect(edges.find(e => e.lang === 'eng')?.target).toContain('/domain/geometry');
-      expect(edges.find(e => e.lang === 'fra')?.target).toContain('/domain/gomtrie');
+      expect(edges.find(e => e.lang === 'fra')?.target).toContain('/domain/géométrie');
       expect(edges.find(e => e.lang === 'eng')?.label).toBe('geometry');
       expect(edges.find(e => e.lang === 'fra')?.label).toBe('géométrie');
     });

package/src/__tests__/scripts/concept-csv.test.ts

@@ -103,4 +103,19 @@ describe('conceptsToCsv (glossarist output API)', () => {
     expect(rows[1]![0]).toBe('222-02-02');
     expect(rows[1]![4]).toBe('');
   });
+
+  // generate-data passes conceptUriPrefix = buildConceptUriPrefix(uriBase,
+  // register) so the uri column carries the SPA route shape
+  // (/dataset/<register>/concept/<id>) and opens in a browser — the
+  // RDF-canonical fallback would 404.
+  it('uri column carries the SPA route shape via conceptUriPrefix', () => {
+    const bare = new Concept({ id: '1-1-010', termid: '1-1-010', status: 'valid' });
+    const csv = conceptsToCsv([bare], {
+      uriBase: 'https://www.glossarist.org/iala-vocab',
+      registerId: 'iala-2023',
+      conceptUriPrefix: 'https://www.glossarist.org/iala-vocab/dataset/iala-2023/concept/',
+    });
+    const rows = parseCsv(csv);
+    expect(rows[1]![1]).toBe('https://www.glossarist.org/iala-vocab/dataset/iala-2023/concept/1-1-010');
+  });
 });

package/src/__tests__/slugify.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { slugify } from '../utils/slugify';
+import publishedSlugs from '../__fixtures__/isotc211-domain-slugs.json';
 
 describe('slugify', () => {
   it('lowercases text', () => {
@@ -11,7 +12,7 @@ describe('slugify', () => {
   });
 
   it('strips non-word characters', () => {
-    expect(slugify('géométrie (2D)')).toBe('gomtrie-2d');
+    expect(slugify('géométrie (2D)')).toBe('géométrie-2d');
   });
 
   it('collapses multiple spaces into single hyphen', () => {
@@ -25,4 +26,76 @@ describe('slugify', () => {
   it('preserves hyphens in input', () => {
     expect(slugify('iso-19107')).toBe('iso-19107');
   });
+
+  describe('unicode labels', () => {
+    it('keeps accented letters', () => {
+      expect(slugify('dirección postal')).toBe('dirección-postal');
+    });
+
+    it('keeps non-Latin scripts', () => {
+      expect(slugify('геопозиционирование')).toBe('геопозиционирование');
+      expect(slugify('地理定位')).toBe('地理定位');
+      expect(slugify('지리 위치')).toBe('지리-위치');
+    });
+
+    it('keeps Arabic combining marks', () => {
+      expect(slugify('نظام الإحداثيات')).toBe('نظام-الإحداثيات');
+    });
+
+    it('is NFC-stable: composed and decomposed input give one slug', () => {
+      expect(slugify('é')).toBe(slugify('é'));
+    });
+
+    it('gives distinct labels distinct slugs', () => {
+      const labels = ['UML', 'dirección postal', 'direccion postal', 'геопозиционирование',
+        '地理定位', '지리 위치', 'تحديد المواقع'];
+      expect(new Set(labels.map(slugify)).size).toBe(labels.length);
+    });
+
+    it('is idempotent', () => {
+      for (const l of ['dirección postal', 'геопозиционирование', '()', 'a b']) {
+        expect(slugify(slugify(l))).toBe(slugify(l));
+      }
+    });
+  });
+
+  describe('labels without letters or digits', () => {
+    it('never returns an empty or separator-only slug', () => {
+      for (const l of ['()', '---', ' ', '!!', '/', '- -']) {
+        expect(slugify(l)).toMatch(/^x-[0-9a-f]{8}$/);
+      }
+    });
+
+    it('distinguishes different such labels', () => {
+      expect(slugify('()')).not.toBe(slugify('[]'));
+      expect(slugify('()')).toBe(slugify('()'));
+    });
+
+    it('still maps empty input to empty (callers guard on truthy)', () => {
+      expect(slugify('')).toBe('');
+    });
+  });
+
+  describe('existing ASCII URLs do not move', () => {
+    // Verbatim copy of the pre-unicode implementation.
+    const legacy = (t: string) => t.toLowerCase().replace(/[^\w\s-]/g, '').replace(/[\s/]+/g, '-');
+
+    it('matches every domain slug published in the isotc211 dataset', () => {
+      const entries = Object.entries(publishedSlugs as Record<string, string>);
+      expect(entries.length).toBeGreaterThan(150);
+      for (const [label, slug] of entries) expect(slugify(label)).toBe(slug);
+    });
+
+    it('is byte-identical to the legacy output for ASCII input with a letter or digit', () => {
+      let seed = 12345;
+      const rnd = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+      for (let i = 0; i < 20000; i++) {
+        const len = 1 + Math.floor(rnd() * 12);
+        let t = '';
+        for (let j = 0; j < len; j++) t += String.fromCharCode(9 + Math.floor(rnd() * 118));
+        if (!/[A-Za-z0-9]/.test(t)) continue;
+        expect(slugify(t)).toBe(legacy(t));
+      }
+    });
+  });
 });

package/src/utils/slugify.ts

@@ -1,3 +1,27 @@
+// Slug for a domain label. Keeps letters and digits of every script so that
+// non-Latin and accented labels stay distinct and readable. Pure-ASCII input
+// that contains a letter or digit yields exactly what the earlier ASCII-only
+// implementation did, so already-published URLs do not move.
+
+const KEEP = /[^\p{L}\p{N}\p{M}_\s-]/gu;
+const HAS_WORD = /[\p{L}\p{N}]/u;
+
+// FNV-1a, 32 bit, over UTF-16 code units. Sync and dependency-free so it runs
+// in the browser and in the Node build scripts alike.
+function shortHash(text: string): string {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h.toString(16).padStart(8, '0');
+}
+
 export function slugify(text: string): string {
-  return text.toLowerCase().replace(/[^\w\s-]/g, '').replace(/[\s/]+/g, '-');
+  if (text === '') return '';
+  const folded = text.normalize('NFKC').toLowerCase();
+  const slug = folded.replace(KEEP, '').replace(/[\s/]+/g, '-');
+  // No letter or digit left (e.g. "()", "---"): a hash keeps such labels
+  // from collapsing into one empty node.
+  return HAS_WORD.test(slug) ? slug : `x-${shortHash(folded.trim())}`;
 }