@glossarist/concept-browser 0.7.113 → 0.7.115

package/src/utils/content-renderer.ts

@@ -5,19 +5,28 @@
  * math placeholders, tables, lists, and text formatting. This is the single
  * source of truth for content rendering in the browser.
  *
- * Mention kinds routed here (all dispatched by glossarist's `parseMention`):
- *   - {{fig:id}} / {{fig:id, display}}  → nonVerbalRefResolver (figure)
- *   - {{table:id}} / {{table:id, display}}  → nonVerbalRefResolver (table)
- *   - {{formula:id}} / {{formula:id, display}}  → nonVerbalRefResolver (formula)
- *   - {{cite:key[, render term]}}  → citeResolver
- *   - {{urn:...[, render term]}}  → xrefResolver
- *   - {{concept_id[, render term]}}  → conceptRefResolver
- *   - {{designation[, render term]}}  → conceptRefResolver
+ * Unified mention syntax: {{kind:target[, label]}}
+ * Every inline reference is a typed mention with a kind prefix:
+ *
+ *   - {{cite:key[, label]}}    → citeResolver (concept source citation)
+ *   - {{urn:...[, label]}}     → xrefResolver (URN routing)
+ *   - {{fig:id[, label]}}      → nonVerbalRefResolver (figure)
+ *   - {{table:id[, label]}}    → nonVerbalRefResolver (table)
+ *   - {{formula:id[, label]}}  → nonVerbalRefResolver (formula)
+ *   - {{bib:id[, label]}}      → bibResolver (bibliography entry, case-3-only)
+ *   - {{link:URL[, label]}}    → linkResolver (external URL)
+ *   - {{image:src[, alt]}}     → imageResolver (inline image embed)
+ *   - {{designation[, label]}} → conceptRefResolver (designation match)
+ *   - {{numeric_id[, label]}}  → conceptRefResolver (numeric ID match)
+ *
+ * Legacy `<<ref,title>>` (AsciiDoc xref) is deprecated; emits a console
+ * warning and renders as plain text. Migrate to {{kind:target}} syntax.
  *
  * Math-specific helpers (replaceBracketed, mathPlaceholder) are internal.
  * The v-math directive upgrades the placeholders to Plurimath at runtime.
  */
 import { escapeHtml, escapeAttr } from './escape';
+import { sanitizeUrl, isSafeUrl } from './url-safety';
 import { parseMention } from 'glossarist';
 import type { NonVerbalKind } from '../adapters/non-verbal/types';
 import { entityKindFromMentionKind } from '../adapters/non-verbal/kind';
@@ -29,6 +38,8 @@ export type BibResolver = (refId: string, title: string) => string;
 export type CiteResolver = (key: string, label: string | null) => string;
 export type ConceptRefResolver = (conceptId: string, term: string) => string;
 export type NonVerbalRefResolver = (kind: NonVerbalKind, entityId: string, display?: string) => string;
+export type LinkResolver = (url: string, label: string) => string;
+export type ImageResolver = (src: string, alt: string) => string;
 
 export interface RenderOptions {
   xrefResolver?: XrefResolver;
@@ -36,6 +47,8 @@ export interface RenderOptions {
   conceptRefResolver?: ConceptRefResolver;
   citeResolver?: CiteResolver;
   nonVerbalRefResolver?: NonVerbalRefResolver;
+  linkResolver?: LinkResolver;
+  imageResolver?: ImageResolver;
 }
 
 // ── Math placeholders ────────────────────────────────────────────────────
@@ -123,7 +136,7 @@ function convertLists(text: string): string {
       items.push(m[1].trim());
     }
     if (!items.length) return _;
-    const lis = items.map(item => `<li>${item}</li>`).join('');
+    const lis = items.map(item => `<li>${escapeHtml(item)}</li>`).join('');
     return `\n<ul class="concept-list">${lis}</ul>`;
   });
 
@@ -135,7 +148,7 @@ function convertLists(text: string): string {
       items.push(m[1].trim());
     }
     if (!items.length) return _;
