@glossarist/concept-browser 0.7.114 → 0.7.116

package/scripts/build-edges.ts

@@ -0,0 +1,572 @@
+import { buildConceptUri } from './lib/concept-uri';
+
+const VALID_COMPLETENESS = new Set(['complete', 'partial']);
+
+function validateCompleteness(value) {
+  if (value == null) return 'complete';
+  if (!VALID_COMPLETENESS.has(value)) {
+    throw new Error(
+      `Invalid partitive relation completeness: "${value}". Allowed: complete, partial`,
+    );
+  }
+  return value;
+}
+
+/**
+ * Resolve a partitive member's multiplicity from JSON-LD.
+ *
+ * Reads gl:multiplicity first (v3 wire shape, ISO 704:2022). Falls back
+ * to migrating from gl:certainty (v2 wire shape) for one release cycle
+ * until upstream emits multiplicity natively.
+ *
+ *   confirmed → compulsory
+ *   possible  → optional
+ */
+const VALID_PRESENCE = new Set(['required', 'optional']);
+const VALID_COUNT = new Set(['exactly_one', 'at_least_one', 'multiple']);
+const LEGACY_MULTIPLICITY_MAP = {
+  compulsory:               { presence: 'required', count: 'exactly_one' },
+  optional:                 { presence: 'optional', count: 'exactly_one' },
+  compulsory_multiple:      { presence: 'required', count: 'multiple' },
+  optional_multiple:        { presence: 'optional', count: 'multiple' },
+  compulsory_at_least_one:  { presence: 'required', count: 'at_least_one' },
+};
+
+function resolvePresence(member) {
+  const p = member['gl:presence'] ?? member.presence;
+  if (p != null) {
+    if (!VALID_PRESENCE.has(p)) throw new Error(`Invalid presence: "${p}"`);
+    return p;
+  }
+  return migrateMultiplicity(member).presence;
+}
+
+function resolveCount(member) {
+  const c = member['gl:count'] ?? member.count;
+  if (c != null) {
+    if (!VALID_COUNT.has(c)) throw new Error(`Invalid count: "${c}"`);
+    return c;
+  }
+  return migrateMultiplicity(member).count;
+}
+
+function migrateMultiplicity(member) {
+  const m = member['gl:multiplicity'] ?? member.multiplicity;
+  if (m && LEGACY_MULTIPLICITY_MAP[m]) return LEGACY_MULTIPLICITY_MAP[m];
+  const certainty = member['gl:certainty'] ?? member.certainty;
+  if (certainty === 'possible') return { presence: 'optional', count: 'exactly_one' };
+  return { presence: 'required', count: 'exactly_one' };
+}
+
+function resolveIsDelimiting(member) {
+  return member['gl:isDelimiting'] === true || member.isDelimiting === true;
+}
+
+function normalizeLocalizedString(content) {
+  if (content == null) return undefined;
+  if (typeof content === 'string') return { default: content };
+  return content;
+}
+
+
+/**
+ * Pre-computes cross-reference and domain edges for each dataset.
+ * Reads all concept JSON files, extracts structured references and
+ * authoritative sources (domains), and writes edges.json + domain-nodes.json.
+ *
+ * Usage: node scripts/build-edges.js
+ */
+import { extractSourceRefs } from './extract-source-refs.js';
+import { readFileSync, writeFileSync, readdirSync, existsSync, realpathSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import yaml from 'js-yaml';
+import { Register } from 'glossarist';
+
+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) {
+  const edges: Record<string, any>[] = [];
+  const sourceUri = concept['@id'];
+  for (const [lang, lc] of Object.entries(concept['gl:localizedConcept'] || {}) as [string, any][]) {
+    if (lc['gl:references']) {
+      for (const ref of lc['gl:references'] as Record<string, any>[]) {
+        if (ref['@id'] && ref['@id'] !== sourceUri) {
+          const edge: Record<string, any> = {
+            source: sourceUri,
+            target: ref['@id'],
+            type: ref['@id'].startsWith('cite:') ? 'citation' : 'references',
+            label: ref['gl:term'] || undefined,
+            register: registerId,
+            lang,
+          };
+          if (ref['gl:sourceId']) edge.sourceId = ref['gl:sourceId'];
+          edges.push(edge);
+        }
+      }
+    }
+  }
+  return edges;
+}
+
+function extractDomains(concept, registerId, uriBase) {
+  if (!uriBase) throw new Error('build-edges: uriBase is required — set uriBase in site-config.yml');
+  const base = uriBase;
+  const edges = [];
+  const sourceUri = concept['@id'];
+  const seen = new Set();
+
+  // v3 managed concept-level section/domain references
+  const domains = concept['gl:domain'];
+  if (Array.isArray(domains)) {
+    for (const d of domains) {
+      const conceptId = d['gl:conceptId'] || d.concept_id;
+      if (conceptId) {
+        const refType = d['gl:refType'] || d.ref_type || 'domain';
+        const isSection = refType === 'section';
+        const edgeType = isSection ? 'section' : 'domain';
+        const domainUri = `${base}/${registerId}/domain/${conceptId}`;
+        if (!seen.has(domainUri)) {
+          seen.add(domainUri);
+          edges.push({
+            source: sourceUri,
+            target: domainUri,
+            type: edgeType,
+            label: conceptId,
+            register: registerId,
+          });
+        }
+      }
+    }
+  }
+
+  // Legacy: localized domain strings
+  const lcs = concept['gl:localizedConcept'] || {};
+  const langs = Object.keys(lcs);
+  for (const lang of langs) {
+    const domain = lcs[lang]['gl:domain'];
+    if (domain && !seen.has(domain)) {
+      seen.add(domain);
+      edges.push({
+        source: sourceUri,
+        target: `${base}/${registerId}/domain/${slugify(domain)}`,
+        type: 'domain',
+        label: domain,
+        register: registerId,
+      });
+    }
+  }
+  return edges;
+}
+
+function extractRelated(concept, registerId, uriBase, urnMap) {
+  const edges = [];
+  const sourceUri = concept['@id'];
+  for (const r of concept['gl:related'] || []) {
+    const ref = r['gl:ref'];
+    if (!ref) continue;
+    const source = ref['gl:source'] || ref['source'];
+    const id = ref['gl:id'] || ref['id'];
+    if (!source || !id) continue;
+    const reg = urnMap.get(source) || source;
+    const target = buildConceptUri(uriBase, reg, id);
+    if (target === sourceUri) continue;
+    edges.push({
+      source: sourceUri,
+      target,
+      type: r['gl:relationshipType'] || 'references',
+      label: r['gl:term'] || undefined,
+      register: reg,
+    });
+  }
+  return edges;
+}
+
+/**
+ * Extracts partitive relations from a concept's gl:partitiveRelations
+ * array. Returns relation objects (NOT binary GraphEdges) so the UI
+ * can render them with their full set-based semantics: comprehensive +
+ * partitives (each with certainty), completeness, plurality, and
+ * criterion.
+ *
+ * Relations are written to partitive_relations.json, keeping
+ * edges.json binary-only.
+ *
+ * v2 shape per concept-model/TODO.partitive-relation-v2.
+ */
+function extractPartitiveRelations(concept, registerId, uriBase, urnMap) {
+  const relations = [];
+  const sourceUri = concept['@id'];
+  for (const rel of concept['gl:partitiveRelations'] || []) {
+    const compRef = rel['gl:comprehensive'];
+    if (!compRef) continue;
+    const comprehensive = resolveConceptUri(compRef, uriBase, urnMap);
+    if (!comprehensive) continue;
+
+    const partitives = (rel['gl:hasPartitive'] || [])
+      .map(p => {
+        const memberRef = p['gl:ref'] || p;
+        const uri = resolveConceptUri(memberRef, uriBase, urnMap);
+        if (!uri || uri === sourceUri) return null;
+        return {
+          uri,
+          presence: resolvePresence(p),
+          count: resolveCount(p),
+          isDelimiting: resolveIsDelimiting(p),
+        };
+      })
+      .filter(p => p !== null);
+
+    if (partitives.length === 0) continue;
+
+    relations.push({
+      source: sourceUri,
+      comprehensive,
+      partitives,
+      completeness: validateCompleteness(rel['gl:completeness']),
+      criterion: normalizeLocalizedString(rel['gl:criterion']),
+      register: registerId,
+    });
+  }
+  return relations;
+}
+
+function resolveConceptUri(ref, uriBase, urnMap) {
+  const source = ref['gl:source'] || ref['source'];
+  const id = ref['gl:id'] || ref['id'];
+  if (!source || !id) return null;
+  const reg = urnMap.get(source) || source;
+  return buildConceptUri(uriBase, reg, id);
+}
+
+const EXTRACTORS = [extractReferences, extractRelated, extractDomains];
+
+function extractAllEdges(concept, registerId, uriBase, urnMap) {
+  return EXTRACTORS.flatMap(fn => fn(concept, registerId, uriBase, urnMap));
+}
+
+/**
+ * Per concept-model TODO.partitive-relation-v2 item 14:
+ * a PartitiveRelation A → {b, c, d} subsumes binary has_part edges
+ * for the same pairs. Warn (don't fail) when both encodings exist.
+ *
+ * Binary edge types considered partitive: has_part, is_part_of,
+ * broader_partitive, narrower_partitive.
+ */
+const BINARY_PARTITIVE_TYPES = new Set(['has_part', 'is_part_of', 'broader_partitive', 'narrower_partitive']);
+
+function warnBinaryPartitiveRedundancy(edges, relations, registerId) {
+  if (!relations?.length) return;
+  const partitivePairs = new Set();
+  for (const rel of relations) {
+    for (const member of rel.partitives ?? []) {
+      const memberUri = member.uri ?? member;
+      partitivePairs.add(`${rel.comprehensive}|${memberUri}`);
+      partitivePairs.add(`${memberUri}|${rel.comprehensive}`);
+    }
+  }
+  const redundant = edges.filter(e =>
+    BINARY_PARTITIVE_TYPES.has(e.type)
+    && partitivePairs.has(`${e.source}|${e.target}`),
+  );
+  if (redundant.length > 0) {
+    console.warn(
+      `  ⚠ ${registerId}: ${redundant.length} binary has_part/is_part_of edge(s) duplicate a PartitiveRelation member — prefer the PartitiveRelation encoding (concept-model TODO item 14).`,
+    );
+  }
+}
+
+// --- Build ---
+
+function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest) {
+  const conceptsDir = join(datasetDir, 'concepts');
+  if (!existsSync(conceptsDir)) {
+    console.log(`  Skipping ${registerId}: no concepts directory`);
+    return { edges: [], sourceRefs: [] };
+  }
+
+  const files = readdirSync(conceptsDir).filter(f => f.endsWith('.json'));
+  console.log(`  Processing ${files.length} concepts...`);
+
+  const allEdges = [];
+  const allPartitiveRelations = [];
+  const allSourceRefs = [];
+  const domainConceptCount = new Map();
+  let processed = 0;
+
+  for (const file of files) {
+    try {
+      const data = JSON.parse(readFileSync(join(conceptsDir, file), 'utf-8'));
+      const edges = extractAllEdges(data, registerId, uriBase, urnMap);
+      const relations = extractPartitiveRelations(data, registerId, uriBase, urnMap);
+      warnBinaryPartitiveRedundancy(edges, relations, registerId);
+      allEdges.push(...edges);
+      allPartitiveRelations.push(...relations);
+      allSourceRefs.push(...extractSourceRefs(data, registerId));
+
+      for (const edge of edges) {
+        if (edge.type === 'domain' || edge.type === 'section') {
+          domainConceptCount.set(edge.target, (domainConceptCount.get(edge.target) || 0) + 1);
+        }
+      }
+    } catch (e) {
+      console.error(`  Error processing ${file}: ${e.message}`);
+    }
+    processed++;
+    if (processed % 5000 === 0) {
+      console.log(`  ... ${processed}/${files.length}`);
+    }
+  }
+
+  // Deduplicate edges by source+target+type+lang
+  const seen = new Set();
+  const deduped = [];
+  for (const edge of allEdges) {
+    const key = `${edge.source}→${edge.target}→${edge.type}→${edge.lang || ''}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      deduped.push(edge);
+    }
+  }
+
+  const output = {
+    registerId,
+    edgeCount: deduped.length,
+    edges: deduped,
+  };
+
+  const outputPath = join(datasetDir, 'edges.json');
+  writeFileSync(outputPath, JSON.stringify(output));
+  console.log(`  Written ${deduped.length} edges to edges.json (${(JSON.stringify(output).length / 1024).toFixed(1)} KB)`);
+
+  // Write partitive_relations.json (parallel to edges.json) for one-to-many
+  // partitive decompositions. See TODO.partitive-relation-v2.
+  const relationsOutput = {
+    registerId,
+    relationCount: allPartitiveRelations.length,
+    relations: allPartitiveRelations,
+  };
+  const relationsPath = join(datasetDir, 'partitive_relations.json');
+  writeFileSync(relationsPath, JSON.stringify(relationsOutput));
+  console.log(`  Written ${allPartitiveRelations.length} partitive relations to partitive_relations.json (${(JSON.stringify(relationsOutput).length / 1024).toFixed(1)} KB)`);
+
+  // Build domain-nodes.json from manifest sections (authoritative source)
+  const manifestSections = manifest.sections;
+  if (manifestSections && manifestSections.length > 0) {
+    const uriBase = manifest.uriBase;
+    if (!uriBase) throw new Error('build-edges: manifest.uriBase is required');
+
+    function buildSectionNode(section: Record<string, any>, idx: number): Record<string, any> {
+      const sectionId = `section-${section.id}`;
+      const domainUri = `${uriBase}/${registerId}/domain/${sectionId}`;
+      const domainLabel = section.names?.eng || section.id;
+      const node: Record<string, any> = {
+        uri: domainUri,
+        id: sectionId,
+        names: section.names || {},
+        label: domainLabel,
+        registerId,
+        conceptCount: domainConceptCount.get(domainUri) || 0,
+        order: idx,
+      };
+      if (section.children && section.children.length > 0) {
+        node.children = section.children.map((child, childIdx) =>
+          buildSectionNode(child, childIdx)
+        );
+      }
+      return node;
+    }
+
+    const domainNodes = manifestSections.map((section, idx) =>
+      buildSectionNode(section, idx)
+    );
+
+    const domainOutput = { registerId, domainNodes };
+    const domainPath = join(datasetDir, 'domain-nodes.json');
+    writeFileSync(domainPath, JSON.stringify(domainOutput));
+    console.log(`  Written ${domainNodes.length} section-based domain nodes to domain-nodes.json`);
+  } else {
+    // Fallback: derive domain nodes from concept edges (legacy behavior)
+    const domainEdgeMap = new Map();
+    for (const edge of deduped) {
+      if (edge.type === 'domain') {
+        const existing = domainEdgeMap.get(edge.target);
+        if (existing) {
+          existing.labels.add(edge.label);
+        } else {
+          domainEdgeMap.set(edge.target, { uri: edge.target, labels: new Set([edge.label]), registerId });
+        }
+      }
+    }
+
+    const domainNodes = [...domainEdgeMap.values()].map(d => ({
+      uri: d.uri,
+      label: [...d.labels][0],
+      registerId: d.registerId,
+      conceptCount: domainConceptCount.get(d.uri) || 0,
+    })).sort((a, b) => b.conceptCount - a.conceptCount);
+
+    const domainOutput = { registerId, domainNodes };
+    const domainPath = join(datasetDir, 'domain-nodes.json');
+    writeFileSync(domainPath, JSON.stringify(domainOutput));
+    console.log(`  Written ${domainNodes.length} edge-derived domain nodes to domain-nodes.json`);
+  }
+
+  return { edges: deduped, sourceRefs: allSourceRefs };
+}
+
+// Main
+export function main() {
+console.log('Building edge indexes...\n');
+
+if (!existsSync(DATA_DIR)) {
+  console.log('No data directory found. Nothing to do.');
+  process.exit(0);
+}
+
+const datasets = readdirSync(DATA_DIR).filter(f => {
+  try {
+    return existsSync(join(DATA_DIR, f, 'manifest.json'));
+  } catch {
+    return false;
+  }
+});
+
+// Build URI→datasetId prefix map from all manifests
+const urnMap = new Map();
+const manifestCache = new Map();
+for (const ds of datasets) {
+  const manifestPath = join(DATA_DIR, ds, 'manifest.json');
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    manifestCache.set(ds, manifest);
+    if (manifest.datasetUri) {
+      const base = manifest.datasetUri.endsWith('*') ? manifest.datasetUri.slice(0, -1) : manifest.datasetUri;
+      if (base) urnMap.set(base, ds);
+    }
+    for (const alias of manifest.uriAliases ?? []) {
+      const base = alias.endsWith('*') ? alias.slice(0, -1) : alias;
+      if (base) urnMap.set(base, ds);
+    }
+  } catch {}
+}
+console.log(`URI resolution map: ${[...urnMap.entries()].map(([k,v]) => `${k}→${v}`).join(', ')}\n`);
+
+const allDatasetEdges = new Map();
+const allSourceRefs = [];
+
+for (const ds of datasets) {
+  const manifest = manifestCache.get(ds);
+  if (!manifest) continue;
+  try {
+    console.log(`${manifest.title} (${ds}):`);
+    const uriBase = manifest.uriBase;
+    if (!uriBase) throw new Error('build-edges: manifest.uriBase is required');
+    const result = buildEdgesForDataset(join(DATA_DIR, ds), ds, uriBase, urnMap, manifest);
+    allDatasetEdges.set(ds, result.edges);
+    allSourceRefs.push(...result.sourceRefs);
+  } catch (e) {
+    console.error(`Error reading manifest for ${ds}: ${e.message}`);
+  }
+  console.log();
+}
+
+// Audit — report concept source strings not covered by manifest refs.
+// Bibliography mapping (ref → URN) is declared in register.yaml and flows
+// through manifest.json to datasets.json at generate time. No separate
+// source-refs file needed — the registry IS the single source of truth.
+
+// Build a lookup of all known source strings from manifests
+const knownSourceStrings = new Set();
+for (const [ds, manifest] of manifestCache) {
+  if (manifest.ref) knownSourceStrings.add(manifest.ref);
+  for (const alias of manifest.refAliases ?? []) {
+    knownSourceStrings.add(alias);
+  }
+  if (manifest.datasetUri) {
+    const base = manifest.datasetUri.endsWith('*') ? manifest.datasetUri.slice(0, -1) : manifest.datasetUri;
+    knownSourceStrings.add(base);
+  }
+  for (const alias of manifest.uriAliases ?? []) {
+    const base = alias.endsWith('*') ? alias.slice(0, -1) : alias;
+    knownSourceStrings.add(base);
+  }
+}
+
+const auditUnmatched = new Map();
+for (const { source, registerId } of allSourceRefs) {
+  if (knownSourceStrings.has(source)) continue;
+  // URN source strings resolve via URI routing — not a bibliography concern
+  if (source.startsWith('urn:')) continue;
+  if (!auditUnmatched.has(source)) {
+    auditUnmatched.set(source, registerId);
+  }
+}
+
+if (auditUnmatched.size > 0) {
+  console.warn(`\n⚠ ${auditUnmatched.size} source string(s) in concept data have no matching dataset ref:`);
+  for (const [source, fromDataset] of auditUnmatched) {
+    console.warn(`  "${source}" (from ${fromDataset})`);
+  }
+  console.warn('Add refAliases to the target dataset manifest, or fix source strings to use URNs.\n');
+}
+
+// Build cross-reference index: for each dataset, which other datasets'
+// edges.json contains edges targeting that dataset's URIs.
+const datasetUriPrefixes = new Map<string, string>();
+for (const [ds, manifest] of manifestCache) {
+  const uriBase = manifest.uriBase;
+    if (!uriBase) throw new Error('build-edges: manifest.uriBase is required');
+  datasetUriPrefixes.set(ds, `${uriBase}/${ds}/`);
+}
+
+const crossRefIndex = {};
+for (const ds of datasets) {
+  crossRefIndex[ds] = [];
+}
+
+for (const [sourceDs, edges] of allDatasetEdges) {
+  const targets = new Set<string>();
+  for (const edge of edges) {
+    for (const [targetDs, prefix] of datasetUriPrefixes) {
+      if (targetDs !== sourceDs && edge.target.startsWith(prefix)) {
+        targets.add(targetDs);
+      }
+    }
+    // Also check source URIs targeting other datasets
+    for (const [targetDs, prefix] of datasetUriPrefixes) {
+      if (targetDs !== sourceDs && edge.source.startsWith(prefix)) {
+        targets.add(targetDs);
+      }
+    }
+  }
+  for (const targetDs of targets) {
+    if (!crossRefIndex[targetDs].includes(sourceDs)) {
+      crossRefIndex[targetDs].push(sourceDs);
+    }
+  }
+}
+
+const crossRefPath = join(DATA_DIR, 'cross-ref-index.json');
+writeFileSync(crossRefPath, JSON.stringify(crossRefIndex));
+const refCount = Object.values(crossRefIndex).reduce((sum: number, arr: string[]) => sum + arr.length, 0);
+console.log(`Written cross-ref-index.json (${refCount} cross-references across ${datasets.length} datasets)`);
+
+console.log('Done.');
+}
+
+const isDirectInvocation = process.argv[1]
+  && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+if (isDirectInvocation) {
+  main();
+}

package/scripts/build-scripts.mjs

@@ -0,0 +1,22 @@
+import { build } from 'esbuild';
+import { globSync } from 'glob';
+import { dirname, relative } from 'path';
+
+const files = globSync('scripts/*.ts').filter(f => !f.includes('__tests__'));
+
+await Promise.all(files.map(async (file) => {
+  const outfile = file.replace(/\.ts$/, '.js');
+  await build({
+    entryPoints: [file],
+    bundle: true,
+    format: 'esm',
+    platform: 'node',
+    outfile,
+    packages: 'external',
+    sourcemap: false,
+    logLevel: 'info',
+  });
+  console.log(`  ${relative(process.cwd(), file)} → ${relative(process.cwd(), outfile)}`);
+}));
+
+console.log(`\nCompiled ${files.length} scripts.`);

package/scripts/check-syntax.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+// scripts/check-syntax.ts
+import { spawnSync } from "node:child_process";
+import { readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+var ROOT = path.resolve(path.dirname(new URL(import.meta.url).pathname), "..");
+var TARGET_DIRS = ["scripts", "cli"];
+var JS_EXTENSIONS = /* @__PURE__ */ new Set([".mjs", ".js", ".cjs"]);
+var ALL_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ...JS_EXTENSIONS]);
+var SKIP_DIRS = /* @__PURE__ */ new Set(["__tests__", "node_modules"]);
+function walk(dir) {
+  const out = [];
+  for (const entry of readdirSync(dir)) {
+    if (SKIP_DIRS.has(entry)) continue;
+    const full = path.join(dir, entry);
+    const st = statSync(full);
+    if (st.isDirectory()) {
+      out.push(...walk(full));
+    } else if (ALL_EXTENSIONS.has(path.extname(entry))) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+function checkAllScripts({ root = ROOT } = {}) {
+  const files = [];
+  for (const sub of TARGET_DIRS) {
+    const dir = path.join(root, sub);
+    try {
+      statSync(dir);
+    } catch {
+      continue;
+    }
+    files.push(...walk(dir));
+  }
+  files.sort();
+  const failures = [];
+  for (const file of files.filter((f) => JS_EXTENSIONS.has(path.extname(f)))) {
+    const result = spawnSync(process.execPath, ["--check", file], { encoding: "utf8" });
+    if (result.status !== 0) {
+      failures.push({ file: path.relative(root, file), stderr: result.stderr || "" });
+    }
+  }
+  if (files.some((f) => path.extname(f) === ".ts")) {
+    const tsconfig = path.join(root, "tsconfig.scripts.json");
+    const result = spawnSync("npx", ["tsc", "-p", tsconfig, "--noEmit"], {
+      encoding: "utf8",
+      cwd: root
+    });
+    if (result.status !== 0) {
+      failures.push({ file: "tsconfig.scripts.json (tsc)", stderr: result.stdout || result.stderr || "" });
+    }
+  }
+  return { files, failures };
+}
+function main() {
+  const { files, failures } = checkAllScripts();
+  if (failures.length === 0) {
+    process.stdout.write(`syntax OK: ${files.length} file(s) checked
+`);
+    return;
+  }
+  process.stderr.write(`syntax check failed: ${failures.length} of ${files.length} file(s)
+
+`);
+  for (const { file, stderr } of failures) {
+    process.stderr.write(`--- ${file} ---
+${stderr}
+`);
+  }
+  process.exit(1);
+}
+var isDirectEntry = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(new URL(import.meta.url).pathname);
+if (isDirectEntry) {
+  main();
+}
+export {
+  checkAllScripts
+};