@glossarist/concept-browser 0.7.113 → 0.7.115

package/scripts/lib/yaml-types.ts

@@ -0,0 +1,262 @@
+/**
+ * YAML author-format TypeScript interfaces.
+ *
+ * These types describe the YAML wire format that dataset authors write
+ * and that `scripts/generate-data.ts` reads. They are the author-facing
+ * contract — the complement to `src/adapters/jsonld-types.ts` (the
+ * browser-facing JSON-LD wire format).
+ *
+ * MECE boundary:
+ *   - yaml-types.ts  → INPUT to the build pipeline (what authors write)
+ *   - jsonld-types.ts → OUTPUT of the build pipeline (what the browser reads)
+ *   - model-bridge.ts → converts JSON-LD → glossarist-js Concept instances
+ *
+ * Model-driven: field names match the YAML keys authors actually write
+ * (snake_case for author-facing, camelCase for internal normalized form).
+ */
+
+// ── Content blocks ─────────────────────────────────────────────────────────
+
+export interface YamlContent {
+  content?: string;
+}
+
+// ── Terms / designations ──────────────────────────────────────────────────
+
+export interface YamlTerm {
+  type?: string;
+  designation?: string;
+  normative_status?: string;
+  origin?: YamlOrigin;
+  grammar_info?: YamlGrammarInfo[];
+  english?: string[];
+}
+
+export interface YamlOrigin {
+  source?: string;
+  ref?: string;
+  version?: string;
+}
+
+export interface YamlGrammarInfo {
+  gender?: string;
+  number?: string;
+  partOfSpeech?: string;
+  noun?: boolean;
+  verb?: boolean;
+  adj?: boolean;
+  adverb?: boolean;
+  preposition?: boolean;
+  participle?: boolean;
+}
+
+// ── Sources ───────────────────────────────────────────────────────────────
+
+export interface YamlSource {
+  origin?: YamlOrigin;
+  ref?: string;
+  link?: string;
+  relationship_type?: string;
+  status?: string;
+  title?: string;
+  type?: string;
+}
+
+// ── Dates ─────────────────────────────────────────────────────────────────
+
+export interface YamlDate {
+  type?: string;
+  date?: string;
+}
+
+// ── Relations ─────────────────────────────────────────────────────────────
+
+export interface YamlRelation {
+  type?: string;
+  target?: string | { ref?: string; uri?: string };
+  content?: string;
+  label?: string;
+}
+
+export interface YamlPartitiveMember {
+  ref?: string;
+  uri?: string;
+  presence?: string;
+  count?: string;
+  delimiting?: boolean;
+  multiplicity?: string;
+  certainty?: string;
+  designation?: string;
+  content?: string;
+}
+
+export interface YamlPartitiveRelation {
+  type?: string;
+  target?: string;
+  members?: YamlPartitiveMember[];
+  criterion?: string;
+  multiplicity?: string;
+  certainty?: string;
+}
+
+export interface YamlGenericRelation {
+  type?: string;
+  target?: string;
+  members?: (string | { ref?: string; uri?: string })[];
+  criterion?: string;
+}
+
+// ── Localization (per-language concept data) ──────────────────────────────
+
+export interface YamlLocalization {
+  language_code?: string;
+  terms?: YamlTerm[];
+  definition?: YamlContent[];
+  notes?: YamlContent[];
+  examples?: YamlContent[];
+  annotations?: YamlContent[];
+  sources?: YamlSource[];
+  dates?: YamlDate[];
+  domain?: string[];
+  references?: YamlSource[];
+  entry_status?: string;
+  classification?: string;
+  review_type?: string;
+  review_date?: string;
+  review_decision_date?: string;
+  review_decision_event?: string;
+  review_status?: string;
+  review_decision?: string;
+  review_decision_notes?: string;
+  lineage_source_similarity?: number;
+  release?: string;
+  script?: string;
+  system?: string;
+  [key: string]: unknown;
+}
+
+// ── Harmonized concept (output of loadConceptFile) ────────────────────────
+//
+// After loadConceptFile(), the concept is normalized to this shape
+// regardless of whether the source was simple or managed format.
+// The `_`-prefixed fields are managed-concept metadata hoisted to top level.
+
+export interface HarmonizedConcept {
+  termid: string;
+  id?: string;
+  uri?: string;
+  status?: string;
+  _related?: YamlRelation[];
+  _partitiveRelations?: YamlPartitiveRelation[];
+  _genericRelations?: YamlGenericRelation[];
+  _domains?: string[];
+  _dates?: YamlDate[];
+  _sources?: YamlSource[];
+  _status?: string;
+  _schemaVersion?: string;
+  _dateAccepted?: string;
+  [lang: string]: unknown;
+}
+
+// ── Managed concept YAML doc (multi-doc format) ───────────────────────────
+
+export interface YamlManagedConceptDoc {
+  data?: {
+    identifier?: string | number;
+    language_code?: string;
+    domains?: string[];
+    [key: string]: unknown;
+  };
+  related?: YamlRelation[];
+  partitive_relations?: YamlPartitiveRelation[];
+  generic_relations?: YamlGenericRelation[];
+  dates?: YamlDate[];
+  sources?: YamlSource[];
+  status?: string;
+  schema_version?: string;
+  date_accepted?: string;
+  terms?: YamlTerm[];
+  definition?: YamlContent[];
+  notes?: YamlContent[];
+  examples?: YamlContent[];
+  [key: string]: unknown;
+}
+
+// ── Dataset manifest ──────────────────────────────────────────────────────
+
+export interface YamlManifestSection {
+  id?: string;
+  slug?: string;
+  title?: string;
+  name?: string;
+  members?: string[];
+  children?: YamlManifestSection[];
+  ordering?: string;
+}
+
+export interface YamlManifest {
+  id?: string;
+  title?: string;
+  description?: string;
+  lastUpdated?: string;
+  sourceRepoUrl?: string;
+  publisher?: string;
+  contactPoint?: string;
+  sections?: YamlManifestSection[];
+  languageOrder?: string[];
+  ref?: Record<string, string>;
+  refAliases?: string[];
+  editionStatus?: string;
+  ordering?: string;
+  [key: string]: unknown;
+}
+
+// ── Bibliography ──────────────────────────────────────────────────────────
+
+export interface YamlBibliographyEntry {
+  reference?: string;
+  title?: string;
+  link?: string;
+  author?: string;
+  date?: string;
+  publisher?: string;
+  type?: string;
+  [key: string]: unknown;
+}
+
+// ── News/content frontmatter ──────────────────────────────────────────────
+
+export interface YamlNewsFrontmatter {
+  title?: string;
+  date?: string;
+  categories?: string;
+  [key: string]: unknown;
+}
+
+// ── Content page config ───────────────────────────────────────────────────
+
+export interface YamlContentPage {
+  route?: string;
+  source?: string;
+  title?: string;
+  translations?: Record<string, { source?: string; title?: string }>;
+  [key: string]: unknown;
+}
+
+// ── SHACL constraint (ontology schema) ────────────────────────────────────
+
+export interface ShaclConstraint {
+  path?: string | null;
+  datatype?: string | null;
+  class?: string | null;
+  valuesFrom?: string | null;
+  nodeKind?: string | null;
+  minCount?: number | null;
+  maxCount?: number | null;
+  in?: string[];
+  [key: string]: unknown;
+}
+
+// ── Prefix map (Turtle emission) ──────────────────────────────────────────
+
+export type PrefixMap = Record<string, string>;

