glossarist 0.4.50 → 0.4.51

package/src/reference-resolver.ts

@@ -1,361 +0,0 @@
-import { ConceptRef } from './models/concept-ref.js';
-import { parseMention } from './reference-mention.js';
-
-export class Reference {
-  constructor(type, target, relationship, source, extras = {}) {
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    this.type = type;
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    this.target = target;
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    this.relationship = relationship ?? null;
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    this.source = source ?? null;
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    this.uri = extras.uri ?? null;
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    this.citation = extras.citation ?? null;
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    this.sourceId = extras.sourceId ?? null;
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    this.resolution = extras.resolution ?? null;
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    this.lookupKey = extras.lookupKey ?? null;
-  }
-
-  get dedupKey() {
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    if (this.type === 'bibliography') {
-      return ['bibliography',
-        // @ts-expect-error TODO(Phase 2e): type this fully
-        this.sourceId ?? this.citation?.ref?.id ?? this.target];
-    }
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    if (this.type === 'figure' || this.type === 'table' || this.type === 'formula') {
-      // @ts-expect-error TODO(Phase 2e): type this fully
-      return [this.type, this.lookupKey?.entityId ?? this.target];
-    }
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    if (this.type === 'concept') {
-      return ['concept',
-        // @ts-expect-error TODO(Phase 2e): type this fully
-        this.lookupKey?.id ?? this.lookupKey?.designation ?? this.target];
-    }
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    return [this.type, this.target];
-  }
-}
-
-function refTarget(rc) {
-  if (rc.content) return rc.content;
-  if (rc.ref instanceof ConceptRef) {
-    return rc.ref.id ?? rc.ref.source ?? '';
-  }
-  return '';
-}
-
-// Extract a concept-ref target from a hyperedge comprehensive/part
-// ConceptRef. Returns the id (preferred) or source. Returns '' if
-// the ref is empty (the constructor already rejects empty refs; this
-// is a defensive guard for data that bypassed the constructor).
-function hyperedgeRefTarget(ref) {
-  if (!ref) return '';
-  if (ref.id) return ref.id;
-  if (ref.source) return ref.source;
-  return '';
-}
-
-export function resolveBibliographyRecord(citationRef, registry) {
-  if (!citationRef?.source || !citationRef?.id) return null;
-  const bioColl = registry[`bibliography:${citationRef.source}`]?.concepts;
-  if (!bioColl) return null;
-  if (citationRef.version) {
-    return bioColl.byIdAnd(citationRef.id, citationRef.version);
-  }
-  return bioColl.byId(citationRef.id);
-}
-
-export function findNonVerbalEntity(ref, registry) {
-  const { entityType, entityId } = ref.lookupKey ?? {};
-  if (!entityType || !entityId) return null;
-  const collection = registry[`nvr:${entityType}`];
-  if (!collection) return null;
-  for (const entity of collection) {
-    const found = entity.findById(entityId);
-    if (found) return found;
-  }
-  return null;
-}
-
-export class ReferenceResolver {
-  extractReferences(concept) {
-    const refs = [];
-
-    for (const rc of concept.relatedConcepts) {
-      const target = refTarget(rc);
-      if (target) {
-        // @ts-expect-error TODO(Phase 2e): type this fully
-        refs.push(new Reference('concept', target, rc.type, 'relatedConcepts', {
-          lookupKey: { id: target },
-        }));
-      }
-    }
-
-    // All hyperedges (Partitive + Generic + future types) live in
-    // concept.relations. Each has a comprehensive ConceptRef and 2+
-    // members each carrying a ConceptRef. The reference type is the
-    // relation's typeTag (partitive_relation, generic_relation, …).
-    const relations = concept.relations ?? [];
-    for (let i = 0; i < relations.length; i++) {
-      const rel = relations[i];
-      const relType = rel?.constructor?.typeTag ?? 'hyperedge';
-      const relPath = `relations[${i}]`;
-
-      const compTarget = hyperedgeRefTarget(rel.comprehensive);
-      if (compTarget) {
-        // @ts-expect-error TODO(Phase 2e): type this fully
-        refs.push(new Reference(
-          'concept',
-          compTarget,
-          relType,
-          `${relPath}.comprehensive`,
-          { lookupKey: { id: compTarget } },
-        ));
-      }
-
-      // Member shape: members is [{ ref, presence, count, is_delimiting }, ...]
-      // (HyperedgeMember / PartitiveMember / GenericMember). The wire
-      // alias .partitives is also handled for backward compat with v2 wire consumers.
-      const members = rel.members ?? rel.partitives ?? rel.parts ?? [];
-      for (let j = 0; j < members.length; j++) {
-        const m = members[j];
-        const memberRef = m?.ref ?? m;
-        const pTarget = hyperedgeRefTarget(memberRef);
-        if (!pTarget) continue;
-        // @ts-expect-error TODO(Phase 2e): type this fully
-        refs.push(new Reference(
-          'concept',
-          pTarget,
-          relType,
-          `${relPath}.members[${j}]`,
-          { lookupKey: { id: pTarget } },
-        ));
-      }
-    }
-
-    for (const ref of concept.figures) {
-      // @ts-expect-error TODO(Phase 2e): type this fully
-      refs.push(new Reference('figure', ref.display ?? ref.entityId, 'structural', 'figures', {
-        lookupKey: { entityType: 'figure', entityId: ref.entityId },
-      }));
-    }
-    for (const ref of concept.tables) {
-      // @ts-expect-error TODO(Phase 2e): type this fully
-      refs.push(new Reference('table', ref.display ?? ref.entityId, 'structural', 'tables', {
-        lookupKey: { entityType: 'table', entityId: ref.entityId },
-      }));
-    }
-    for (const ref of concept.formulas) {
-      // @ts-expect-error TODO(Phase 2e): type this fully
-      refs.push(new Reference('formula', ref.display ?? ref.entityId, 'structural', 'formulas', {
-        lookupKey: { entityType: 'formula', entityId: ref.entityId },
-      }));
-    }
-
-    for (const lang of concept.languages) {
-      const lc = concept.localization(lang);
-      if (!lc) continue;
-
-      for (let i = 0; i < lc.sources.length; i++) {
-        const src = lc.sources[i];
-        const ref = src.origin?.toString() ?? '';
-        if (ref) {
-          // @ts-expect-error TODO(Phase 2e): type this fully
-          refs.push(new Reference('standard', ref, src.type, `localizations.${lang}.sources[${i}]`));
-        }
-      }
-
-      for (const { text, source } of lc.walkTexts(`localizations.${lang}`)) {
-        for (const ref of this._extractFromText(text, source, concept)) {
-          refs.push(ref);
-        }
-      }
-    }
-
-    return this._dedup(refs);
-  }
-
-  _dedup(refs) {
-    const seen = new Set();
-    return refs.filter(ref => {
-      const key = JSON.stringify(ref.dedupKey);
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    });
-  }
-
-  _extractFromText(text, source, concept) {
-    const refs = [];
-    const re = /\{\{([^{}]*?)\}\}/g;
-    let m;
-    while ((m = re.exec(text)) !== null) {
-      const parsed = parseMention(m[1]);
-      switch (parsed.kind) {
-        case 'cite-ref':
-          // @ts-expect-error TODO(Phase 2e): type this fully
-          refs.push(this._resolveCiteRef(parsed, source, concept));
-          break;
-        case 'urn-ref':
-          // @ts-expect-error TODO(Phase 2e): type this fully
-          refs.push(new Reference('concept', parsed.label ?? parsed.uri, 'embedded', source, {
-            uri: parsed.uri,
-            resolution: null,
-          }));
-          break;
-        case 'fig-ref':
-          // @ts-expect-error TODO(Phase 2e): type this fully
-          refs.push(new Reference('figure', parsed.label ?? parsed.key, 'embedded', source, {
-            lookupKey: { entityType: 'figure', entityId: parsed.key },
-          }));
-          break;
-        case 'table-ref':
-          // @ts-expect-error TODO(Phase 2e): type this fully
-          refs.push(new Reference('table', parsed.label ?? parsed.key, 'embedded', source, {
-            lookupKey: { entityType: 'table', entityId: parsed.key },
-          }));
-          break;
-        case 'formula-ref':
-          // @ts-expect-error TODO(Phase 2e): type this fully
-          refs.push(new Reference('formula', parsed.label ?? parsed.key, 'embedded', source, {
-            lookupKey: { entityType: 'formula', entityId: parsed.key },
-          }));
-          break;
-        case 'numeric':
-          // @ts-expect-error TODO(Phase 2e): type this fully
-          refs.push(new Reference('concept', parsed.label ?? parsed.id, 'embedded', source, {
-            lookupKey: { id: parsed.id },
-          }));
-          break;
-        case 'designation':
-          // @ts-expect-error TODO(Phase 2e): type this fully
-          refs.push(new Reference('concept', parsed.label ?? parsed.id, 'embedded', source, {
-            lookupKey: { designation: parsed.id },
-          }));
-          break;
-        case 'unresolved':
-          break;
-      }
-    }
-    return refs;
-  }
-
-  _resolveCiteRef(parsed, source, concept) {
-    const sourceEntry = concept?.findSourceById(parsed.key) ?? null;
-    if (!sourceEntry) {
-      return new Reference(
-        'bibliography',
-        parsed.label ?? parsed.key,
-        null,
-        source,
-        {
-          sourceId: parsed.key,
-          citation: null,
-          resolution: { kind: 'unresolved', reason: 'no-source' },
-        },
-      );
-    }
-    const displayTarget = parsed.label
-      ?? sourceEntry.origin?.toString()
-      ?? sourceEntry.id;
-    return new Reference(
-      'bibliography',
-      displayTarget,
-      null,
-      source,
-      {
-        sourceId: sourceEntry.id,
-        citation: sourceEntry.origin,
-        resolution: { kind: 'resolved', sourceId: sourceEntry.id },
-      },
-    );
-  }
-
-  resolveReference(ref, registry) {
-    if (ref == null || registry == null) return null;
-
-    switch (ref.type) {
-      case 'concept':      return this._resolveConcept(ref, registry);
-      case 'bibliography': return this._resolveBibliography(ref, registry);
-      case 'figure':
-      case 'table':
-      case 'formula':      return this._resolveNonVerbal(ref, registry);
-      case 'dataset':      return this._resolveDataset(ref, registry);
-      case 'typed-ref':    return this._resolveTypedRef(ref, registry);
-      case 'standard':     return this._resolveStandard(ref, registry);
-      default:             return null;
-    }
-  }
-
-  _resolveNonVerbal(ref, registry) {
-    return findNonVerbalEntity(ref, registry);
-  }
-
-  _resolveConcept(ref, registry) {
-    if (ref.lookupKey?.id) {
-      const dataset = ref.lookupKey.dataset;
-      if (dataset) {
-        return registry[dataset]?.concepts?.byId(ref.lookupKey.id) ?? null;
-      }
-      for (const entry of Object.values(registry)) {
-        // @ts-expect-error TODO(Phase 2e): type this fully
-        const found = entry?.concepts?.byId(ref.lookupKey.id);
-        if (found) return found;
-      }
-      return null;
-    }
-    if (ref.uri && ref.resolution?.datasetId) {
-      return registry[ref.resolution.datasetId]?.concepts?.byId(ref.resolution.conceptId) ?? null;
-    }
-    return null;
-  }
-
-  _resolveBibliography(ref, registry) {
-    if (ref.citation) {
-      return resolveBibliographyRecord(ref.citation.ref, registry) ?? ref.citation;
-    }
-    if (ref.uri && ref.resolution?.source) {
-      return resolveBibliographyRecord(ref.resolution, registry) ?? null;
-    }
-    return null;
-  }
-
-  _resolveDataset(_ref, _registry) {
-    return null;
-  }
-
-  _resolveTypedRef(_ref, _registry) {
-    return null;
-  }
-
-  _resolveStandard(_ref, _registry) {
-    return null;
-  }
-
-  resolveAll(concept, registry) {
-    const resolved = new Map();
-    for (const ref of this.extractReferences(concept)) {
-      if (ref.type === 'concept' || ref.type === 'bibliography'
-          || ref.type === 'figure' || ref.type === 'table' || ref.type === 'formula') {
-        const target = this.resolveReference(ref, registry);
-        if (target != null) {
-          const key = ref.target ?? ref.uri ?? ref.sourceId;
-          if (key != null) resolved.set(key, target);
-        }
-      }
-    }
-    return resolved;
-  }
-}
-
-export const referenceResolver = new ReferenceResolver();

