@glossarist/concept-browser 0.7.109 → 0.7.111

package/cli/index.mjs

@@ -112,18 +112,30 @@ Environment:
     const faviconCfgIsObject =
       faviconCfg !== null && typeof faviconCfg === 'object' && !Array.isArray(faviconCfg);
 
+    // Defensive field access: loadSiteConfig normalizes snake_case YAML keys
+    // to camelCase at load time, so `source_dir` arrives as `sourceDir`. But
+    // the canonical FaviconConfig schema documents snake_case (matching the
+    // YAML wire format), and Astro's getSiteConfig path does NOT normalize.
+    // Accept both forms so a future change to either loader can't break this.
+    // See src/utils/favicon-config-access.ts for the SSOT + tests.
+    const cfgBasePath       = faviconCfgIsObject ? (faviconCfg.basePath ?? faviconCfg.base_path) : undefined;
+    const cfgSkipDefault    = faviconCfgIsObject ? (faviconCfg.skipDefaultLinks ?? faviconCfg.skip_default_links) === true : false;
+    const cfgLinksHtml      = faviconCfgIsObject ? (faviconCfg.linksHtml ?? faviconCfg.links_html) : undefined;
+    const cfgSourceDir      = faviconCfgIsObject ? (faviconCfg.sourceDir ?? faviconCfg.source_dir) : undefined;
+    const cfgIcons          = faviconCfgIsObject ? faviconCfg.icons : undefined;
+
     let faviconHtml = '';
     let skipDefaultGeneration = false;
 
     if (faviconCfgIsObject) {
       // Object form — honor each declared field.
-      if (faviconCfg.icons && Array.isArray(faviconCfg.icons) && faviconCfg.icons.length > 0) {
+      if (cfgIcons && Array.isArray(cfgIcons) && cfgIcons.length > 0) {
         // Data-driven: build <link> tags from the icons array.
         const basePathForIcons =
-          faviconCfg.base_path ||
+          cfgBasePath ||
           process.env.BASE_PATH?.replace(/\/+$/, '') ||
           '';
-        faviconHtml = faviconCfg.icons.map((icon) => {
+        faviconHtml = cfgIcons.map((icon) => {
           const attrs = [`rel="${icon.rel || 'icon'}"`];
           if (icon.type) attrs.push(`type="${icon.type}"`);
           if (icon.sizes) attrs.push(`sizes="${icon.sizes}"`);
@@ -138,19 +150,19 @@ Environment:
         }).join('\n    ');
         skipDefaultGeneration = true;
       }
-      if (faviconCfg.links_html) {
+      if (cfgLinksHtml) {
         if (faviconHtml) {
           console.warn('  Warning: branding.favicon.icons and links_html are both set; using icons (data form).');
         } else {
           console.warn('  Warning: branding.favicon.links_html is deprecated. Use branding.favicon.icons (data) instead.');
-          faviconHtml = String(faviconCfg.links_html);
+          faviconHtml = String(cfgLinksHtml);
         }
         skipDefaultGeneration = true;
       }
-      if (faviconCfg.source_dir) {
-        const srcDir = resolve(process.cwd(), faviconCfg.source_dir);
+      if (cfgSourceDir) {
+        const srcDir = resolve(process.cwd(), cfgSourceDir);
         if (fs.existsSync(srcDir) && fs.statSync(srcDir).isDirectory()) {
-          console.log(`\n=== FAVICONS (copy from ${faviconCfg.source_dir}) ===\n`);
+          console.log(`\n=== FAVICONS (copy from ${cfgSourceDir}) ===\n`);
           // When the consumer provides a canonical favicon set, also delete
           // the default-generated cruft (apple-touch-icon-*.png, etc.) so
           // it doesn't linger in public/ and pollute the deployment.
@@ -191,12 +203,12 @@ Environment:
               copied++;
             }
           }
-          console.log(`  Copied ${copied} canonical favicon file(s) from ${faviconCfg.source_dir}`);
+          console.log(`  Copied ${copied} canonical favicon file(s) from ${cfgSourceDir}`);
         } else {
           console.warn(`  Warning: branding.favicon.source_dir not found: ${srcDir}`);
         }
       }
-      if (faviconCfg.skip_default_links) {
+      if (cfgSkipDefault) {
         skipDefaultGeneration = true;
       }
     }
@@ -253,7 +265,7 @@ Environment:
       fs.writeFileSync(resolve(publicDir, 'favicon-links.html'), faviconHtml);
       // Apply base_path prefix (issue #173 + BASE_PATH-aware deployments).
       const basePath =
-        (faviconCfgIsObject && faviconCfg.base_path) ||
+        cfgBasePath ||
         process.env.BASE_PATH?.replace(/\/+$/, '') ||
         '';
       if (basePath) {

package/cli/index.ts

@@ -74,16 +74,21 @@ interface FaviconIcon {
 }
 
 interface FaviconConfig {
-  /** Path prefix for all favicon URLs. Defaults to BASE_PATH-aware '/'. */
+  /** Path prefix for all favicon URLs. Accepts both forms because
+   *  loadSiteConfig normalizes snake_case → camelCase at load time. */
   base_path?: string;
+  basePath?: string;
   /** Skip emitting the default <link> block. */
   skip_default_links?: boolean;
-  /** Consumer-declared icons (DATA, not HTML). Replaces the default set. */
+  skipDefaultLinks?: boolean;
+  /** Consumer-declared icons (DATA, not HTML). */
   icons?: FaviconIcon[];
-  /** @deprecated Use `icons` instead. Raw HTML — kept for backward compat. */
+  /** @deprecated Use `icons` instead. */
   links_html?: string;
+  linksHtml?: string;
   /** Consumer-side directory of canonical favicon files. */
   source_dir?: string;
+  sourceDir?: string;
 }
 
 interface BrandingConfig {
@@ -137,13 +142,21 @@ async function runBuildPipeline(config: SiteConfig | null): Promise<void> {
 
   if (faviconCfgObject) {
     const cfg: FaviconConfig = faviconCfgObject;
-    if (cfg.icons && cfg.icons.length > 0) {
+    // Defensive field access: loadSiteConfig normalizes snake_case → camelCase
+    // at load time. Accept both forms.
+    const cfgBasePath: string | undefined    = cfg.basePath ?? cfg.base_path;
+    const cfgSkipDefault: boolean            = (cfg.skipDefaultLinks ?? cfg.skip_default_links) === true;
+    const cfgLinksHtml: string | undefined   = cfg.linksHtml ?? cfg.links_html;
+    const cfgSourceDir: string | undefined   = cfg.sourceDir ?? cfg.source_dir;
+    const cfgIcons: FaviconIcon[] | undefined = cfg.icons;
+
+    if (cfgIcons && cfgIcons.length > 0) {
       // Data-driven: build <link> tags from the icons array.
       const basePathForIcons: string =
-        cfg.base_path ||
+        cfgBasePath ||
         process.env.BASE_PATH?.replace(/\/+$/, '') ||
         '';
-      faviconHtml = cfg.icons.map((icon: FaviconIcon): string => {
+      faviconHtml = cfgIcons.map((icon: FaviconIcon): string => {
         const attrs: string[] = [`rel="${icon.rel || 'icon'}"`];
         if (icon.type) attrs.push(`type="${icon.type}"`);
         if (icon.sizes) attrs.push(`sizes="${icon.sizes}"`);
@@ -156,19 +169,19 @@ async function runBuildPipeline(config: SiteConfig | null): Promise<void> {
       }).join('\n    ');
       skipDefaultGeneration = true;
     }
-    if (cfg.links_html) {
+    if (cfgLinksHtml) {
       if (faviconHtml) {
         console.warn('  Warning: branding.favicon.icons and links_html are both set; using icons (data form).');
       } else {
         console.warn('  Warning: branding.favicon.links_html is deprecated. Use branding.favicon.icons (data) instead.');
-        faviconHtml = String(cfg.links_html);
+        faviconHtml = String(cfgLinksHtml);
       }
       skipDefaultGeneration = true;
     }
-    if (cfg.source_dir) {
-      const srcDir: string = resolve(process.cwd(), cfg.source_dir);
+    if (cfgSourceDir) {
+      const srcDir: string = resolve(process.cwd(), cfgSourceDir);
       if (fs.existsSync(srcDir) && fs.statSync(srcDir).isDirectory()) {
-        console.log(`\n=== FAVICONS (copy from ${cfg.source_dir}) ===\n`);
+        console.log(`\n=== FAVICONS (copy from ${cfgSourceDir}) ===\n`);
         // When the consumer provides a canonical favicon set, also delete
         // the default-generated cruft so it doesn't linger in public/.
         const cruftFiles: readonly string[] = [
@@ -207,12 +220,12 @@ async function runBuildPipeline(config: SiteConfig | null): Promise<void> {
             copied++;
           }
         }
-        console.log(`  Copied ${copied} canonical favicon file(s) from ${cfg.source_dir}`);
+        console.log(`  Copied ${copied} canonical favicon file(s) from ${cfgSourceDir}`);
       } else {
         console.warn(`  Warning: branding.favicon.source_dir not found: ${srcDir}`);
       }
     }
-    if (cfg.skip_default_links) {
+    if (cfgSkipDefault) {
       skipDefaultGeneration = true;
     }
   }
@@ -266,7 +279,7 @@ async function runBuildPipeline(config: SiteConfig | null): Promise<void> {
   if (faviconHtml) {
     fs.writeFileSync(resolve(publicDir, 'favicon-links.html'), faviconHtml);
     const basePath: string =
-      (faviconCfgObject?.base_path) ||
+      (faviconCfgObject ? (faviconCfgObject.basePath ?? faviconCfgObject.base_path) : undefined) ||
       process.env.BASE_PATH?.replace(/\/+$/, '') ||
       '';
     if (basePath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.109",
+  "version": "0.7.111",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {
@@ -38,7 +38,7 @@
     "astro": "^7.0.7",
     "d3": "^7.9.0",
     "favicons": "^7.2.0",
-    "glossarist": "^0.4.51",
+    "glossarist": "^0.4.52",
     "js-yaml": "^4.1.0",
     "jszip": "^3.10.1",
     "pinia": "^2.3.1",

package/src/__tests__/utils/external-detection.test.ts

@@ -1,79 +1,155 @@
 import { describe, it, expect } from 'vitest';
 import {
   isExternalConcept,
+  isExternalMember,
+  isExternalComprehensive,
+  getExternalMembers,
   hasProvidedBy,
-  isDanglingExternal,
+  hasDanglingExternal,
   formatExternalLabel,
-  type ConceptStoreLike,
+  type ConceptStore,
+  type ExternalConceptLike,
 } from '../../utils/external-detection';
+import { checkExtensionalCompleteness } from 'glossarist';
 
-const mockStore: ConceptStoreLike = {
+/**
+ * External-detection + extensional-completeness contract tests.
+ *
+ * glossarist@0.4.52 promoted these utilities from concept-browser's
+ * local src/utils/external-detection.ts into the upstream library.
+ * This spec pins:
+ *   1. The local module re-exports the upstream functions (no drift).
+ *   2. The upstream signatures work as documented.
+ *   3. `formatExternalLabel` (the UI-only helper) stays local.
+ *   4. `checkExtensionalCompleteness` flags ISO 704:2022 §6.4.5.1
+ *      open-ended patterns in extensional definitions.
+ */
+
+const extResolved: ExternalConceptLike = { status: 'external', related: [{ type: 'provided_by' }] };
+const extDangling: ExternalConceptLike = { status: 'external', related: [] };
+const internal: ExternalConceptLike = { status: 'valid', related: [] };
+
+const store: ConceptStore = {
   lookup(ref) {
-    if (ref?.id === 'ext-1') {
-      return { status: 'external', relatedConcepts: [{ type: 'provided_by' }] };
-    }
-    if (ref?.id === 'ext-2') {
-      return { status: 'external', relatedConcepts: [] };
-    }
-    if (ref?.id === 'int-1') {
-      return { status: 'valid', relatedConcepts: [] };
-    }
+    if (ref?.id === 'ext-resolved') return extResolved;
+    if (ref?.id === 'ext-dangling') return extDangling;
+    if (ref?.id === 'int-1') return internal;
     return null;
   },
 };
 
-describe('external-detection', () => {
+describe('external-detection (re-exports from glossarist@0.4.52)', () => {
   describe('isExternalConcept', () => {
-    it('returns true when the concept status is external', () => {
-      expect(isExternalConcept({ source: 's', id: 'ext-1' }, mockStore)).toBe(true);
+    it('returns true when concept.status === "external"', () => {
+      expect(isExternalConcept(extResolved)).toBe(true);
+      expect(isExternalConcept(extDangling)).toBe(true);
     });
 
-    it('returns false when the concept status is valid', () => {
-      expect(isExternalConcept({ source: 's', id: 'int-1' }, mockStore)).toBe(false);
+    it('returns false for internal concepts', () => {
+      expect(isExternalConcept(internal)).toBe(false);
     });
 
-    it('returns false when the concept is not found', () => {
-      expect(isExternalConcept({ source: 's', id: 'unknown' }, mockStore)).toBe(false);
+    it('returns false for null/undefined', () => {
+      expect(isExternalConcept(null)).toBe(false);
+      expect(isExternalConcept(undefined)).toBe(false);
     });
+  });
 
-    it('returns false when ref is null', () => {
-      expect(isExternalConcept(null, mockStore)).toBe(false);
+  describe('isExternalMember', () => {
+    it('returns true when the member ref resolves to an external concept', () => {
+      expect(isExternalMember({ ref: { source: 's', id: 'ext-resolved' } }, store)).toBe(true);
+    });
+
+    it('returns false when the member ref resolves to an internal concept', () => {
+      expect(isExternalMember({ ref: { source: 's', id: 'int-1' } }, store)).toBe(false);
     });
 
     it('returns false when store is null', () => {
-      expect(isExternalConcept({ source: 's', id: 'ext-1' }, null)).toBe(false);
+      expect(isExternalMember({ ref: { source: 's', id: 'ext-resolved' } }, null)).toBe(false);
+    });
+
+    it('returns false when ref is missing', () => {
+      expect(isExternalMember({}, store)).toBe(false);
+      expect(isExternalMember(null, store)).toBe(false);
+    });
+  });
+
+  describe('isExternalComprehensive', () => {
+    it('returns true when the comprehensive ref resolves to external', () => {
+      const hyperedge = {
+        comprehensive: { source: 's', id: 'ext-resolved' },
+        members: [],
+      };
+      expect(isExternalComprehensive(hyperedge, store)).toBe(true);
+    });
+
+    it('returns false when the comprehensive ref resolves to internal', () => {
+      const hyperedge = {
+        comprehensive: { source: 's', id: 'int-1' },
+        members: [],
+      };
+      expect(isExternalComprehensive(hyperedge, store)).toBe(false);
+    });
+  });
+
+  describe('getExternalMembers', () => {
+    it('returns only the members whose refs resolve to external', () => {
+      const hyperedge = {
+        comprehensive: { source: 's', id: 'int-1' },
+        members: [
+          { ref: { source: 's', id: 'ext-resolved' } },
+          { ref: { source: 's', id: 'int-1' } },
+          { ref: { source: 's', id: 'ext-dangling' } },
+        ],
+      };
+      const external = getExternalMembers(hyperedge, store);
+      expect(external).toHaveLength(2);
+      expect(external.map(m => (m.ref as { id?: string } | undefined)?.id)).toEqual(['ext-resolved', 'ext-dangling']);
     });
   });
 
   describe('hasProvidedBy', () => {
-    it('returns true when the external concept has a provided_by edge', () => {
-      expect(hasProvidedBy({ source: 's', id: 'ext-1' }, mockStore)).toBe(true);
+    it('returns true when the concept has a provided_by edge', () => {
+      expect(hasProvidedBy(extResolved)).toBe(true);
     });
 
-    it('returns false when the external concept has no provided_by edge', () => {
-      expect(hasProvidedBy({ source: 's', id: 'ext-2' }, mockStore)).toBe(false);
+    it('returns false when the concept has no provided_by edge', () => {
+      expect(hasProvidedBy(extDangling)).toBe(false);
     });
 
-    it('returns false when the concept is not found', () => {
-      expect(hasProvidedBy({ source: 's', id: 'unknown' }, mockStore)).toBe(false);
+    it('returns false for null/undefined', () => {
+      expect(hasProvidedBy(null)).toBe(false);
+      expect(hasProvidedBy(undefined)).toBe(false);
     });
   });
 
-  describe('isDanglingExternal', () => {
-    it('returns false when the external concept has provided_by (resolved)', () => {
-      expect(isDanglingExternal({ source: 's', id: 'ext-1' }, mockStore)).toBe(false);
+  describe('hasDanglingExternal (hyperedge-level)', () => {
+    it('returns true when any external ref lacks a provided_by edge', () => {
+      const hyperedge = {
+        comprehensive: { source: 's', id: 'ext-dangling' },
+        members: [],
+      };
+      expect(hasDanglingExternal(hyperedge, store)).toBe(true);
     });
 
-    it('returns true when the external concept has no provided_by (dangling)', () => {
-      expect(isDanglingExternal({ source: 's', id: 'ext-2' }, mockStore)).toBe(true);
+    it('returns false when every external ref is resolved', () => {
+      const hyperedge = {
+        comprehensive: { source: 's', id: 'ext-resolved' },
+        members: [{ ref: { source: 's', id: 'ext-resolved' } }],
+      };
+      expect(hasDanglingExternal(hyperedge, store)).toBe(false);
     });
 
-    it('returns false for internal concepts', () => {
-      expect(isDanglingExternal({ source: 's', id: 'int-1' }, mockStore)).toBe(false);
+    it('returns false when no refs are external', () => {
+      const hyperedge = {
+        comprehensive: { source: 's', id: 'int-1' },
+        members: [{ ref: { source: 's', id: 'int-1' } }],
+      };
+      expect(hasDanglingExternal(hyperedge, store)).toBe(false);
     });
   });
 
-  describe('formatExternalLabel', () => {
+  describe('formatExternalLabel (local UI helper, not in upstream)', () => {
     it('wraps the label in parentheses for external concepts', () => {
       expect(formatExternalLabel('precision condition', true)).toBe('(precision condition)');
     });
@@ -83,3 +159,30 @@ describe('external-detection', () => {
     });
   });
 });
+
+describe('checkExtensionalCompleteness (ISO 704:2022 §6.4.5.1)', () => {
+  it('returns null for non-extensional definitions', () => {
+    expect(checkExtensionalCompleteness({ type: 'intensional', content: '...' })).toBeNull();
+    expect(checkExtensionalCompleteness({ type: null, content: '...' })).toBeNull();
+    expect(checkExtensionalCompleteness(null)).toBeNull();
+  });
+
+  it('returns null for an extensional definition that lists every member', () => {
+    expect(checkExtensionalCompleteness({
+      type: 'extensional',
+      content: '1, 2, 3',
+    })).toBeNull();
+  });
+
+  it('returns a warning when an extensional definition uses an open-ended pattern', () => {
+    // Open-ended patterns: "etc.", "...", "and so on", "includes but is not limited to"
+    const issue = checkExtensionalCompleteness({
+      type: 'extensional',
+      content: 'length, mass, time, etc.',
+    });
+    expect(issue).not.toBeNull();
+    expect(issue?.severity).toBe('warning');
+    expect(issue?.rule).toBe('ISO-704-6.4.5.1');
+    expect(issue?.message).toMatch(/completeness|extensional/i);
+  });
+});

package/src/__tests__/utils/favicon-config-access.test.ts

@@ -0,0 +1,147 @@
+import { describe, it, expect } from 'vitest';
+import {
+  getFaviconBasePath,
+  getFaviconSkipDefaultLinks,
+  getFaviconLinksHtml,
+  getFaviconSourceDir,
+  getFaviconIcons,
+} from '../../utils/favicon-config-access';
+
+/**
+ * Regression test for the snake_case/camelCase mismatch reported against
+ * 0.7.109 (user-filed bug, 2026-08-01):
+ *
+ *   "source_dir reads snake_case — CLI reads faviconCfg.source_dir but
+ *    loadSiteConfig normalizes to sourceDir. Same bug as skip_default_links,
+ *    base_path, links_html. The canonical files never get copied."
+ *
+ * Root cause: two loaders, two conventions.
+ *   - scripts/load-site-config.mjs normalizes snake_case → camelCase.
+ *   - src/lib/site-config.ts (Astro) does NOT normalize.
+ *
+ * Fix: the accessors below accept BOTH forms. They check camelCase first
+ * (the post-normalization form) and fall back to snake_case (the raw YAML
+ * wire form). Either loader's output works.
+ */
+
+describe('getFaviconBasePath', () => {
+  it('returns undefined for null/undefined', () => {
+    expect(getFaviconBasePath(null)).toBeUndefined();
+    expect(getFaviconBasePath(undefined)).toBeUndefined();
+    expect(getFaviconBasePath({})).toBeUndefined();
+  });
+
+  it('reads camelCase basePath', () => {
+    expect(getFaviconBasePath({ basePath: '/vocab/' })).toBe('/vocab/');
+  });
+
+  it('reads snake_case base_path', () => {
+    expect(getFaviconBasePath({ base_path: '/vocab/' })).toBe('/vocab/');
+  });
+
+  it('camelCase wins when both forms are set', () => {
+    expect(getFaviconBasePath({ basePath: '/camel/', base_path: '/snake/' })).toBe('/camel/');
+  });
+});
+
+describe('getFaviconSkipDefaultLinks', () => {
+  it('returns false for null/undefined', () => {
+    expect(getFaviconSkipDefaultLinks(null)).toBe(false);
+    expect(getFaviconSkipDefaultLinks(undefined)).toBe(false);
+    expect(getFaviconSkipDefaultLinks({})).toBe(false);
+  });
+
+  it('reads camelCase skipDefaultLinks', () => {
+    expect(getFaviconSkipDefaultLinks({ skipDefaultLinks: true })).toBe(true);
+    expect(getFaviconSkipDefaultLinks({ skipDefaultLinks: false })).toBe(false);
+  });
+
+  it('reads snake_case skip_default_links', () => {
+    expect(getFaviconSkipDefaultLinks({ skip_default_links: true })).toBe(true);
+  });
+});
+
+describe('getFaviconLinksHtml', () => {
+  it('returns undefined for null/undefined', () => {
+    expect(getFaviconLinksHtml(null)).toBeUndefined();
+    expect(getFaviconLinksHtml({})).toBeUndefined();
+  });
+
+  it('reads camelCase linksHtml', () => {
+    expect(getFaviconLinksHtml({ linksHtml: '<link>' })).toBe('<link>');
+  });
+
+  it('reads snake_case links_html', () => {
+    expect(getFaviconLinksHtml({ links_html: '<link>' })).toBe('<link>');
+  });
+});
+
+describe('getFaviconSourceDir', () => {
+  it('returns undefined for null/undefined', () => {
+    expect(getFaviconSourceDir(null)).toBeUndefined();
+    expect(getFaviconSourceDir({})).toBeUndefined();
+  });
+
+  it('reads camelCase sourceDir', () => {
+    expect(getFaviconSourceDir({ sourceDir: 'assets/favicons' })).toBe('assets/favicons');
+  });
+
+  /**
+   * THE LOAD-BEARING TEST — pins the exact bug the user reported.
+   * "source_dir reads snake_case — CLI reads faviconCfg.source_dir but
+   *  loadSiteConfig normalizes to sourceDir. The canonical files never
+   *  get copied."
+   *
+   * After loadSiteConfig normalization, the config object has sourceDir
+   * (camelCase), NOT source_dir. The accessor must return the value.
+   */
+  it('reads snake_case source_dir (the user-reported regression form)', () => {
+    expect(getFaviconSourceDir({ source_dir: 'assets/favicons' })).toBe('assets/favicons');
+  });
+
+  it('camelCase wins when both forms are set', () => {
+    expect(getFaviconSourceDir({ sourceDir: 'a', source_dir: 'b' })).toBe('a');
+  });
+});
+
+describe('getFaviconIcons', () => {
+  it('returns undefined for null/undefined', () => {
+    expect(getFaviconIcons(null)).toBeUndefined();
+    expect(getFaviconIcons({})).toBeUndefined();
+  });
+
+  it('reads icons (same key in both forms)', () => {
+    const icons = [{ rel: 'icon', href: 'favicon.ico' }];
+    expect(getFaviconIcons({ icons })).toBe(icons);
+  });
+});
+
+describe('regression — both loader outputs work end-to-end', () => {
+  // Simulate the two loader paths:
+  //   - Astro's getSiteConfig (no normalization): snake_case keys preserved
+  //   - CLI's loadSiteConfig (normalizes): camelCase keys
+  const snakeCaseForm = {
+    base_path: '/cie-eilv/',
+    skip_default_links: true,
+    source_dir: 'assets/favicons',
+    links_html: '<link>',
+    icons: [{ rel: 'icon', href: 'favicon.ico' }],
+  };
+  const camelCaseForm = {
+    basePath: '/cie-eilv/',
+    skipDefaultLinks: true,
+    sourceDir: 'assets/favicons',
+    linksHtml: '<link>',
+    icons: [{ rel: 'icon', href: 'favicon.ico' }],
+  };
+
+  for (const [label, cfg] of [['snake_case (Astro)', snakeCaseForm], ['camelCase (CLI)', camelCaseForm]] as const) {
+    it(`accessors return identical values for ${label}`, () => {
+      expect(getFaviconBasePath(cfg)).toBe('/cie-eilv/');
+      expect(getFaviconSkipDefaultLinks(cfg)).toBe(true);
+      expect(getFaviconSourceDir(cfg)).toBe('assets/favicons');
+      expect(getFaviconLinksHtml(cfg)).toBe('<link>');
+      expect(getFaviconIcons(cfg)).toEqual([{ rel: 'icon', href: 'favicon.ico' }]);
+    });
+  }
+});

package/src/components/LanguageDetail.vue

@@ -1,5 +1,6 @@
 <script setup lang="ts">
 import type { Concept, LocalizedConcept, Designation, Expression, Abbreviation as AbbreviationType } from 'glossarist';
+import { checkExtensionalCompleteness, type ExtensionalCompletenessIssue } from 'glossarist';
 import { computed } from 'vue';
 import { langName, langLabel } from '../utils/lang';
 import { renderContent } from '../utils/content-renderer';
@@ -33,6 +34,33 @@ const definition = computed(() => {
   const content = lc.value.definitions.map(d => d.content).filter(Boolean).join('\n\n');
   return content;
 });
+
+/**
+ * ISO 704:2022 §6.4.5.1 extensional-completeness warnings.
+ *
+ * An extensional definition enumerates every member of the concept's
+ * extension. Open-ended phrasing ("etc.", "...", "and so on") signals
+ * that the enumeration is incomplete — the definition is invalid per
+ * ISO 704. Surface each warning inline so editors can fix the source.
+ *
+ * The validator gates on `definition.type === 'extensional'`. Today
+ * concept-browser's DetailedDefinition model doesn't carry that field,
+ * so this returns [] — the wiring is in place for the moment glossarist
+ * exposes definition-type tracking (or for consumers that annotate
+ * definitions themselves).
+ */
+const extensionalIssues = computed<ExtensionalCompletenessIssue[]>(() => {
+  if (!lc.value) return [];
+  const issues: ExtensionalCompletenessIssue[] = [];
+  for (const d of lc.value.definitions) {
+    const issue = checkExtensionalCompleteness(
+      d as unknown as { type?: string | null; content?: string | null },
+    );
+    if (issue) issues.push(issue);
+  }
+  return issues;
+});
+
 const notes = computed(() => lc.value?.notes.map(n => n.content).filter(Boolean) ?? []);
 const examples = computed(() => lc.value?.examples.map(e => e.content).filter(Boolean) ?? []);
 const sources = computed(() => lc.value?.sources ?? []);
@@ -140,6 +168,16 @@ function handleContentClick(e: MouseEvent) {
       <div v-if="definition" class="card p-5">
         <div class="section-label">{{ t('concept.definition') }}</div>
         <div class="text-ink-800 leading-relaxed mt-3" v-html="renderContent(definition, renderOpts)"></div>
+        <!-- ISO 704:2022 §6.4.5.1 extensional-completeness warnings -->
+        <div
+          v-for="(issue, i) in extensionalIssues"
+          :key="'ext'+i"
+          class="mt-3 p-2 rounded border border-amber-200 dark:border-amber-800 bg-amber-50 dark:bg-amber-900/20 text-xs text-amber-900 dark:text-amber-100"
+          :title="`Rule: ${issue.rule}`"
+        >
+          <span class="font-semibold">⚠ {{ t('concept.extensionalWarning') || 'Extensional completeness' }}:</span>
+          {{ issue.message }}
+        </div>
       </div>
 
       <!-- Notes -->

package/src/components/PartitiveRelationList.vue

@@ -9,6 +9,10 @@
  *     drop's line style encodes its multiplicity + is_delimiting per
  *     ISO 704:2022 (5 multiplicity values × 2 delimiting states).
  *
+ * External concepts (status: 'external') are wrapped in parentheses per
+ * ISO 704:2022 §5.5.4.3.1, using the upstream `isExternalMember` /
+ * `isExternalComprehensive` detection from glossarist@0.4.52.
+ *
  * Header badges communicate metadata that the diagram's line styles
  * also encode — for users who can't perceive the visual difference
  * (screen readers, low vision, monochrome displays).
@@ -21,6 +25,7 @@ import { useI18n, locale } from '../i18n';
 import { completenessLabel } from '../utils/partitive-relation-styling';
 import { presenceLabel, countLabel } from '../utils/partitive-multiplicity';
 import { resolveDesignation } from '../utils/resolve-designation';
+import { isExternalMember, isExternalComprehensive, formatExternalLabel } from '../utils/external-detection';
 import PartitiveRelationDiagram, {
   type PartitiveMemberLabeled,
 } from './PartitiveRelationDiagram.vue';
@@ -36,8 +41,51 @@ const store = useVocabularyStore();
 const factory = getFactory();
 const { t } = useI18n();
 
-function designationFor(uri: string): string {
-  return resolveDesignation(uri, store, factory, locale.value);
+/** Per-URI cache of external-status lookups, so the rake doesn't re-resolve
+ *  the same concept on every render pass. */
+const externalCache = new Map<string, boolean>();
+
+/**
+ * Bridge the concept-browser ref shape to glossarist@0.4.52's ConceptStore
+ * interface. The store exposes concepts via `lookup({ source, id })` and
+ * returns an object with `.status` + `.related[]` — exactly what the
+ * upstream external-detection utilities need.
+ */
+const externalStore = {
+  lookup(ref: { source?: string | null; id?: string | null }) {
+    if (!ref?.source && !ref?.id) return null;
+    // Find the matching concept by traversing the loaded datasets.
+    for (const adapter of store.datasets.values()) {
+      for (const entry of adapter.getConcepts() ?? []) {
+        if (entry && entry.id === ref.id) {
+          return {
+            status: entry.status,
+            related: (entry as any).relatedConcepts ?? (entry as any).related ?? [],
+          };
+        }
+      }
+    }
+    return null;
+  },
+};
+
+function isExternalUri(uri: string, kind: 'member' | 'comprehensive'): boolean {
+  if (externalCache.has(uri)) return externalCache.get(uri)!;
+  // Build a member/hyperedge shape the upstream utilities expect.
+  const ref = { source: uri, id: uri.split('/').pop() ?? uri };
+  let isExt: boolean;
+  if (kind === 'comprehensive') {
+    isExt = isExternalComprehensive({ comprehensive: ref, members: [] }, externalStore);
+  } else {
+    isExt = isExternalMember({ ref }, externalStore);
+  }
+  externalCache.set(uri, isExt);
+  return isExt;
+}
+
+function designationFor(uri: string, kind: 'member' | 'comprehensive' = 'member'): string {
+  const label = resolveDesignation(uri, store, factory, locale.value);
+  return formatExternalLabel(label, isExternalUri(uri, kind));
 }
 
 function navigate(uri: string) {
@@ -67,7 +115,7 @@ function criterionText(criterion?: Record<string, string>): string | null {
 function labeledMembers(rel: PartitiveRelationWire): PartitiveMemberLabeled[] {
   return rel.partitives.map(m => ({
     uri: m.uri,
-    label: designationFor(m.uri),
+    label: designationFor(m.uri, 'member'),
     presence: m.presence,
     count: m.count,
     isDelimiting: m.isDelimiting,

package/src/layouts/Default.astro

@@ -9,7 +9,7 @@ import {
   type FontConfigLike,
 } from '../utils/font-stack';
 import { resolveFaviconBase } from '../utils/favicon-base';
-import { buildDefaultFaviconLinks, renderFaviconLinkTag } from '../utils/favicon-links';
+import { buildFaviconLinks, renderFaviconLinkTag } from '../utils/favicon-links';
 
 interface Props {
   title: string;

package/src/utils/external-detection.ts

@@ -1,70 +1,97 @@
 /**
  * External concept detection — ISO 704:2022 external concepts.
  *
- * An "external concept" is one referenced from this dataset but defined
- * elsewhere (status: 'external'). In diagrams, external concepts are
- * shown in parentheses with a dashed border per ISO 704:2022 §5.5.4.3.1.
+ * The detection logic now lives upstream in glossarist@0.4.52 — this
+ * file is a thin re-export so consumers don't have to know which package
+ * the functions live in. The signature is also richer upstream: it
+ * understands `MemberLike` (with nested `.ref`) and `HyperedgeLike`
+ * shapes, matching the actual glossarist-js model.
  *
- * Detection requires concept resolution (looking up the referenced
- * concept's status), which is a consumer concern — the model itself
- * stays pure. These utility functions take a conceptStore/lookup
- * callback provided by the caller.
+ * The only thing kept locally is `formatExternalLabel` — it's a pure
+ * UI concern (parentheses per ISO 704 §5.5.4.3.1) and doesn't belong
+ * in the model library.
+ *
+ * ISO 704:2022 §5.5.4.3.1: external concepts are shown in parentheses
+ * with a dashed border in diagrams.
  */
 
-export interface ConceptLike {
-  status?: string | null;
-  relatedConcepts?: ReadonlyArray<{ type?: string | null }>;
-}
+import {
+  isExternalConcept,
+  isExternalMember as glsIsExternalMember,
+  isExternalComprehensive as glsIsExternalComprehensive,
+  getExternalMembers as glsGetExternalMembers,
+  hasProvidedBy,
+  hasDanglingExternal as glsHasDanglingExternal,
+} from 'glossarist';
+import type {
+  ExternalConceptLike,
+  ConceptStore,
+} from 'glossarist';
 
-export interface ConceptStoreLike {
-  lookup(ref: { source?: string | null; id?: string | null }): ConceptLike | null;
-}
+export type {
+  ExternalConceptLike,
+  ConceptStore,
+};
 
-export interface RefLike {
-  source?: string | null;
-  id?: string | null;
-}
+export {
+  isExternalConcept,
+  hasProvidedBy,
+};
 
 /**
- * Check if a member's concept resolves to status: external.
+ * Defensive wrappers around the upstream hyperedge-aware queries.
+ * glossarist@0.4.52 throws on null `store` (it indexes into it
+ * unconditionally). UI consumers may have no store available (e.g.,
+ * during initial render before the vocabulary store is loaded) —
+ * return false / [] instead of propagating the throw.
  */
-export function isExternalConcept(
-  ref: RefLike | null | undefined,
-  store: ConceptStoreLike | null | undefined,
+export function isExternalMember(
+  member: { ref?: unknown } | null | undefined,
+  store: ConceptStore | null | undefined,
 ): boolean {
-  if (!ref || !store) return false;
-  const concept = store.lookup(ref);
-  return concept?.status === 'external';
+  if (!member || !store) return false;
+  return glsIsExternalMember(member as Parameters<typeof glsIsExternalMember>[0], store);
 }
 
-/**
- * Check if an external concept has a provided_by edge for resolution.
- * Without provided_by, the reference dangles — the decomposition is
- * incomplete.
- */
-export function hasProvidedBy(
-  ref: RefLike | null | undefined,
-  store: ConceptStoreLike | null | undefined,
+export function isExternalComprehensive(
+  hyperedge: { comprehensive?: unknown; members?: readonly unknown[] },
+  store: ConceptStore | null | undefined,
 ): boolean {
-  if (!ref || !store) return false;
-  const concept = store.lookup(ref);
-  if (!concept?.relatedConcepts) return false;
-  return concept.relatedConcepts.some(rc => rc.type === 'provided_by');
+  if (!hyperedge || !store) return false;
+  return glsIsExternalComprehensive(
+    hyperedge as Parameters<typeof glsIsExternalComprehensive>[0],
+    store,
+  );
 }
 
-/**
- * Check if an external concept's reference dangles (no provided_by edge).
- */
-export function isDanglingExternal(
-  ref: RefLike | null | undefined,
-  store: ConceptStoreLike | null | undefined,
+export function getExternalMembers(
+  hyperedge: { comprehensive?: unknown; members?: readonly unknown[] },
+  store: ConceptStore | null | undefined,
+): { ref?: unknown }[] {
+  if (!hyperedge || !store) return [];
+  return glsGetExternalMembers(
+    hyperedge as Parameters<typeof glsGetExternalMembers>[0],
+    store,
+  );
+}
+
+export function hasDanglingExternal(
+  hyperedge: { comprehensive?: unknown; members?: readonly unknown[] },
+  store: ConceptStore | null | undefined,
 ): boolean {
-  return isExternalConcept(ref, store) && !hasProvidedBy(ref, store);
+  if (!hyperedge || !store) return false;
+  return glsHasDanglingExternal(
+    hyperedge as Parameters<typeof glsHasDanglingExternal>[0],
+    store,
+  );
 }
 
 /**
  * Format a label for an external concept — parenthetical per ISO 704.
  * Returns `"(label)"` for external concepts, `label` for internal.
+ *
+ * Kept locally because it's a pure UI concern (rendering decision), not
+ * a model-layer classification.
  */
 export function formatExternalLabel(
   label: string,

package/src/utils/favicon-config-access.ts

@@ -0,0 +1,68 @@
+/**
+ * Defensive favicon config accessor.
+ *
+ * WHY THIS EXISTS
+ *
+ * `loadSiteConfig` (scripts/load-site-config.mjs) normalizes YAML keys
+ * from snake_case to camelCase at load time. So a YAML config with
+ * `branding.favicon.source_dir: assets/favicons` arrives at the CLI as
+ * `cfg.sourceDir`. But the canonical `FaviconConfig` type documents the
+ * snake_case form (matching the YAML wire format), and Astro's
+ * `getSiteConfig` does NOT normalize — so `Default.astro` sees the raw
+ * snake_case form.
+ *
+ * The 0.7.107–0.7.109 CLI used `cfg.source_dir` directly, which silently
+ * returned `undefined` after the loader's normalization. Canonical files
+ * never got copied. Regression caught by user 2026-08-01.
+ *
+ * The fix: this helper reads BOTH forms. Each accessor takes the config
+ * object and returns whichever form is present. The class of "loader
+ * changed normalization, broke the CLI" is now permanently closed.
+ */
+
+export interface RawFaviconConfig {
+  // snake_case (YAML wire format / Astro path)
+  base_path?: string;
+  skip_default_links?: boolean;
+  links_html?: string;
+  source_dir?: string;
+  icons?: unknown;
+  // camelCase (loadSiteConfig normalized form / TS convention)
+  basePath?: string;
+  skipDefaultLinks?: boolean;
+  linksHtml?: string;
+  sourceDir?: string;
+}
+
+function pick<T>(...vals: Array<T | undefined>): T | undefined {
+  for (const v of vals) {
+    if (v !== undefined && v !== null) return v;
+  }
+  return undefined;
+}
+
+export function getFaviconBasePath(cfg: RawFaviconConfig | null | undefined): string | undefined {
+  if (!cfg) return undefined;
+  return pick(cfg.basePath, cfg.base_path);
+}
+
+export function getFaviconSkipDefaultLinks(cfg: RawFaviconConfig | null | undefined): boolean {
+  if (!cfg) return false;
+  return pick(cfg.skipDefaultLinks, cfg.skip_default_links) === true;
+}
+
+export function getFaviconLinksHtml(cfg: RawFaviconConfig | null | undefined): string | undefined {
+  if (!cfg) return undefined;
+  return pick(cfg.linksHtml, cfg.links_html);
+}
+
+export function getFaviconSourceDir(cfg: RawFaviconConfig | null | undefined): string | undefined {
+  if (!cfg) return undefined;
+  return pick(cfg.sourceDir, cfg.source_dir);
+}
+
+export function getFaviconIcons(cfg: RawFaviconConfig | null | undefined): unknown {
+  if (!cfg) return undefined;
+  // `icons` has no snake_case form — same key in both worlds.
+  return cfg.icons;
+}