package/scripts/{process-about-pages.mjs → process-about-pages.ts}

@@ -19,7 +19,7 @@ import { join, basename, extname, resolve } from 'node:path';
 import { cwd } from 'node:process';
 import { fileURLToPath } from 'node:url';
 
-import { loadSiteConfig } from './load-site-config.mjs';
+import { loadSiteConfig } from './load-site-config';
 
 export function loadSiteConfigForAbout() {
   try {

package/scripts/{smoke.mjs → smoke.ts}

@@ -36,7 +36,7 @@ const DIST = pathResolve(__dirname, '..', 'dist');
 const MIME = {
   '.html': 'text/html; charset=utf-8',
   '.js':   'application/javascript; charset=utf-8',
-  '.mjs':  'application/javascript; charset=utf-8',
+  '':  'application/javascript; charset=utf-8',
   '.css':  'text/css; charset=utf-8',
   '.json': 'application/json; charset=utf-8',
   '.svg':  'image/svg+xml',
@@ -53,7 +53,7 @@ const MIME = {
   '.webmanifest': 'application/manifest+json; charset=utf-8',
 };
 
-function serveDist(root) {
+function serveDist(root: string): Promise<{ server: ReturnType<typeof createServer>; origin: string }> {
   return new Promise((resolve) => {
     const server = createServer((req, res) => {
       try {
@@ -91,7 +91,8 @@ function serveDist(root) {
     });
     // Use port 0 to let the OS pick a free port; retrieve it after listen.
     server.listen(0, '127.0.0.1', () => {
-      const { port } = server.address();
+      const addr = server.address();
+      const port = typeof addr === 'object' && addr ? addr.port : 0;
       resolve({ server, origin: `http://127.0.0.1:${port}` });
     });
   });

package/scripts/{validate-shacl.mjs → validate-shacl.ts}

@@ -90,7 +90,7 @@ function parseTurtle(text, baseIri) {
   });
 }
 
-function* walkTtl(dir) {
+function* walkTtl(dir: string): Generator<string> {
   for (const entry of readdirSync(dir)) {
     const full = join(dir, entry);
     if (statSync(full).isDirectory()) yield* walkTtl(full);
@@ -98,12 +98,12 @@ function* walkTtl(dir) {
   }
 }
 
-function formatViolation(v) {
+function formatViolation(v: any): string {
   const focus = v.focusNode?.value ?? '(unknown)';
   const shape = v.shape?.value ?? '(unknown)';
   const path = v.path?.value ?? '';
   const message = (v.message && v.message.length > 0)
-    ? v.message.map(m => m.value).join('; ')
+    ? v.message.map((m: any) => m.value).join('; ')
     : '(no message)';
   const pathPart = path ? `\n    path:    ${path}` : '';
   return `    shape:   ${shape}${pathPart}\n    node:    ${focus}\n    message: ${message}`;
@@ -121,7 +121,7 @@ async function main() {
   try {
     const shapesText = readFileSync(shapesPath, 'utf8');
     shapesDataset = await parseTurtle(shapesText, `file://${shapesPath}`);
-  } catch (e) {
+  } catch (e: any) {
     console.error(`Failed to load SHACL shapes from ${shapesPath}: ${e.message}`);
     process.exit(2);
   }
@@ -150,7 +150,7 @@ async function main() {
     try {
       const text = readFileSync(path, 'utf8');
       graph = await parseTurtle(text, `file://${path}`);
-    } catch (e) {
+    } catch (e: any) {
       violations.push({ path, parseError: e.message });
       continue;
     }

package/scripts/validate-yaml.ts

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+/**
+ * validate-yaml — validate dataset author YAML files against the
+ * Glossarist concept JSON Schema.
+ *
+ * Usage:
+ *   npx tsx scripts/validate-yaml.ts <path-to-yaml-or-dir>
+ *   npx tsx scripts/validate-yaml.ts .datasets/my-vocab/concepts/
+ */
+
+import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { join, extname, resolve } from 'node:path';
+import { cwd } from 'node:process';
+import yaml from 'js-yaml';
+
+const SCHEMA_PATH = join(cwd(), 'data', 'concept-model', 'shapes', 'glossarist.concept.yaml.schema.json');
+
+export interface ValidationError { path: string; message: string; }
+export interface ValidationResult { valid: boolean; errors: ValidationError[]; }
+
+export function loadSchema(): any {
+  if (!existsSync(SCHEMA_PATH)) {
+    throw new Error(`Schema not found: ${SCHEMA_PATH}`);
+  }
+  return JSON.parse(readFileSync(SCHEMA_PATH, 'utf8'));
+}
+
+export function validateValue(value: any, schema: any, path: string, rootSchema: any, errors: ValidationError[]): void {
+  if (schema.$ref) {
+    const ref = schema.$ref.replace(/^#\/\$defs\//, '');
+    validateValue(value, rootSchema.$defs?.[ref] ?? {}, path, rootSchema, errors);
+    return;
+  }
+  if (schema.type === 'array') {
+    if (!Array.isArray(value)) {
+      errors.push({ path, message: `Expected array, got ${typeof value}` });
+      return;
+    }
+    for (let i = 0; i < value.length; i++) {
+      validateValue(value[i], schema.items ?? {}, `${path}[${i}]`, rootSchema, errors);
+    }
+    return;
+  }
+  if (schema.type && typeof value !== schema.type) {
+    errors.push({ path, message: `Expected ${schema.type}, got ${typeof value}` });
+    return;
+  }
+  if (schema.enum && !schema.enum.includes(value)) {
+    errors.push({ path, message: `"${value}" is not one of [${schema.enum.join(', ')}]` });
+    return;
+  }
+  if (schema.type === 'object' && schema.properties) {
+    for (const [key, subSchema] of Object.entries(schema.properties) as [string, any][]) {
+      if (value[key] !== undefined) {
+        validateValue(value[key], subSchema, `${path}.${key}`, rootSchema, errors);
+      }
+    }
+    if (schema.required) {
+      for (const req of schema.required) {
+        if (!(req in value)) {
+          errors.push({ path: `${path}.${req}`, message: `Missing required field: ${req}` });
+        }
+      }
+    }
+    if (schema.patternProperties) {
+      for (const [pattern, subSchema] of Object.entries(schema.patternProperties) as [string, any][]) {
+        const re = new RegExp(pattern);
+        for (const key of Object.keys(value)) {
+          if (re.test(key) && !(key in (schema.properties ?? {}))) {
+            validateValue(value[key], subSchema, `${path}.${key}`, rootSchema, errors);
+          }
+        }
+      }
+    }
+  }
+  if (schema.type === 'array' && Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      validateValue(value[i], schema.items ?? {}, `${path}[${i}]`, rootSchema, errors);
+    }
+  }
+}
+
+export function validateYaml(yamlContent: string, schema: any): ValidationResult {
+  const data = yaml.load(yamlContent);
+  const errors: ValidationError[] = [];
+  if (Array.isArray(data)) {
+    for (let i = 0; i < data.length; i++) {
+      validateValue(data[i], schema, `doc[${i}]`, schema, errors);
+    }
+  } else if (data && typeof data === 'object') {
+    validateValue(data, schema, 'root', schema, errors);
+  } else {
+    errors.push({ path: 'root', message: 'YAML must be an object or array of objects' });
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+function walkYaml(dir: string): string[] {
+  const out: string[] = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    const st = statSync(full);
+    if (st.isDirectory()) out.push(...walkYaml(full));
+    else if (['.yaml', '.yml'].includes(extname(entry))) out.push(full);
+  }
+  return out;
+}
+
+function main(): void {
+  const target = process.argv[2];
+  if (!target) {
+    console.error('Usage: validate-yaml <path-to-yaml-or-dir>');
+    process.exit(1);
+  }
+  const schema = loadSchema();
+  const resolvedTarget = resolve(target);
+  if (!existsSync(resolvedTarget)) {
+    console.error(`Path not found: ${resolvedTarget}`);
+    process.exit(1);
+  }
+  const files = statSync(resolvedTarget).isDirectory() ? walkYaml(resolvedTarget) : [resolvedTarget];
+  let totalValid = 0;
+  let totalErrors = 0;
+  for (const file of files) {
+    const content = readFileSync(file, 'utf8');
+    const result = validateYaml(content, schema);
+    if (result.valid) {
+      totalValid++;
+    } else {
+      totalErrors += result.errors.length;
+      console.error(`FAIL: ${file}`);
+      for (const err of result.errors) console.error(`  ${err.path}: ${err.message}`);
+    }
+  }
+  console.log(`\n${totalValid}/${files.length} files valid, ${totalErrors} errors`);
+  process.exit(totalErrors > 0 ? 1 : 0);
+}
+
+const isDirect = process.argv[1] && resolve(process.argv[1]) === fileURLToPathPath();
+function fileURLToPathPath(): string {
+  return resolve(new URL(import.meta.url).pathname);
+}
+
+if (isDirect) main();

package/src/__tests__/extract-source-refs.test.ts

@@ -1,8 +1,7 @@
-// @ts-nocheck — ESM .js import without type declarations
 import { describe, it, expect } from 'vitest';
-import { extractSourceRefs } from '../../scripts/extract-source-refs.js';
+import { extractSourceRefs } from '../../scripts/extract-source-refs';
 
-function makeConcept(sources: any[], localizedSources?: any) {
+function makeConcept(sources: any[] = [], localizedSources?: any) {
   return {
     '@id': 'https://glossarist.org/ds1/concept/1.1',
     'gl:source': sources || [],

package/src/__tests__/perf/serialization-perf.test.ts

@@ -1,5 +1,5 @@
-// @ts-nocheck — TODO.typescript/12: remove after glossarist TS migration
 import { describe, it, expect } from 'vitest';
+import type { Quad } from 'n3';
 import { Concept } from 'glossarist';
 import { conceptToQuads, collectQuads, writeTurtleSync, PREFIXES } from 'glossarist/rdf';
 import type { ConceptFixture } from '../__fixtures__/concepts';
@@ -41,7 +41,7 @@ describe('Layer 7 — serialization performance regression', () => {
 
     const start = performance.now();
     for (const { concept } of concepts) {
-      const quads = collectQuads(conceptToQuads(concept, { registerId: 'perf', uriBase: BASE }));
+      const quads = collectQuads(conceptToQuads(concept, { registerId: 'perf', uriBase: BASE }) as Generator<Quad>);
       writeTurtleSync(quads, { prefixes: PREFIXES });
     }
     const elapsed = performance.now() - start;
@@ -55,7 +55,7 @@ describe('Layer 7 — serialization performance regression', () => {
     const concepts = makeConcepts(100);
     const start = performance.now();
     for (const { concept } of concepts) {
-      const quads = collectQuads(conceptToQuads(concept, { registerId: 'perf', uriBase: BASE }));
+      const quads = collectQuads(conceptToQuads(concept, { registerId: 'perf', uriBase: BASE }) as Generator<Quad>);
       writeTurtleSync(quads, { prefixes: PREFIXES });
     }
     const elapsed = performance.now() - start;
@@ -69,7 +69,7 @@ describe('Layer 7 — scale stress (P4: 10 000 concepts)', () => {
     const concepts = makeConcepts(SCALE_CONCEPT_COUNT);
     const start = performance.now();
     for (const { concept } of concepts) {
-      const quads = collectQuads(conceptToQuads(concept, { registerId: 'perf', uriBase: BASE }));
+      const quads = collectQuads(conceptToQuads(concept, { registerId: 'perf', uriBase: BASE }) as Generator<Quad>);
       writeTurtleSync(quads, { prefixes: PREFIXES });
     }
     const elapsed = performance.now() - start;
@@ -98,7 +98,7 @@ describe('Layer 7 — scale stress (P4: 10 000 concepts)', () => {
 function timeTurtle(concepts: { concept: Concept; uri: string }[]): number {
   const start = performance.now();
   for (const { concept } of concepts) {
-    const quads = collectQuads(conceptToQuads(concept, { registerId: 'perf', uriBase: BASE }));
+    const quads = collectQuads(conceptToQuads(concept, { registerId: 'perf', uriBase: BASE }) as Generator<Quad>);
     writeTurtleSync(quads, { prefixes: PREFIXES });
   }
   return performance.now() - start;

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

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { Parser, Store } from 'n3';
-import { buildAgentsTurtle as _buildAgentsTurtle } from '../../../scripts/lib/agents-turtle.mjs';
+import { buildAgentsTurtle as _buildAgentsTurtle } from '../../../scripts/lib/agents-turtle';
 
 const buildAgentsTurtle = _buildAgentsTurtle as unknown as (...args: any[]) => Promise<string>;
 

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

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { Parser, Store } from 'n3';
-import { buildBibliographyTurtle } from '../../../scripts/lib/bibliography-turtle.mjs';
+import { buildBibliographyTurtle } from '../../../scripts/lib/bibliography-turtle';
 
 const FOAF = 'http://xmlns.com/foaf/0.1/';
 const DCTERMS = 'http://purl.org/dc/terms/';

package/src/__tests__/scripts/build-activity-turtle.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { Parser, Store } from 'n3';
-import { buildActivityTurtle } from '../../../scripts/lib/build-activity-turtle.mjs';
+import { buildActivityTurtle } from '../../../scripts/lib/build-activity-turtle';
 
 function makeInput(overrides: any = {}): any {
   return {

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

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { rmSync, mkdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { BuildCache } from '../../../scripts/lib/build-cache.mjs';
+import { BuildCache } from '../../../scripts/lib/build-cache';
 
 const SUITE_DIR = join(tmpdir(), `build-cache-${process.pid}-${Date.now()}`);
 

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

@@ -10,12 +10,12 @@ function parseTurtle(text: string): Store {
 }
 
 function runInline(code: string): string {
-  return execFileSync('node', ['--input-type=module', '-e', code], { encoding: 'utf8' }).toString();
+  return execFileSync('node', ['--import', 'tsx', '--input-type=module', '-e', code], { encoding: 'utf8' }).toString();
 }
 
 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(await buildVocabularyTurtle());`);
+  it('vocab-turtle.ts produces parseable Turtle with 7 schemes', () => {
+    const out = runInline(`import { buildVocabularyTurtle } from './scripts/lib/vocab-turtle'; 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' &&
@@ -24,9 +24,9 @@ describe('WS F Layer 8 — build pipeline integration', () => {
     expect(schemes.length).toBe(7);
   });
 
-  it('dataset-turtle.mjs produces parseable dcat:Dataset', () => {
+  it('dataset-turtle.ts produces parseable dcat:Dataset', () => {
     const out = runInline(`
-      import { buildDatasetTurtle } from './scripts/lib/dataset-turtle.mjs';
+      import { buildDatasetTurtle } from './scripts/lib/dataset-turtle';
       console.log(await buildDatasetTurtle({
         datasetIri: 'https://glossarist.org/test/',
         registerId: 'test', title: 'Test', modified: '2026-06-28',
@@ -42,9 +42,9 @@ describe('WS F Layer 8 — build pipeline integration', () => {
     expect(types).toContain('http://www.w3.org/2004/02/skos/core#ConceptScheme');
   });
 
-  it('build-activity-turtle.mjs produces parseable prov:Activity', () => {
+  it('build-activity-turtle.ts produces parseable prov:Activity', () => {
     const out = runInline(`
-      import { buildActivityTurtle } from './scripts/lib/build-activity-turtle.mjs';
+      import { buildActivityTurtle } from './scripts/lib/build-activity-turtle';
       console.log(await buildActivityTurtle({
         baseUri: 'https://glossarist.org',
         runId: 'test', startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:05:00Z',
@@ -59,9 +59,9 @@ describe('WS F Layer 8 — build pipeline integration', () => {
     expect(activities.length).toBe(1);
   });
 
-  it('agents-turtle.mjs produces parseable foaf:Person', () => {
+  it('agents-turtle.ts produces parseable foaf:Person', () => {
     const out = runInline(`
-      import { buildAgentsTurtle } from './scripts/lib/agents-turtle.mjs';
+      import { buildAgentsTurtle } from './scripts/lib/agents-turtle';
       console.log(await buildAgentsTurtle([{ name: 'Ada Lovelace', role: 'Editor', organization: 'Royal Society' }], 'https://glossarist.org/agent', 'https://glossarist.org/org'));
     `);
     const store = parseTurtle(out);
@@ -72,9 +72,9 @@ describe('WS F Layer 8 — build pipeline integration', () => {
     expect(persons.length).toBe(1);
   });
 
-  it('bibliography-turtle.mjs produces parseable dcterms:BibliographicResource', () => {
+  it('bibliography-turtle.ts produces parseable dcterms:BibliographicResource', () => {
     const out = runInline(`
-      import { buildBibliographyTurtle } from './scripts/lib/bibliography-turtle.mjs';
+      import { buildBibliographyTurtle } from './scripts/lib/bibliography-turtle';
       console.log(await buildBibliographyTurtle('test', { iso704: { reference: 'ISO 704' } }, 'https://glossarist.org'));
     `);
     const store = parseTurtle(out);
@@ -85,9 +85,9 @@ describe('WS F Layer 8 — build pipeline integration', () => {
     expect(bibs.length).toBe(1);
   });
 
-  it('version-turtle.mjs produces parseable prov:Entity chain', () => {
+  it('version-turtle.ts produces parseable prov:Entity chain', () => {
     const out = runInline(`
-      import { buildVersionHistoryTurtle } from './scripts/lib/version-turtle.mjs';
+      import { buildVersionHistoryTurtle } from './scripts/lib/version-turtle';
       console.log(await buildVersionHistoryTurtle({
         registerId: 'test', datasetIri: 'https://glossarist.org/test/',
         versions: [
@@ -113,12 +113,12 @@ describe('WS F Layer 8 — build pipeline integration', () => {
 
   it('all six emitters produce parseable output in a single subprocess', () => {
     const out = runInline(`
-      import { buildVocabularyTurtle } from './scripts/lib/vocab-turtle.mjs';
-      import { buildDatasetTurtle } from './scripts/lib/dataset-turtle.mjs';
-      import { buildActivityTurtle } from './scripts/lib/build-activity-turtle.mjs';
-      import { buildAgentsTurtle } from './scripts/lib/agents-turtle.mjs';
-      import { buildBibliographyTurtle } from './scripts/lib/bibliography-turtle.mjs';
-      import { buildVersionHistoryTurtle } from './scripts/lib/version-turtle.mjs';
+      import { buildVocabularyTurtle } from './scripts/lib/vocab-turtle';
+      import { buildDatasetTurtle } from './scripts/lib/dataset-turtle';
+      import { buildActivityTurtle } from './scripts/lib/build-activity-turtle';
+      import { buildAgentsTurtle } from './scripts/lib/agents-turtle';
+      import { buildBibliographyTurtle } from './scripts/lib/bibliography-turtle';
+      import { buildVersionHistoryTurtle } from './scripts/lib/version-turtle';
       const parts = [
         await buildVocabularyTurtle(),
         await buildDatasetTurtle({ datasetIri: 'https://glossarist.org/test/', registerId: 'test', title: 't', modified: '2026-01-01', languages: ['eng'], distributions: [], topConceptUris: [], sections: [] }),