package/src/render-classification.ts

@@ -1,85 +0,0 @@
-import { resolveBibliographyRecord, findNonVerbalEntity } from './reference-resolver.js';
-
-export class ReferenceClassifier {
-  constructor(registry = {}, sourceDatasetId = null, options = {}) {
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    this.registry = registry;
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    this.sourceDatasetId = sourceDatasetId;
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    this.options = options;
-  }
-
-  classify(ref) {
-    if (ref == null) return 'unknown';
-
-    switch (ref.type) {
-      case 'concept':      return this._classifyConcept(ref);
-      case 'dataset':      return this._classifyDataset(ref);
-      case 'bibliography': return this._classifyBibliography(ref);
-      case 'figure':
-      case 'table':
-      case 'formula':      return this._classifyNonVerbal(ref);
-      case 'typed-ref':    return this._classifyTypedRef(ref);
-      case 'standard':     return 'legacy-standard';
-      default:             return 'unknown';
-    }
-  }
-
-  _classifyConcept(ref) {
-    if (ref.uri) {
-      const dsId = ref.resolution?.datasetId;
-      if (!dsId) return 'unresolved';
-      // @ts-expect-error TODO(Phase 2e): type this fully
-      if (!this.registry[dsId]) return 'external-citation';
-      // @ts-expect-error TODO(Phase 2e): type this fully
-      if (dsId === this.sourceDatasetId) return 'same-dataset';
-      return 'cross-dataset';
-    }
-    if (ref.lookupKey?.designation) {
-      return 'unresolved-designation';
-    }
-    if (ref.lookupKey?.id) {
-      const dsId = ref.lookupKey.dataset;
-      // @ts-expect-error TODO(Phase 2e): type this fully
-      if (!this.registry[dsId]) return 'unresolved';
-      // @ts-expect-error TODO(Phase 2e): type this fully
-      if (dsId === this.sourceDatasetId) return 'same-dataset';
-      return 'cross-dataset';
-    }
-    return 'unresolved';
-  }
-
-  _classifyDataset(ref) {
-    if (ref.resolution?.kind === 'dataset-self') return 'dataset-self';
-    if (ref.resolution?.kind === 'dataset-namespace') return 'dataset-self';
-    return 'unknown';
-  }
-
-  _classifyBibliography(ref) {
-    if (ref.citation) {
-      // @ts-expect-error TODO(Phase 2e): type this fully
-      return resolveBibliographyRecord(ref.citation.ref, this.registry)
-        ? 'internal-citation'
-        : 'self-contained-citation';
-    }
-    if (ref.uri) {
-      // @ts-expect-error TODO(Phase 2e): type this fully
-      return resolveBibliographyRecord(ref.resolution, this.registry)
-        ? 'internal-citation'
-        : 'external-citation';
-    }
-    return 'unresolved-citation';
-  }
-
-  _classifyTypedRef(_ref) {
-    return 'typed-ref';
-  }
-
-  _classifyNonVerbal(ref) {
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    return findNonVerbalEntity(ref, this.registry)
-      ? 'internal-citation'
-      : 'external-citation';
-  }
-}