-    const lis = items.map(item => `<li>${item}</li>`).join('');
+    const lis = items.map(item => `<li>${escapeHtml(item)}</li>`).join('');
     return `\n<ol class="concept-list concept-list-ordered">${lis}</ol>`;
   });
 
@@ -144,12 +157,30 @@ function convertLists(text: string): string {
 
 // ── Inline reference resolution ──────────────────────────────────────────
 
-function resolveBibRefs(text: string, opts: RenderOptions): string {
+/**
+ * Deprecated AsciiDoc xref syntax: <<refId, title>>
+ *
+ * This was historically overloaded for:
+ *   1. Non-concept entity xrefs (should use {{fig/table/formula:id, label}})
+ *   2. Bibliography lookups (should use {{bib:id}} or {{cite:id}})
+ *   3. Concept citations (should use {{cite:id}})
+ *
+ * All three uses are wrong. This function emits a deprecation warning and
+ * renders the title as plain text. Datasets should migrate to the unified
+ * {{kind:target}} syntax.
+ */
+function resolveLegacyXref(text: string): string {
   return text.replace(/<<([^,>]+),([^>]+)>>/g, (_, refId, title) => {
-    if (opts.bibResolver) {
-      return opts.bibResolver(refId.trim(), title.trim());
+    const rid = refId.trim();
+    const lbl = title.trim();
+    if (typeof console !== 'undefined') {
+      console.warn(
+        `[glossarist] <<${rid},${lbl}>> is deprecated. ` +
+        `Use {{fig/table/formula:${rid}, ${lbl}}} for non-concept entities, ` +
+        `{{cite:${rid}}} for concept citations, or {{bib:${rid}}} for bibliography.`,
+      );
     }
-    return `<span class="bib-ref">${escapeHtml(title.trim())}</span>`;
+    return `<span class="legacy-xref" title="Deprecated: use {{kind:target}} syntax">${escapeHtml(lbl)}</span>`;
   });
 }
 
@@ -180,6 +211,48 @@ function resolveUrnRefs(text: string, opts: RenderOptions): string {
 
 function resolveMentions(text: string, opts: RenderOptions): string {
   return text.replace(/\{\{([^{}]+?)\}\}/g, (_orig, body) => {
+
+    // ── New kinds: link, image, bib (pre-parsed before parseMention) ──
+    // These follow the same {{kind:target[, label]}} convention as
+    // fig/table/formula but are handled here because glossarist's
+    // parseMention doesn't recognize them yet. When glossarist-js adds
+    // support (per PROMPT-NOW.md), these pre-parse cases can be removed
+    // and the switch below will handle them natively.
+
+    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());
+      const label = commaIdx > 0 ? rest.slice(commaIdx + 1).trim() : url;
+      if (opts.linkResolver) return opts.linkResolver(url, label);
+      const safeUrl = sanitizeUrl(url);
+      if (!safeUrl) return escapeHtml(label);
+      return `<a href="${escapeAttr(safeUrl)}" target="_blank" rel="noopener" class="ext-link">${escapeHtml(label)}</a>`;
+    }
+
+    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());
+      const alt = commaIdx > 0 ? rest.slice(commaIdx + 1).trim() : '';
+      if (opts.imageResolver) return opts.imageResolver(src, alt);
+      if (!isSafeUrl(src)) return escapeHtml(alt || src);
+      return `<img src="${escapeAttr(src)}" alt="${escapeAttr(alt)}" class="inline-image" />`;
+    }
+
+    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());
+      const label = commaIdx > 0 ? rest.slice(commaIdx + 1).trim() : id;
+      if (opts.bibResolver) return opts.bibResolver(id, label);
+      return `<span class="bib-ref">${escapeHtml(label)}</span>`;
+    }
+
+    // ── Existing kinds: handled by glossarist's parseMention ──
     const parsed = parseMention(body);
     const p = parsed as unknown as Record<string, unknown>;
 
@@ -253,10 +326,10 @@ function resolveMentions(text: string, opts: RenderOptions): string {
  * 2. AsciiDoc tables
  * 3. Bullet and numbered lists
  * 4. Text formatting (bold, italic, subscript)
- * 5. Bibliography cross-references (<<ref,title>>)
- * 6. Single-brace URN inline references ({urn:...})
- * 7. Mention dispatcher — non-verbal (fig/table/formula), then parseMention
- *    (cite-ref, urn-ref, numeric, designation)
+ * 5. Legacy AsciiDoc xrefs (<<ref,title>> → deprecated, renders as plain text)
+ * 6. URN inline references ({urn:...})
+ * 7. Mention dispatcher — link/image/bib (pre-parsed), then parseMention
+ *    (fig/table/formula, cite-ref, urn-ref, numeric, designation)
  */
 export function renderContent(text: string, xrefResolverOrOpts?: XrefResolver | RenderOptions): string {
   if (!text) return '';
@@ -280,7 +353,7 @@ export function renderContent(text: string, xrefResolverOrOpts?: XrefResolver |
   result = result.replace(/~([^~]+)~/g, '<sub>$1</sub>');
 
   // Stage 4: Reference resolution
-  result = resolveBibRefs(result, opts);
+  result = resolveLegacyXref(result);
   result = resolveUrnRefs(result, opts);
 
   // Stage 5: Mention dispatcher (non-verbal first, then parseMention SSOT)
@@ -296,18 +369,28 @@ export function renderContent(text: string, xrefResolverOrOpts?: XrefResolver |
 export function cleanContent(text: string): string {
   if (!text) return '';
   let result = text
+    // Legacy xrefs first (before HTML tag stripping eats <<)
+    .replace(/<<([^,>]+),([^>]+)>>/g, '$2')
     .replace(/<[^>]+>/g, '')
     .replace(/\*\*([^*]+)\*\*/g, '$1')
     .replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, '$1')
     .replace(/~([^~]+)~/g, '_$1')
     .replace(/\n[ \t]*\* /g, '; ')
-    .replace(/<<([^,>]+),([^>]+)>>/g, '$2')
-    // Non-verbal mentions: {{fig:id, display}} → display; {{fig:id}} → id
+    // Entity mentions: {{fig:id, display}} → display; {{fig:id}} → id
     .replace(/\{\{(?:fig|figure|table|tbl|formula|eq):([^,}]+),\s*([^}]+)\}\}/g, '$2')
     .replace(/\{\{(?:fig|figure|table|tbl|formula|eq):([^}]+)\}\}/g, '$1')
+    // Link mentions: {{link:URL, label}} → label; {{link:URL}} → URL
+    .replace(/\{\{link:([^,}]+),\s*([^}]+)\}\}/gi, '$2')
+    .replace(/\{\{link:([^}]+)\}\}/gi, '$1')
+    // Image mentions: {{image:src, alt}} → alt; {{image:src}} → empty
+    .replace(/\{\{image:[^,}]+,\s*([^}]+)\}\}/gi, '$1')
+    .replace(/\{\{image:([^}]+)\}\}/gi, '')
+    // Bib mentions: {{bib:id, label}} → label; {{bib:id}} → id
+    .replace(/\{\{bib:([^,}]+),\s*([^}]+)\}\}/gi, '$2')
+    .replace(/\{\{bib:([^}]+)\}\}/gi, '$1')
     // URN refs — show render term (second part for two-arg, third part for three-arg)
