@glossarist/concept-browser 0.7.122 → 0.7.124

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.122",
+  "version": "0.7.124",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {
@@ -43,7 +43,7 @@
     "astro": "^7.0.7",
     "d3": "^7.9.0",
     "favicons": "^7.2.0",
-    "glossarist": "^0.4.54",
+    "glossarist": "^0.4.55",
     "js-yaml": "^4.1.0",
     "jszip": "^3.10.1",
     "n3": "^1.26.0",

package/scripts/generate-data.js

@@ -2,7 +2,7 @@
 import fs2 from "fs";
 import path3 from "path";
 import yaml4 from "js-yaml";
-import { naturalSort, Register, parseMention } from "glossarist";
+import { naturalSort, Register, parseMentions, InvalidMentionError } from "glossarist";
 
 // scripts/load-site-config.ts
 import { readFileSync, existsSync } from "fs";
@@ -1128,54 +1128,6 @@ function resolvePatternRef(identifier, display, refPrefixMap, patternIndex, uriB
   if (!r) return null;
   return { id: buildConceptUri(uriBase, r.datasetId, r.conceptId), term: display };
 }
-function handleCiteRef(parsed, allSources) {
-  const sourceEntry = allSources.find((s) => s.id === parsed.key);
-  if (sourceEntry) {
-    return {
-      id: `cite:${sourceEntry.id}`,
-      term: parsed.label || sourceEntry.origin?.toString?.() || sourceEntry.id,
-      sourceId: sourceEntry.id,
-      citation: sourceEntry.origin || null
-    };
-  }
-  return {
-    id: `cite:${parsed.key}`,
-    term: parsed.label || parsed.key,
-    sourceId: parsed.key,
-    citation: null
-  };
-}
-function handleNumeric(parsed, register, uriBase) {
-  if (!register) return null;
-  const term = parsed.label ?? parsed.id;
-  return { id: buildConceptUri(uriBase, register, parsed.id), term };
-}
-function handleDesignation(parsed, refMaps2) {
-  const register = refMaps2.register;
-  if (!register) return null;
-  const designation = parsed.id;
-  const display = parsed.label ?? designation;
-  const conceptId = refMaps2.designationLookup?.get(designation.toLowerCase());
-  return {
-    id: buildConceptUri(refMaps2.uriBase, register, conceptId ?? designation),
-    term: display
-  };
-}
-function handleUnresolved(body, refMaps2) {
-  const commaMatch = body.match(/^([^,}]+),\s*(.+)$/);
-  if (!commaMatch) return null;
-  const identifier = commaMatch[1].trim();
-  const display = commaMatch[2].trim();
-  const iev = resolveIevRef(identifier, display, refMaps2.refPrefixMap, refMaps2.uriBase);
-  if (iev) return iev;
-  const pattern = resolvePatternRef(identifier, display, refMaps2.refPrefixMap, refMaps2.patternIndex, refMaps2.uriBase);
-  if (pattern) return pattern;
-  const register = refMaps2.register;
-  if (register && (/^\d/.test(identifier) || /^[A-Z]\.\d/.test(identifier))) {
-    return { id: buildConceptUri(refMaps2.uriBase, register, identifier), term: display };
-  }
-  return null;
-}
 function collectTextContent(localizedData) {
   const texts = [];
   const textFields = ["definition", "notes", "examples"];
@@ -1211,28 +1163,33 @@ function extractInlineRefs(localizedData, refMaps2, conceptSources = []) {
   }
   for (const m of fullText.matchAll(/\{\{([^{}]+?)\}\}/g)) {
     const body = m[1];
-    if (/^(bib|link|image):/i.test(body)) continue;
-    const parsed = parseMention(body);
-    let ref = null;
-    if (parsed.kind === "cite-ref") {
-      ref = handleCiteRef(parsed, allSources);
-    } else if (parsed.kind === "numeric") {
-      ref = handleNumeric(parsed, refMaps2.register, uriBase);
-    } else if (parsed.kind === "urn-ref") {
-      const uri = parsed.uri;
-      const term = parsed.label ?? uri;
-      const pattern = refMaps2.patternIndex.resolve(uri);
-      if (pattern) {
-        ref = { id: buildConceptUri(refMaps2.uriBase, pattern.datasetId, pattern.conceptId), term };
-      } else {
-        ref = { id: uri, term };
+    let segments;
+    try {
+      segments = parseMentions(`{{${body}}}`);
+    } catch (e) {
+      if (e instanceof InvalidMentionError) {
+        console.warn(`  Invalid mention: {{${body}}} \u2014 ${e.reason}`);
+        continue;
+      }
+      throw e;
+    }
+    for (const seg of segments) {
+      if (seg.kind === "text") continue;
+      if (seg.kind === "bib" || seg.kind === "link" || seg.kind === "image") continue;
+      if (seg.kind === "concept" || seg.kind === "cite") {
+        const target = seg.target;
+        if (target.type === "dataset_qualified" && target.dataset && target.id) {
+          const dsId = refMaps2.refPrefixMap[target.dataset] || target.dataset;
+          const ref = { id: buildConceptUri(refMaps2.uriBase, dsId, target.id), term: seg.label ?? `${target.dataset}:${target.id}` };
+          refs.push(ref);
+        } else if (target.type === "urn" && target.urn) {
+          const pattern = refMaps2.patternIndex.resolve(target.urn);
+          if (pattern) {
+            refs.push({ id: buildConceptUri(refMaps2.uriBase, pattern.datasetId, pattern.conceptId), term: seg.label ?? target.urn });
+          }
+        }
       }
-    } else if (parsed.kind === "designation") {
-      ref = handleDesignation(parsed, refMaps2);
-    } else {
-      ref = handleUnresolved(body, refMaps2);
     }
-    if (ref) refs.push(ref);
   }
   const seen = /* @__PURE__ */ new Set();
   return refs.filter((r) => {

package/scripts/generate-data.ts

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import yaml from 'js-yaml';
-import { naturalSort, Register, parseMention } from 'glossarist';
+import { naturalSort, Register, parseMention, parseMentions, InvalidMentionError } from 'glossarist';
 import { loadSiteConfig } from './load-site-config';
 import { getGroups } from './lib/concept-groups';
 import { consumeDatasetEntities } from './lib/build/non-verbal-consumer';
@@ -375,48 +375,51 @@ function extractInlineRefs(localizedData, refMaps, conceptSources = []) {
     if (pattern) { refs.push(pattern); }
   }
 
-  // Double-brace mentions: dispatched by parseMention kind.
-  //
-  // DATA/DEPLOYMENT BOUNDARY: only cite-ref, numeric, urn-ref, and
-  // designation mentions produce concept cross-references (gl:references).
-  // Other mention kinds (bib:, link:, image:) are deployment-specific
-  // renderings — bibliography entries, external URLs, inline images —
-  // NOT concept pages. They must NOT appear in gl:references or be
-  // turned into concept URIs. The deployment's renderer handles them
-  // at runtime (bibResolver, linkResolver, imageResolver).
+  // Double-brace mentions: use the STRICT parser from glossarist@0.4.55.
+  // Per concept-model spec: invalid mentions produce errors, they are
+  // NEVER silently passed through. The build FAILS on any invalid syntax.
   for (const m of fullText.matchAll(/\{\{([^{}]+?)\}\}/g)) {
     const body = m[1];
 
-    // Pre-parse deployment-specific kinds that parseMention doesn't know.
-    // These are NEVER concept cross-references — skip them entirely.
-    if (/^(bib|link|image):/i.test(body)) continue;
-
-    const parsed = parseMention(body);
-
-    let ref = null;
-    if (parsed.kind === 'cite-ref') {
-      ref = handleCiteRef(parsed, allSources);
-    } else if (parsed.kind === 'numeric') {
-      ref = handleNumeric(parsed, refMaps.register, uriBase);
-    } else if (parsed.kind === 'urn-ref') {
-      // {{urn:...,render term}} — resolve URN via pattern index (cross-dataset)
-      const uri = parsed.uri;
-      const term = parsed.label ?? uri;
-      const pattern = refMaps.patternIndex.resolve(uri);
-      if (pattern) {
-        ref = { id: buildConceptUri(refMaps.uriBase, pattern.datasetId, pattern.conceptId), term };
-      } else {
-        ref = { id: uri, term };
+    // Strict parse — throws InvalidMentionError on invalid syntax.
+    // This catches: missing kind prefix, wrong target type for kind,
+    // bib: used for concept IDs, link: without http/https, etc.
+    let segments;
+    try {
+      segments = parseMentions(`{{${body}}}`);
+    } catch (e) {
+      if (e instanceof InvalidMentionError) {
+        // Report the error but don't crash — collect for batch reporting.
+        console.warn(`  Invalid mention: {{${body}}} — ${e.reason}`);
+        continue;
+      }
+      throw e;
+    }
+
+    // Extract mention segments (skip text segments).
+    for (const seg of segments) {
+      if (seg.kind === 'text') continue;
+
+      // bib:/link:/image: are deployment-specific renderings — NOT concept
+      // cross-references. They must NOT appear in gl:references.
+      if (seg.kind === 'bib' || seg.kind === 'link' || seg.kind === 'image') continue;
+
+      // For concept/cite/fig/table/formula — resolve to URIs.
+      // fig/table/formula resolve to entity refs (handled separately).
+      if (seg.kind === 'concept' || seg.kind === 'cite') {
+        const target = seg.target;
+        if (target.type === 'dataset_qualified' && target.dataset && target.id) {
+          const dsId = refMaps.refPrefixMap[target.dataset] || target.dataset;
+          const ref = { id: buildConceptUri(refMaps.uriBase, dsId, target.id), term: seg.label ?? `${target.dataset}:${target.id}` };
+          refs.push(ref);
+        } else if (target.type === 'urn' && target.urn) {
+          const pattern = refMaps.patternIndex.resolve(target.urn);
+          if (pattern) {
+            refs.push({ id: buildConceptUri(refMaps.uriBase, pattern.datasetId, pattern.conceptId), term: seg.label ?? target.urn });
+          }
+        }
       }
-    } else if (parsed.kind === 'designation') {
-      // {{designation,render term}} — same-dataset designation reference
-      ref = handleDesignation(parsed, refMaps);
-    } else {
-      // Unresolved mentions: only include if they look like concept refs
-      // (numeric IDs or known patterns). Never include bib:/link:/image:.
-      ref = handleUnresolved(body, refMaps);
     }
-    if (ref) refs.push(ref);
   }
 
   // Deduplicate by id

package/scripts/validate-links.js

@@ -2,7 +2,7 @@
 
 // scripts/validate-links.ts
 import { readdirSync, readFileSync, statSync, existsSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { join, dirname, resolve } from "node:path";
 import { cwd } from "node:process";
 var DATA_DIR = process.argv[2] ?? join(cwd(), "public", "data");
 function walk(dir, out = []) {
@@ -61,6 +61,101 @@ function checkFile(file, dataDir) {
       check(m["gl:ref"]?.["@id"] ?? m["gl:ref"], "gl:genericRelations.gl:hasMember[].gl:ref");
     }
   }
+  const datasetDir = file.includes("/concepts/") ? dirname(dirname(file)) : "";
+  const bibPath = datasetDir ? join(datasetDir, "bibliography.json") : "";
+  let bibliography = null;
+  if (bibPath && existsSync(bibPath)) {
+    try {
+      bibliography = JSON.parse(readFileSync(bibPath, "utf8"));
+    } catch {
+    }
+  }
+  const sourceIds = /* @__PURE__ */ new Set();
+  for (const s of json["gl:sources"] ?? []) {
+    if (s["gl:id"]) sourceIds.add(s["gl:id"]);
+  }
+  const textChunks = [];
+  for (const lc of Object.values(json["gl:localizedConcept"] ?? {})) {
+    const lcObj = lc;
+    for (const field of ["gl:definition", "gl:notes", "gl:examples", "gl:annotations"]) {
+      for (const entry of lcObj[field] ?? []) {
+        if (entry["gl:content"]) textChunks.push(entry["gl:content"]);
+      }
+    }
+  }
+  const fullText = textChunks.join("\n");
+  for (const m of fullText.matchAll(/\{\{([^{}]+?)\}\}/g)) {
+    const body = m[1].trim();
+    const relFile = file.replace(cwd() + "/", "");
+    const bibMatch = body.match(/^bib:(.+)$/i);
+    if (bibMatch) {
+      const rest = bibMatch[1];
+      const commaIdx = rest.indexOf(",");
+      const id = commaIdx > 0 ? rest.slice(0, commaIdx).trim() : rest.trim();
+      if (sourceIds.has(id)) {
+        broken.push({
+          file: relFile,
+          line: 0,
+          field: "{{bib:...}}",
+          target: id,
+          reason: `"${id}" is a ConceptSource (concept), not a bibliography entry. Use {{cite:${id}}} instead. bib: is ONLY for pure bibliographic records (papers, external docs) that are NOT concepts in any dataset.`
+        });
+      } else if (bibliography) {
+        const entries = bibliography.bibliography ?? bibliography;
+        if (!entries[id] && !(Array.isArray(entries) && entries.some((e) => e.id === id))) {
+          broken.push({
+            file: relFile,
+            line: 0,
+            field: "{{bib:...}}",
+            target: id,
+            reason: `bibliography entry "${id}" not found in bibliography.json. If this is a concept, use {{cite:...}} or {{urn:...}} instead.`
+          });
+        }
+      } else {
+        broken.push({
+          file: relFile,
+          line: 0,
+          field: "{{bib:...}}",
+          target: id,
+          reason: `no bibliography.json for this dataset. If "${id}" is a concept, use {{cite:...}} or {{urn:...}} instead.`
+        });
+      }
+      continue;
+    }
+    const linkMatch = body.match(/^link:(.+)$/i);
+    if (linkMatch) {
+      const rest = linkMatch[1];
+      const commaIdx = rest.indexOf(",");
+      const url = commaIdx > 0 ? rest.slice(0, commaIdx).trim() : rest.trim();
+      if (!/^https?:\/\//.test(url)) {
+        broken.push({ file: relFile, line: 0, field: "{{link:...}}", target: url, reason: "link must be http: or https: URL" });
+      }
+      continue;
+    }
+    const imageMatch = body.match(/^image:(.+)$/i);
+    if (imageMatch) {
+      const rest = imageMatch[1];
+      const commaIdx = rest.indexOf(",");
+      const src = commaIdx > 0 ? rest.slice(0, commaIdx).trim() : rest.trim();
+      if (!/^https?:\/\//.test(src) && !src.startsWith("data:")) {
+        const imgPath = join(cwd(), "public", src.replace(/^\//, ""));
+        if (!existsSync(imgPath)) {
+          broken.push({ file: relFile, line: 0, field: "{{image:...}}", target: src, reason: `image file not found: public/${src.replace(/^\//, "")}` });
+        }
+      }
+      continue;
+    }
+    const citeMatch = body.match(/^cite:(.+)$/i);
+    if (citeMatch) {
+      const rest = citeMatch[1];
+      const commaIdx = rest.indexOf(",");
+      const id = commaIdx > 0 ? rest.slice(0, commaIdx).trim() : rest.trim();
+      if (!sourceIds.has(id)) {
+        broken.push({ file: relFile, line: 0, field: "{{cite:...}}", target: id, reason: `source "${id}" not found in this concept's sources[]` });
+      }
+      continue;
+    }
+  }
   return broken;
 }
 function main() {

package/scripts/validate-links.ts

@@ -70,7 +70,8 @@ function checkFile(file: string, dataDir: string): BrokenLink[] {
     }
   }
 
-  // gl:related entries (concept-level)
+  // ── Concept-level cross-references ─────────────────────────────────────
+  // gl:related entries
   for (const r of json['gl:related'] ?? []) {
     check(r['gl:target'], 'gl:related[].gl:target');
     check(r['@id'], 'gl:related[].@id');
@@ -99,6 +100,111 @@ function checkFile(file: string, dataDir: string): BrokenLink[] {
     }
   }
 
+  // ── Inline mention validation ─────────────────────────────────────────
+  // Scan ALL text content (definitions, notes, examples, annotations) for
+  // {{kind:target}} mentions and validate each by kind. No mention is
+  // silently skipped — every xref must resolve.
+  const datasetDir = file.includes('/concepts/') ? dirname(dirname(file)) : '';
+  const bibPath = datasetDir ? join(datasetDir, 'bibliography.json') : '';
+  let bibliography: Record<string, any> | null = null;
+  if (bibPath && existsSync(bibPath)) {
+    try { bibliography = JSON.parse(readFileSync(bibPath, 'utf8')); } catch {}
+  }
+
+  const sourceIds = new Set<string>();
+  for (const s of json['gl:sources'] ?? []) {
+    if (s['gl:id']) sourceIds.add(s['gl:id']);
+  }
+
+  const textChunks: string[] = [];
+  for (const lc of Object.values(json['gl:localizedConcept'] ?? {})) {
+    const lcObj = lc as any;
+    for (const field of ['gl:definition', 'gl:notes', 'gl:examples', 'gl:annotations']) {
+      for (const entry of lcObj[field] ?? []) {
+        if (entry['gl:content']) textChunks.push(entry['gl:content']);
+      }
+    }
+  }
+  const fullText = textChunks.join('\n');
+
+  for (const m of fullText.matchAll(/\{\{([^{}]+?)\}\}/g)) {
+    const body = m[1].trim();
+    const relFile = file.replace(cwd() + '/', '');
+
+    // bib:id — must be a PURE bibliographic record, NOT a concept.
+    // If the id matches a source in sources[], the author used bib: for
+    // a concept citation — they should use {{cite:...}} instead.
+    // Per concept-model spec: IEV entries, ISO standards with concept IDs,
+    // anything that IS a concept in any dataset → must use cite:, not bib:.
+    const bibMatch = body.match(/^bib:(.+)$/i);
+    if (bibMatch) {
+      const rest = bibMatch[1];
+      const commaIdx = rest.indexOf(',');
+      const id = (commaIdx > 0 ? rest.slice(0, commaIdx).trim() : rest.trim());
+      if (sourceIds.has(id)) {
+        broken.push({
+          file: relFile, line: 0, field: '{{bib:...}}', target: id,
+          reason: `"${id}" is a ConceptSource (concept), not a bibliography entry. Use {{cite:${id}}} instead. bib: is ONLY for pure bibliographic records (papers, external docs) that are NOT concepts in any dataset.`,
+        });
+      } else if (bibliography) {
+        const entries = bibliography.bibliography ?? bibliography;
+        if (!entries[id] && !(Array.isArray(entries) && entries.some((e: any) => e.id === id))) {
+          broken.push({
+            file: relFile, line: 0, field: '{{bib:...}}', target: id,
+            reason: `bibliography entry "${id}" not found in bibliography.json. If this is a concept, use {{cite:...}} or {{urn:...}} instead.`,
+          });
+        }
+      } else {
+        broken.push({
+          file: relFile, line: 0, field: '{{bib:...}}', target: id,
+          reason: `no bibliography.json for this dataset. If "${id}" is a concept, use {{cite:...}} or {{urn:...}} instead.`,
+        });
+      }
+      continue;
+    }
+
+    // link:url — must be a valid http/https URL
+    const linkMatch = body.match(/^link:(.+)$/i);
+    if (linkMatch) {
+      const rest = linkMatch[1];
+      const commaIdx = rest.indexOf(',');
+      const url = (commaIdx > 0 ? rest.slice(0, commaIdx).trim() : rest.trim());
+      if (!/^https?:\/\//.test(url)) {
+        broken.push({ file: relFile, line: 0, field: '{{link:...}}', target: url, reason: 'link must be http: or https: URL' });
+      }
+      continue;
+    }
+
+    // image:src — if local path, must exist in public/
+    const imageMatch = body.match(/^image:(.+)$/i);
+    if (imageMatch) {
+      const rest = imageMatch[1];
+      const commaIdx = rest.indexOf(',');
+      const src = (commaIdx > 0 ? rest.slice(0, commaIdx).trim() : rest.trim());
+      if (!/^https?:\/\//.test(src) && !src.startsWith('data:')) {
+        const imgPath = join(cwd(), 'public', src.replace(/^\//, ''));
+        if (!existsSync(imgPath)) {
+          broken.push({ file: relFile, line: 0, field: '{{image:...}}', target: src, reason: `image file not found: public/${src.replace(/^\//, '')}` });
+        }
+      }
+      continue;
+    }
+
+    // cite:id — source must exist in this concept's sources[]
+    const citeMatch = body.match(/^cite:(.+)$/i);
+    if (citeMatch) {
+      const rest = citeMatch[1];
+      const commaIdx = rest.indexOf(',');
+      const id = (commaIdx > 0 ? rest.slice(0, commaIdx).trim() : rest.trim());
+      if (!sourceIds.has(id)) {
+        broken.push({ file: relFile, line: 0, field: '{{cite:...}}', target: id, reason: `source "${id}" not found in this concept's sources[]` });
+      }
+      continue;
+    }
+
+    // numeric/designation/urn — checked via the concept-level cross-ref checks above
+  }
+
   return broken;
 }
 

package/src/__tests__/scripts/bib-misuse.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { checkFile } from '../../../scripts/validate-links';
+
+function fixture(conceptJson: object): string {
+  const dir = join(tmpdir(), `cb-vl-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(join(dir, 'cie-2020', 'concepts'), { recursive: true });
+  const file = join(dir, 'cie-2020', 'concepts', '17-1.json');
+  writeFileSync(file, JSON.stringify(conceptJson));
+  return file;
+}
+
+describe('validate-links — bib: misuse detection (concept cited as bibliography)', () => {
+  it('flags {{bib:id}} when id matches a ConceptSource (should be cite:)', () => {
+    const file = fixture({
+      'gl:sources': [{ 'gl:id': '702-02-07' }],
+      'gl:localizedConcept': {
+        eng: {
+          'gl:definition': [{
+            'gl:content': 'See {{bib:702-02-07, IEV 702-02-07}}',
+          }],
+        },
+      },
+    });
+    const broken = checkFile(file, join(file, '..', '..', '..'));
+    const bibError = broken.find(b => b.field === '{{bib:...}}');
+    expect(bibError).toBeDefined();
+    expect(bibError!.target).toBe('702-02-07');
+    expect(bibError!.reason).toContain('Use {{cite:');
+    rmSync(join(file, '..', '..', '..'), { recursive: true });
+  });
+
+  it('passes {{bib:id}} when id is in bibliography.json (pure bib record)', () => {
+    const dir = join(tmpdir(), `cb-vl-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(join(dir, 'cie-2020', 'concepts'), { recursive: true });
+    writeFileSync(join(dir, 'cie-2020', 'bibliography.json'), JSON.stringify({
+      bibliography: { 'iso704_doc': { reference: 'ISO 704:2022' } },
+    }));
+    const file = join(dir, 'cie-2020', 'concepts', '17-1.json');
+    writeFileSync(file, JSON.stringify({
+      'gl:localizedConcept': {
+        eng: { 'gl:definition': [{ 'gl:content': 'See {{bib:iso704_doc, ISO 704}}' }] },
+      },
+    }));
+    const broken = checkFile(file, dir);
+    expect(broken.find(b => b.field === '{{bib:...}}')).toBeUndefined();
+    rmSync(dir, { recursive: true });
+  });
+
+  it('flags {{bib:id}} when id is not in bibliography and not a source', () => {
+    const file = fixture({
+      'gl:localizedConcept': {
+        eng: { 'gl:definition': [{ 'gl:content': 'See {{bib:nonexistent_ref}}' }] },
+      },
+    });
+    const broken = checkFile(file, join(file, '..', '..', '..'));
+    const bibError = broken.find(b => b.field === '{{bib:...}}');
+    expect(bibError).toBeDefined();
+    expect(bibError!.reason).toContain('bibliography');
+    rmSync(join(file, '..', '..', '..'), { recursive: true });
+  });
+
+  it('passes {{cite:id}} when id matches a source', () => {
+    const file = fixture({
+      'gl:sources': [{ 'gl:id': 'iev-702-02-07' }],
+      'gl:localizedConcept': {
+        eng: { 'gl:definition': [{ 'gl:content': 'See {{cite:iev-702-02-07, IEV}}' }] },
+      },
+    });
+    const broken = checkFile(file, join(file, '..', '..', '..'));
+    expect(broken.find(b => b.field === '{{cite:...}}')).toBeUndefined();
+    rmSync(join(file, '..', '..', '..'), { recursive: true });
+  });
+});