package/src/sort.ts

@@ -1,22 +0,0 @@
-const NATURAL_SORT_RE = /(\d+|\D+)/g;
-const DIGIT_RE = /^\d+$/;
-
-/**
- * Natural sort comparator for concept IDs like "3.1.1.1", "551-12-39".
- */
-export function naturalSort(a: string, b: string): number {
-  const pa = a.match(NATURAL_SORT_RE) || [];
-  const pb = b.match(NATURAL_SORT_RE) || [];
-  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-    const na = pa[i] || '';
-    const nb = pb[i] || '';
-    if (DIGIT_RE.test(na) && DIGIT_RE.test(nb)) {
-      const diff = parseInt(na, 10) - parseInt(nb, 10);
-      if (diff !== 0) return diff;
-    } else {
-      const cmp = na.localeCompare(nb);
-      if (cmp !== 0) return cmp;
-    }
-  }
-  return 0;
-}

package/src/transforms/concept-to-gloss.transform.ts

@@ -1,81 +0,0 @@
-// ConceptToGlossTransform — converts a Concept model into RDF.
-//
-// Usage:
-//   const xform = new ConceptToGlossTransform({ registerId: 'iso-6709', uriBase: 'https://example.org' });
-//   const ttl = await xform.toTurtle(concept);
-
-import { conceptToQuads } from '../rdf/gloss-concept.js';
-import {
-  collectQuads,
-  writeTurtle,
-  writeNTriples,
-  writeJsonld,
-} from '../rdf/document-writer.js';
-
-type QuadLike = unknown;
-type ConceptLike = { registerId?: string; id?: string | number } & Record<string, unknown>;
-
-interface WriterEntry {
-  write: (quads: QuadLike[] | QuadLike, transform: ConceptToGlossTransform) => Promise<unknown>;
-}
-
-const WRITERS: Readonly<Record<string, WriterEntry>> = Object.freeze({
-  turtle:   { write: (quads) => writeTurtle(quads as QuadLike[]) },
-  ntriples: { write: (quads) => writeNTriples(quads as QuadLike[]) },
-  jsonld:   { write: (quads, t) => writeJsonld(quads as QuadLike[], t._jsonldOpts() as never) },
-});
-
-export class ConceptToGlossTransform {
-  readonly registerId: string | undefined;
-  readonly uriBase: string;
-  readonly jsonldContext: unknown;
-
-  constructor(options: { registerId?: string; uriBase?: string; jsonldContext?: unknown } = {}) {
-    this.registerId = options.registerId;
-    this.uriBase = (options.uriBase ?? '').replace(/\/+$/, '');
-    if (!this.uriBase) {
-      throw new Error(
-        'ConceptToGlossTransform requires options.uriBase — the deployment canonical URI root.',
-      );
-    }
-    this.jsonldContext = options.jsonldContext;
-  }
-
-  toTurtle(target: ConceptLike): Promise<unknown> { return this._serialize(target, 'turtle'); }
-  toTurtleAll(targets: Iterable<ConceptLike>): Promise<unknown> { return this._serialize(targets, 'turtle'); }
-  toJsonld(target: ConceptLike): Promise<unknown> { return this._serialize(target, 'jsonld'); }
-  toJsonldAll(targets: Iterable<ConceptLike>): Promise<unknown> { return this._serialize(targets, 'jsonld'); }
-  toNTriples(target: ConceptLike): Promise<unknown> { return this._serialize(target, 'ntriples'); }
-  toNTriplesAll(targets: Iterable<ConceptLike>): Promise<unknown> { return this._serialize(targets, 'ntriples'); }
-
-  async _serialize(target: ConceptLike | Iterable<ConceptLike>, format: string): Promise<unknown> {
-    const writer = WRITERS[format];
-    if (!writer) throw new Error(`Unknown serialization format: ${format}`);
-    const quads = this._collect(target);
-    return writer.write(quads, this);
-  }
-
-  _collect(target: ConceptLike | Iterable<ConceptLike>): QuadLike[] {
-    if (target && typeof (target as Iterable<ConceptLike>)[Symbol.iterator] === 'function') {
-      const quads: QuadLike[] = [];
-      for (const concept of target as Iterable<ConceptLike>) {
-        for (const q of conceptToQuads(concept as never, this._optsFor(concept))) {
-          quads.push(q);
-        }
-      }
-      return quads;
-    }
-    return collectQuads(conceptToQuads(target as never, this._optsFor(target as ConceptLike)));
-  }
-
-  _optsFor(concept: ConceptLike): { registerId: string; uriBase: string } {
-    return {
-      registerId: this.registerId ?? concept.registerId ?? 'glossary',
-      uriBase: this.uriBase,
-    };
-  }
-
-  _jsonldOpts(): { context?: unknown } {
-    return this.jsonldContext ? { context: this.jsonldContext } : {};
-  }
-}