-    .replace(/\{\{urn:[^,}]+,([^,}]+),([^}]+)\}\}/g, '$1')  // three-arg: {{urn:...,term,display}} → term
-    .replace(/\{\{urn:[^,}]+(?:,([^}]+))?\}\}/g, (_, label) => label ? label.trim() : '')  // two-arg or bare
+    .replace(/\{\{urn:[^,}]+,([^,}]+),([^}]+)\}\}/g, '$1')
+    .replace(/\{\{urn:[^,}]+(?:,([^}]+))?\}\}/g, (_, label) => label ? label.trim() : '')
     .replace(/\{urn:[^,}]+,([^,}]+)(?:,[^}]+)?\}/g, '$1')
     // Cite refs — show render term (or empty if bare)
     .replace(/\{\{cite:[^,}]+(?:,([^}]+))?\}\}/g, (_, label) => label ? label.trim() : '')

package/src/utils/url-safety.ts

@@ -18,11 +18,7 @@ export function isSafeUrl(url: string): boolean {
     }
   }
 
-  if (trimmed.startsWith('#') || trimmed.startsWith('/') || trimmed.startsWith('./') || trimmed.startsWith('../')) {
-    return true;
-  }
-
-  return false;
+  return true;
 }
 
 export function sanitizeUrl(url: string): string {

package/src/views/learn/LearnInlineContentView.vue

@@ -0,0 +1,128 @@
+<script setup lang="ts">
+/**
+ * LearnInlineContentView — unified inline content syntax reference.
+ *
+ * Documents every {{kind:target}} mention kind with examples,
+ * explains the data/deployment boundary for citations, and shows
+ * the resolution cascade.
+ */
+import { computed } from 'vue';
+import { useI18n } from '../../i18n';
+import LearnCard from '../../components/learn/LearnCard.vue';
+
+const { t } = useI18n();
+
+const introText = computed(() =>
+  t('learn.inlineContent.intro') ||
+  'Every inline reference in concept text uses the unified mustache-kind:target notation. The first word (before the colon) tells you what kind of reference it is.',
+);
+
+const mentionKinds = [
+  { kind: 'cite', syntax: '{{cite:sourceId}}', example: '{{cite:iso7301}}', desc: 'Cite a ConceptSource from this concept\'s sources[] list. Walks the full resolution cascade (co-deployed → routed → bib).' },
+  { kind: 'cite + label', syntax: '{{cite:sourceId, label}}', example: '{{cite:iso7301, rice}}', desc: 'Same as cite, with an explicit display label.' },
+  { kind: 'urn', syntax: '{{urn:URN}}', example: '{{urn:iso:std:iso:704}}', desc: 'Reference a concept via URN routing. The deployment decides which dataset (if any) handles this URN.' },
+  { kind: 'fig', syntax: '{{fig:id}}', example: '{{fig:diagram_3}}', desc: 'Reference a figure entity in the same dataset.' },
+  { kind: 'table', syntax: '{{table:id}}', example: '{{table:unit_list}}', desc: 'Reference a table entity.' },
+  { kind: 'formula', syntax: '{{formula:id}}', example: '{{formula:ohm_law}}', desc: 'Reference a formula entity.' },
+  { kind: 'bib', syntax: '{{bib:id}}', example: '{{bib:ref_1}}', desc: 'Bibliography entry (case-3-only — no underlying concept). Renders as a flat reference.' },
+  { kind: 'link', syntax: '{{link:URL}}', example: '{{link:https://example.com}}', desc: 'External URL. The URL is canonical; the deployment has no say.' },
+  { kind: 'link + label', syntax: '{{link:URL, label}}', example: '{{link:https://example.com, click here}}', desc: 'External URL with display label.' },
+  { kind: 'image', syntax: '{{image:src}}', example: '{{image:diagram.png}}', desc: 'Inline image embed. Local images get basePath-prefixed.' },
+  { kind: 'image + alt', syntax: '{{image:src, alt}}', example: '{{image:diagram.png, The diagram}}', desc: 'Image with accessibility alt text.' },
+  { kind: 'designation', syntax: '{{designation}}', example: '{{measurement unit}}', desc: 'Reference a concept by matching its designation text (same dataset).' },
+  { kind: 'numeric', syntax: '{{numeric_id}}', example: '{{112-01-10}}', desc: 'Reference a concept by numeric ID (same dataset).' },
+];
+
+const cascade = [
+  { step: 1, name: 'uriPatterns', desc: 'Is there a co-deployed dataset that matches this URI?', result: 'Internal link (case 1)' },
+  { step: 2, name: 'routing[]', desc: 'Is there a routing entry for this URI in site-config.yml?', result: 'External link (case 2)' },
+  { step: 3, name: 'citation.link', desc: 'Does the source have a canonical link?', result: 'Flat bib record (case 3)' },
+  { step: 4, name: 'unresolved', desc: 'No match anywhere', result: 'Plain text' },
+];
+</script>
+
+<template>
+  <div class="max-w-4xl mx-auto px-4 sm:px-6 lg:px-8 py-8 space-y-6">
+    <h1 class="font-title text-3xl text-ink-800 dark:text-ink-50 mb-2">
+      {{ t('learn.inlineContent.title') || 'Inline Content Syntax' }}
+    </h1>
+    <p class="text-ink-500 dark:text-ink-400">
+      {{ introText }}
+    </p>
+
+    <LearnCard title="Mention Kinds">
+      <template #body>
+        <div class="overflow-x-auto">
+          <table class="w-full text-sm">
+            <thead>
+              <tr class="border-b border-ink-100 dark:border-ink-700 text-left">
+                <th class="py-2 pr-4">Kind</th>
+                <th class="py-2 pr-4">Syntax</th>
+                <th class="py-2 pr-4">Example</th>
+                <th class="py-2">Description</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="row in mentionKinds" :key="row.syntax" class="border-b border-ink-50 dark:border-ink-800">
+                <td class="py-2 pr-4 font-mono text-xs text-ink-600 dark:text-ink-300">{{ row.kind }}</td>
+                <td class="py-2 pr-4 font-mono text-xs text-ink-700 dark:text-ink-200">{{ row.syntax }}</td>
+                <td class="py-2 pr-4 font-mono text-xs text-emerald-700 dark:text-emerald-300">{{ row.example }}</td>
+                <td class="py-2 text-xs text-ink-500 dark:text-ink-400">{{ row.desc }}</td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+      </template>
+    </LearnCard>
+
+    <LearnCard title="Data / Deployment Boundary">
+      <template #body>
+        <div class="space-y-3 text-sm text-ink-600 dark:text-ink-300">
+          <p>
+            <strong>Dataset authors</strong> write citations in a deployment-agnostic way.
+            They don't know where their dataset will be deployed or what other datasets will be co-deployed.
+          </p>
+          <p>
+            <strong>Deployers</strong> write <code class="text-xs bg-ink-50 dark:bg-ink-800 px-1 rounded">site-config.yml</code>
+            to register datasets and declare URI patterns. They never edit dataset content.
+          </p>
+          <p>
+            <strong>Concept-browser</strong> resolves every citation at runtime. The same YAML works in any deployment.
+          </p>
+        </div>
+      </template>
+    </LearnCard>
+
+    <LearnCard title="Resolution Cascade">
+      <template #body>
+        <div class="space-y-2">
+          <div v-for="step in cascade" :key="step.step" class="flex items-start gap-3 py-2">
+            <span class="flex-shrink-0 w-6 h-6 rounded-full bg-ink-100 dark:bg-ink-700 text-ink-600 dark:text-ink-300 text-xs font-mono flex items-center justify-center">{{ step.step }}</span>
+            <div class="flex-1">
+              <div class="font-mono text-xs text-ink-700 dark:text-ink-200">{{ step.name }}</div>
+              <div class="text-xs text-ink-500 dark:text-ink-400">{{ step.desc }}</div>
+              <div class="text-xs text-emerald-700 dark:text-emerald-300 mt-0.5">{{ step.result }}</div>
+            </div>
+          </div>
+        </div>
+      </template>
+    </LearnCard>
+
+    <LearnCard title="Deprecated: <<ref,title>>">
+      <template #body>
+        <div class="text-sm text-ink-600 dark:text-ink-300 space-y-2">
+          <p>
+            The AsciiDoc xref syntax <code class="text-xs bg-amber-50 dark:bg-amber-900/20 px-1 rounded">&lt;&lt;ref,title&gt;&gt;</code>
+            is deprecated. It emits a console warning and renders as plain text.
+          </p>
+          <p>Migrate to the unified syntax:</p>
+          <ul class="list-disc list-inside text-xs space-y-1">
+            <li><code>&lt;&lt;fig_3,Figure 3&gt;&gt;</code> → <code class="text-emerald-700 dark:text-emerald-300" v-text="'{{fig:fig_3, Figure 3}}'"></code></li>
+            <li><code>&lt;&lt;845-01-01, 845-01-01&gt;&gt;</code> → <code class="text-emerald-700 dark:text-emerald-300" v-text="'{{cite:iev_845-01-01}}'"></code></li>
+            <li><code>&lt;&lt;ref_1, ISO 704&gt;&gt;</code> → <code class="text-emerald-700 dark:text-emerald-300" v-text="'{{bib:ref_1, ISO 704}}'"></code></li>
+          </ul>
+        </div>
+      </template>
+    </LearnCard>
+  </div>
+</template>

package/tsconfig.json

@@ -20,6 +20,6 @@
     },
     "baseUrl": "."
   },
