@glossarist/concept-browser 0.7.114 → 0.7.116

package/scripts/validate-shacl.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+// scripts/validate-shacl.ts
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, extname, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Parser as N3Parser } from "n3";
+import rdfDataset from "@rdfjs/dataset";
+import { validateShacl } from "glossarist/rdf/shacl";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var VENDORED_SHAPES = resolve(__dirname, "..", "data", "concept-model", "shapes", "glossarist.shacl.ttl");
+var createDataset = rdfDataset.dataset.bind(rdfDataset);
+function parseArgs(argv) {
+  const out = { dataRoot: "public/data", shapesPath: null };
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--shapes") {
+      out.shapesPath = argv[++i];
+      if (!out.shapesPath) throw new Error("--shapes requires a path argument");
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(USAGE);
+      process.exit(0);
+    } else {
+      out.dataRoot = arg;
+    }
+  }
+  if (process.env.SHAPES_PATH && !out.shapesPath) {
+    out.shapesPath = process.env.SHAPES_PATH;
+  }
+  return out;
+}
+var USAGE = `Usage: validate-shacl.mjs [options] [data-root]
+
+Options:
+  --shapes <path>   Path to a SHACL shapes .ttl file (overrides the default
+                    vendored shapes under data/concept-model/shapes/).
+  --help, -h        Show this help.
+
+Environment:
+  SHAPES_PATH       Same as --shapes. Lower priority than the CLI flag.
+
+Default data-root is public/data.
+`;
+function resolveShapesPath(cliPath) {
+  if (cliPath) return cliPath;
+  if (!statSync(VENDORED_SHAPES, { throwIfNoEntry: false })) {
+    throw new Error(
+      `Vendored SHACL shapes not found at ${VENDORED_SHAPES}.
+Run \`npm run sync:model\` to fetch them from glossarist/concept-model, or pass --shapes <path>, or set SHAPES_PATH=<path>.`
+    );
+  }
+  return VENDORED_SHAPES;
+}
+function parseTurtle(text, baseIri) {
+  const parser = new N3Parser({ baseIRI: baseIri });
+  const out = createDataset();
+  return new Promise((resolve2, reject) => {
+    parser.parse(text, (err, quad) => {
+      if (err) reject(err);
+      else if (quad) out.add(quad);
+      else resolve2(out);
+    });
+  });
+}
+function* walkTtl(dir) {
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) yield* walkTtl(full);
+    else if (extname(full) === ".ttl") yield full;
+  }
+}
+function formatViolation(v) {
+  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("; ") : "(no message)";
+  const pathPart = path ? `
+    path:    ${path}` : "";
+  return `    shape:   ${shape}${pathPart}
+    node:    ${focus}
+    message: ${message}`;
+}
+async function main() {
+  const args = parseArgs(process.argv);
+  const shapesPath = resolveShapesPath(args.shapesPath);
+  let shapesDataset;
+  try {
+    const shapesText = readFileSync(shapesPath, "utf8");
+    shapesDataset = await parseTurtle(shapesText, `file://${shapesPath}`);
+  } catch (e) {
+    console.error(`Failed to load SHACL shapes from ${shapesPath}: ${e.message}`);
+    process.exit(2);
+  }
+  let statDir;
+  try {
+    statDir = statSync(args.dataRoot);
+  } catch (e) {
+    console.error(`Data root not found: ${args.dataRoot}`);
+    process.exit(2);
+  }
+  if (!statDir.isDirectory()) {
+    console.error(`Data root is not a directory: ${args.dataRoot}`);
+    process.exit(2);
+  }
+  const files = [...walkTtl(args.dataRoot)];
+  if (files.length === 0) {
+    console.log(`No .ttl files under ${args.dataRoot} \u2014 SHACL gate skipped.`);
+    return;
+  }
+  const violations = [];
+  for (const path of files) {
+    let graph;
+    try {
+      const text = readFileSync(path, "utf8");
+      graph = await parseTurtle(text, `file://${path}`);
+    } catch (e) {
+      violations.push({ path, parseError: e.message });
+      continue;
+    }
+    const report = await validateShacl(graph, { shapes: shapesDataset });
+    if (!report.conforms) {
+      for (const v of report.results) {
+        violations.push({ path, result: v });
+      }
+    }
+  }
+  if (violations.length === 0) {
+    console.log(`SHACL validation passed \u2014 ${files.length} file(s) conform.`);
+    return;
+  }
+  console.error(`SHACL validation FAILED \u2014 ${violations.length} violation(s) in ${files.length} file(s):
+`);
+  let currentPath = null;
+  for (const v of violations) {
+    if (v.path !== currentPath) {
+      currentPath = v.path;
+      console.error(`
+  ${v.path}`);
+    }
+    if (v.parseError) {
+      console.error(`    PARSE ERROR: ${v.parseError}`);
+    } else {
+      console.error(formatViolation(v.result));
+    }
+  }
+  console.error("");
+  process.exit(1);
+}
+main().catch((e) => {
+  console.error(`validate-shacl: unexpected error: ${e.stack ?? e}`);
+  process.exit(2);
+});

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.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+// scripts/validate-yaml.ts
+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";
+var SCHEMA_PATH = join(cwd(), "data", "concept-model", "shapes", "glossarist.concept.yaml.schema.json");
+function loadSchema() {
+  if (!existsSync(SCHEMA_PATH)) {
+    throw new Error(`Schema not found: ${SCHEMA_PATH}`);
+  }
+  return JSON.parse(readFileSync(SCHEMA_PATH, "utf8"));
+}
+function validateValue(value, schema, path, rootSchema, errors) {
+  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)) {
+      if (value[key] !== void 0) {
+        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)) {
+        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);
+    }
+  }
+}
+function validateYaml(yamlContent, schema) {
+  const data = yaml.load(yamlContent);
+  const errors = [];
+  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) {
+  const out = [];
+  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() {
+  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(`
+${totalValid}/${files.length} files valid, ${totalErrors} errors`);
+  process.exit(totalErrors > 0 ? 1 : 0);
+}
+var isDirect = process.argv[1] && resolve(process.argv[1]) === fileURLToPathPath();
+function fileURLToPathPath() {
+  return resolve(new URL(import.meta.url).pathname);
+}
+if (isDirect) main();
+export {
+  loadSchema,
+  validateValue,
+  validateYaml
+};

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__/published-package-contract.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { resolve, join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..', '..');
+const SCRIPTS_DIR = join(ROOT, 'scripts');
+
+const LIBRARY_SCRIPTS = [
+  'load-site-config',
+  'validate-yaml',
+  'normalize-yaml',
+  'extract-source-refs',
+  'migrate-v1-to-v3',
+];
+
+const PIPELINE_SCRIPTS = [
+  'fetch-datasets',
+  'generate-data',
+  'build-edges',
+  'process-about-pages',
+  'smoke',
+  'generate-ontology-data',
+  'generate-ontology-schema',
+  'doctor',
+  'validate-shacl',
+  'bridge-to-astro',
+  'sync-concept-model',
+  'generate-404',
+];
+
+function runPlain(args: string[], opts?: Parameters<typeof spawnSync>[2]): { status: number | null; stdout: string; stderr: string } {
+  const result = spawnSync('node', args, { encoding: 'utf8', cwd: ROOT, ...opts });
+  return {
+    status: result.status,
+    stdout: typeof result.stdout === 'string' ? result.stdout : result.stdout?.toString('utf8') ?? '',
+    stderr: typeof result.stderr === 'string' ? result.stderr : result.stderr?.toString('utf8') ?? '',
+  };
+}
+
+describe('published-package contract — compiled .js scripts load under plain node (no tsx)', () => {
+  it('npm run build:scripts produces .js for every script', () => {
+    const build = spawnSync('node', [join(ROOT, 'scripts', 'build-scripts.mjs')], {
+      encoding: 'utf8',
+      cwd: ROOT,
+    });
+    expect(build.status).toBe(0);
+
+    for (const name of [...LIBRARY_SCRIPTS, ...PIPELINE_SCRIPTS]) {
+      const jsPath = join(SCRIPTS_DIR, `${name}.js`);
+      expect(existsSync(jsPath)).toBe(true);
+    }
+  }, 30000);
+
+  it('library scripts export functions under plain node (ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING regression)', () => {
+    for (const name of LIBRARY_SCRIPTS) {
+      const jsPath = `./scripts/${name}.js`;
+      const result = runPlain(['--input-type=module', '-e', `import(${JSON.stringify(jsPath)}).then(m => console.log('OK', Object.keys(m).length)).catch(e => { console.error('FAIL', e.message); process.exit(1); })`]);
+      expect(result.stderr).not.toContain('ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING');
+      expect(result.status).toBe(0);
+      expect(result.stdout).toContain('OK');
+    }
+  }, 60000);
+
+  it('pipeline scripts do not throw ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING (may fail on missing config, that is OK)', () => {
+    for (const name of PIPELINE_SCRIPTS) {
+      const result = runPlain(['--input-type=module', '-e', `import(${JSON.stringify(`./scripts/${name}.js`)}).then(() => console.log('OK')).catch(e => { console.error(e.message); })`]);
+      expect(result.stderr).not.toContain('ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING');
+    }
+  }, 60000);
+
+  it('validate-yaml.js exports validateYaml function', () => {
+    const result = runPlain(['--input-type=module', '-e', `
+      import { validateYaml } from './scripts/validate-yaml.js';
+      const schema = { type: 'object', required: ['termid'], properties: { termid: { type: 'string' } } };
+      const r = validateYaml('termid: test', schema);
+      console.log('valid=' + r.valid);
+    `]);
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('valid=true');
+  });
+});

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()}`);