package/src/transforms/index.d.ts

@@ -1,26 +0,0 @@
-// Type declarations for the public transforms layer.
-//
-// Mirrors the runtime exports of src/transforms/index.js.
-
-import type { Concept } from '../models/index';
-import type { Quad } from '@rdfjs/dataset';
-
-export interface ConceptToGlossTransformOptions {
-  registerId?: string;
-  uriBase?: string;
-  jsonldContext?: Record<string, string>;
-}
-
-export declare class ConceptToGlossTransform {
-  constructor(options?: ConceptToGlossTransformOptions);
-  readonly registerId: string | undefined;
-  readonly uriBase: string;
-  readonly jsonldContext: Record<string, string> | undefined;
-
-  toTurtle(concept: Concept): Promise<string>;
-  toTurtleAll(concepts: Iterable<Concept>): Promise<string>;
-  toJsonld(concept: Concept): Promise<string>;
-  toJsonldAll(concepts: Iterable<Concept>): Promise<string>;
-  toNTriples(concept: Concept): Promise<string>;
-  toNTriplesAll(concepts: Iterable<Concept>): Promise<string>;
-}

package/src/uuid.ts

@@ -1,32 +0,0 @@
-import { createHash } from 'crypto';
-
-const NAMESPACE_UUID = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-
-export function uuidV5(namespace: string, name: string): string {
-  const ns = _parseUuid(namespace);
-  const hash = createHash('sha1').update(ns).update(name, 'utf8').digest();
-  hash[6] = ((hash[6] ?? 0) & 0x0f) | 0x50;
-  hash[8] = ((hash[8] ?? 0) & 0x3f) | 0x80;
-  return _formatUuid(hash);
-}
-
-export function conceptUuid(conceptId: string, namespace: string = NAMESPACE_UUID): string {
-  return uuidV5(namespace, conceptId);
-}
-
-export function localizedConceptUuid(
-  conceptId: string,
-  languageCode: string,
-  namespace: string = NAMESPACE_UUID,
-): string {
-  return uuidV5(namespace, `${conceptId}:${languageCode}`);
-}
-
-function _parseUuid(str: string): Buffer {
-  return Buffer.from(str.replace(/-/g, ''), 'hex');
-}
-
-function _formatUuid(hash: Buffer): string {
-  const h = hash.toString('hex');
-  return [h.slice(0, 8), h.slice(8, 12), h.slice(12, 16), h.slice(16, 20), h.slice(20, 32)].join('-');
-}