-  "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.vue", "cli/**/*.ts", "env.d.ts", ".astro/types.d.ts"],
-  "exclude": ["src/content.config.ts", "src/pages/**", "src/layouts/**", "src/astro-islands/**", "src/lib/site-config.ts"]
+  "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.vue", "env.d.ts", ".astro/types.d.ts"],
+  "exclude": ["src/content.config.ts", "src/pages/**", "src/layouts/**", "src/astro-islands/**", "src/lib/site-config.ts", "src/__tests__/**", "scripts/**", "cli/**"]
 }

package/vite.config.ts

@@ -183,7 +183,7 @@ export default defineConfig({
     globals: true,
     include: [
       'src/__tests__/**/*.test.ts',
-      'scripts/__tests__/**/*.test.mjs',
+      'scripts/__tests__/**/*.test.ts',
     ],
   },
 })

package/src/__tests__/composables/use-concept-edges-v2.test.ts

@@ -1,167 +0,0 @@
-// @ts-nocheck — TODO.typescript/12: remove after glossarist TS migration
-import { describe, it, expect } from 'vitest';
-// glossarist 0.4.33 renamed PartitiveRelation → PartitiveHyperedge.
-// Import from glossarist/models (extended by our local augmentation).
-import type {
-  PartitiveHyperedge,
-  PartitiveMember,
-  ConceptRef,
-} from 'glossarist/models';
-import {
-  PartitiveHyperedge as PartitiveHyperedgeModel,
-  PartitiveMember as PartitiveMemberModel,
-  ConceptRef as ConceptRefModel,
-} from 'glossarist/models';
-
-/**
- * Verifies glossarist-js 0.4.26's MECE-native PartitiveRelation model
- * (ISO 704:2022 presence × count + is_delimiting).
- *
- * The concept-browser consumes these fields directly (no migration
- * bridge). These specs pin the runtime contract so a regression in
- * upstream is caught here.
- */
-
-function makeRef(source: string, id: string): ConceptRef {
-  return ConceptRefModel.fromJSON({ source, id }) as ConceptRef;
-}
-
-function makePartitive(
-  source: string,
-  id: string,
-  fields: { presence?: 'required' | 'optional'; count?: 'exactly_one' | 'at_least_one' | 'multiple'; isDelimiting?: boolean } = {},
-): PartitiveMember {
-  const data: {
-    ref: ConceptRef;
-    presence?: 'required' | 'optional';
-    count?: 'exactly_one' | 'at_least_one' | 'multiple';
-    is_delimiting?: boolean;
-  } = { ref: makeRef(source, id) };
-  if (fields.presence) data.presence = fields.presence;
-  if (fields.count) data.count = fields.count;
-  if (fields.isDelimiting) data.is_delimiting = fields.isDelimiting;
-  return new (PartitiveMemberModel as unknown as new (data: unknown) => PartitiveMember)(data) as PartitiveMember;
-}
-
-function makeRelation(opts: {
-  comprehensive: ConceptRef;
-  partitives: PartitiveMember[];
-  completeness?: 'complete' | 'partial';
-  criterion?: Record<string, string>;
-}): PartitiveHyperedge {
-  return new (PartitiveHyperedgeModel as unknown as new (data: unknown) => PartitiveHyperedge)(opts) as PartitiveHyperedge;
-}
-
-describe('useConceptEdges — MECE PartitiveRelation (glossarist 0.4.26)', () => {
-  describe('PartitiveMember (ISO 704:2022 presence × count + delimiting)', () => {
-    it('presence defaults to required, count defaults to exactly_one', () => {
-      const m = makePartitive('test', '1.1');
-      expect(m.presence).toBe('required');
-      expect(m.presence === "required").toBe(true);
-      expect(m.presence === "optional").toBe(false);
-    });
-
-    it('count defaults to exactly_one', () => {
-      const m = makePartitive('test', '1.1');
-      expect(m.count).toBe('exactly_one');
-    });
-
-    it('presence=optional is preserved', () => {
-      const m = makePartitive('test', '1.1', { presence: 'optional' });
-      expect(m.presence).toBe('optional');
-      expect(m.presence === "optional").toBe(true);
-      expect(m.presence === "required").toBe(false);
-    });
-
-    it('count=multiple is preserved', () => {
-      const m = makePartitive('test', '1.1', { count: 'multiple' });
-      expect(m.count).toBe('multiple');
-    });
-
-    it('count=at_least_one is preserved', () => {
-      const m = makePartitive('test', '1.1', { count: 'at_least_one' });
-      expect(m.count).toBe('at_least_one');
-    });
-
-    it('is_delimiting defaults to false', () => {
-      const m = makePartitive('test', '1.1');
-      expect((m as any).is_delimiting).toBe(false);
-      expect((m as any).is_delimiting).toBe(false);
-    });
-
-    it('is_delimiting is preserved when set to true', () => {
-      const m = makePartitive('test', '1.1', { isDelimiting: true });
-      expect((m as any).is_delimiting).toBe(true);
-      expect((m as any).is_delimiting).toBe(true);
-    });
-
-    it('rejects the vacuous (presence=optional, count=at_least_one)', () => {
-      expect(() =>
-        makePartitive('test', '1.1', { presence: 'optional', count: 'at_least_one' }),
-      ).toThrow(/collapses to optional \+ multiple/);
-    });
-  });
-
-  describe('PartitiveRelation', () => {
-    it('accepts 2 members with default axes', () => {
-      const r = makeRelation({
-        comprehensive: makeRef('test', '1.3'),
-        partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
-      });
-      expect((r as any).members).toHaveLength(2);
-      expect((r as any).completeness).toBe('complete');
-      expect((r as any).isComplete).toBe(true);
-      expect((r as any).isPartial).toBe(false);
-    });
-
-    it('completeness=partial is preserved', () => {
-      const r = makeRelation({
-        comprehensive: makeRef('test', '1.3'),
-        partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
-        completeness: 'partial',
-      });
-      expect((r as any).completeness).toBe('partial');
-      expect((r as any).isPartial).toBe(true);
-    });
-
-    it('isCoordinate true when ≥2 partitives', () => {
-      const r = makeRelation({
-        comprehensive: makeRef('test', '1.3'),
-        partitives: [makePartitive('test', '1.4'), makePartitive('test', '1.5')],
-      });
-      expect((r as any).isCoordinate).toBe(true);
-    });
-
-    it('rejects < 2 partitives (ISO 704 requirement)', () => {
-      expect(() => makeRelation({
-        comprehensive: makeRef('test', '1.3'),
-        partitives: [makePartitive('test', '1.4')],
-      })).toThrow(/≥2 partitives/);
-    });
-
-    it('round-trips through toJSON with MECE fields', () => {
-      const r = makeRelation({
-        comprehensive: makeRef('test', '1.3'),
-        partitives: [
-          makePartitive('test', '1.4', { presence: 'required', count: 'multiple' }),
-          makePartitive('test', '1.5', { presence: 'optional', isDelimiting: true }),
-        ],
-        completeness: 'partial',
-        criterion: { eng: 'physical structure' },
-      });
-      const json = r.toJSON() as {
-        comprehensive: unknown;
-        partitives: Array<{ presence?: string; count?: string; is_delimiting?: boolean; ref: unknown }>;
-        completeness: string;
-        criterion?: Record<string, string>;
-      };
-      expect(json.comprehensive).toBeDefined();
-      expect(json.partitives).toHaveLength(2);
-      expect(json.partitives[0].count).toBe('multiple');
-      expect(json.partitives[1].presence).toBe('optional');
-      expect(json.partitives[1].is_delimiting).toBe(true);
-      expect(json.completeness).toBe('partial');
-      expect(json.criterion).toEqual({ eng: 'physical structure' });
-    });
-  });
-});