package/src/v1-reader.ts

@@ -1,66 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import * as yaml from 'js-yaml';
-import { Concept } from './models/concept.js';
-import { InvalidInputError } from './errors.js';
-
-export class V1Reader {
-  static isV1Directory(dir) {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    return entries.some(e =>
-      e.isDirectory() && fs.existsSync(path.join(dir, e.name, 'concept.yaml'))
-    );
-  }
-
-  static readConcept(conceptDir) {
-    const conceptFile = path.join(conceptDir, 'concept.yaml');
-    if (!fs.existsSync(conceptFile)) {
-      throw new InvalidInputError(`No concept.yaml found in ${conceptDir}`);
-    }
-
-    const data = yaml.load(fs.readFileSync(conceptFile, 'utf8'));
-    const localizations = {};
-
-    for (const file of fs.readdirSync(conceptDir)) {
-      if (file === 'concept.yaml' || !file.endsWith('.yaml')) continue;
-      const lang = file.slice(0, -'.yaml'.length);
-      localizations[lang] = yaml.load(fs.readFileSync(path.join(conceptDir, file), 'utf8'));
-    }
-
-    return new Concept({
-      // @ts-expect-error TODO(Phase 2e): type this fully
-      id: String(data.termid ?? data.data?.identifier ?? path.basename(conceptDir)),
-      // @ts-expect-error TODO(Phase 2e): type this fully
-      term: data.term ?? null,
-      localizations,
-      raw: data,
-    });
-  }
-
-  static readAll(dir) {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    const concepts = [];
-
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const conceptDir = path.join(dir, entry.name);
-      if (!fs.existsSync(path.join(conceptDir, 'concept.yaml'))) continue;
-      try {
-        // @ts-expect-error TODO(Phase 2e): type this fully
-        concepts.push(V1Reader.readConcept(conceptDir));
-      } catch { /* skip unreadable concepts */ }
-    }
-
-    return concepts;
-  }
-}
-
-export async function migrateV1ToV2(v1Dir, v2Dir) {
-  const concepts = V1Reader.readAll(v1Dir);
-  const { writeConcept } = await import('./concept-writer.js');
-  fs.mkdirSync(v2Dir, { recursive: true });
-
-  for (const concept of concepts) {
-    writeConcept(v2Dir, concept, 'canonical');
-  }
-}