@glossarist/concept-browser 0.7.133 → 0.7.134

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.133",
+  "version": "0.7.134",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {

package/src/__tests__/components/pipe-bundles.test.ts

@@ -167,3 +167,117 @@ describe('drawGenericPipes — pipe-and-thread contract', () => {
     expect(svg.querySelectorAll('line.pipe-seg').length).toBe(0);
   });
 });
+
+describe('drawGenericPipes — external + ellipsis ghosts (concept-model PR #91)', () => {
+  const pos = new Map<string, { x: number; y: number }>([
+    ['vim-2012/1.9', { x: 0, y: 0 }],
+    ['vim-2012/1.15', { x: 100, y: -50 }],
+  ]);
+
+  function makeGhostRelation(): GenericRelationWire {
+    return {
+      source: 'https://example.org/vim-2012/concept/1.9',
+      comprehensive: 'https://example.org/vim-2012/concept/1.9',
+      completeness: 'complete',
+      criterion: { eng: 'by system membership' },
+      register: 'vim-2012',
+      members: [
+        { uri: 'https://example.org/vim-2012/concept/1.15', presence: 'required', count: 'at_least_one',
+          delimitingCharacteristic: { eng: 'off-system measurement unit' } },
+        { uri: 'urn:gloss:ext:in-system measurement unit', presence: 'optional', count: 'any',
+          external: true, text: 'in-system measurement unit',
+          delimitingCharacteristic: { eng: 'in-system measurement unit' } },
+      ],
+    };
+  }
+
+  function makeEllipsisRelation(): GenericRelationWire {
+    return {
+      source: 'https://example.org/vim-2012/concept/1.9',
+      comprehensive: 'https://example.org/vim-2012/concept/1.9',
+      completeness: 'partial',
+      criterion: { eng: 'by epistemic status' },
+      register: 'vim-2012',
+      members: [
+        { uri: 'https://example.org/vim-2012/concept/1.15', presence: 'required', count: 'at_least_one',
+          delimitingCharacteristic: { eng: 'x' } },
+        { uri: 'urn:gloss:ellipsis', presence: 'required', count: 'exactly_one', ellipsis: true },
+      ],
+    };
+  }
+
+  it('renders an external member as a dashed pill with parenthesized text', () => {
+    const svg = makeSvg();
+    drawGenericPipes(svg, pos, {
+      isDark: false,
+      color: '#b45309',
+      isMuted: false,
+      relations: [makeGhostRelation()],
+      locale: 'eng',
+    });
+    const pill = svg.querySelector('rect.pipe-ghost-external');
+    expect(pill).toBeDefined();
+    expect(pill!.getAttribute('stroke-dasharray')).toBe('3 2');
+    const label = svg.querySelector('text.pipe-ghost-external-label');
+    expect(label).toBeDefined();
+    expect(label!.textContent).toBe('(in-system measurement unit)');
+  });
+
+  it('renders an ellipsis member as a muted ... ghost', () => {
+    const svg = makeSvg();
+    drawGenericPipes(svg, pos, {
+      isDark: false,
+      color: '#b45309',
+      isMuted: false,
+      relations: [makeEllipsisRelation()],
+      locale: 'eng',
+    });
+    const ell = svg.querySelector('text.pipe-ghost-ellipsis');
+    expect(ell).toBeDefined();
+    expect(ell!.textContent).toBe('...');
+  });
+
+  it('keeps a 1-resolved + 1-ghost rake alive (ghosts count as members)', () => {
+    const svg = makeSvg();
+    drawGenericPipes(svg, pos, {
+      isDark: false,
+      color: '#b45309',
+      isMuted: false,
+      relations: [makeGhostRelation()],
+      locale: 'eng',
+    });
+    /* 1 resolved member + 1 ghost = 2 layout members → 1 pipe + 2 threads. */
+    expect(svg.querySelectorAll('line.pipe-seg').length).toBe(3);
+  });
+
+  it('draws ghost threads dashed so they read as non-node placeholders', () => {
+    const svg = makeSvg();
+    drawGenericPipes(svg, pos, {
+      isDark: false,
+      color: '#b45309',
+      isMuted: false,
+      relations: [makeEllipsisRelation()],
+      locale: 'eng',
+    });
+    const dashed = Array.from(svg.querySelectorAll('line.pipe-seg'))
+      .filter(l => l.getAttribute('stroke-dasharray') === '3 3');
+    expect(dashed.length).toBe(1);
+  });
+
+  it('drops a rake whose members are ALL ghosts with no positioned anchor', () => {
+    const svg = makeSvg();
+    const emptyPos = new Map<string, { x: number; y: number }>([
+      ['vim-2012/1.9', { x: 0, y: 0 }],
+    ]);
+    drawGenericPipes(svg, emptyPos, {
+      isDark: false,
+      color: '#b45309',
+      isMuted: false,
+      relations: [makeGhostRelation()],
+      locale: 'eng',
+    });
+    /* 1.15 not in pos → zero positioned members → layout collapses onto
+       comp; ghosts have no anchor distinct from comp, so nothing draws. */
+    expect(svg.querySelectorAll('line.pipe-seg').length).toBe(0);
+  });
+});

package/src/__tests__/wire-keys.test.ts

@@ -60,6 +60,6 @@ describe('GL wire-key SSOT', () => {
     // The point of this test: when adding a key, you remember to update
     // the count; when removing, you notice the test fails. Catches
     // accidental drift in either direction.
-    expect(Object.keys(GL).length).toBe(91);
+    expect(Object.keys(GL).length).toBe(93);
   });
 });

package/src/adapters/jsonld-types.ts

@@ -43,6 +43,8 @@ export interface JsonLdRef {
   'gl:id'?: string;
   'gl:version'?: string;
   'gl:text'?: string;
+  'gl:external'?: boolean;
+  'gl:ellipsis'?: boolean;
   source?: string;
   id?: string;
   version?: string;

package/src/adapters/model-bridge.ts

@@ -298,7 +298,9 @@ function mapRefFromJsonLd(rawRef: JsonLdRef | string | undefined): Record<string
   refObj.id = rawRef[GL.LOCAL_ID] ?? rawRef.id;
   refObj.version = rawRef[GL.VERSION] ?? rawRef.version;
   if (rawRef[GL.TEXT]) refObj.text = rawRef[GL.TEXT];
-  return (refObj.source ?? refObj.id ?? refObj.version ?? refObj.text) != null
+  if (rawRef[GL.EXTERNAL] === true) refObj.external = true;
+  if (rawRef[GL.ELLIPSIS] === true) refObj.ellipsis = true;
+  return (refObj.source ?? refObj.id ?? refObj.version ?? refObj.text ?? refObj.external ?? refObj.ellipsis) != null
     ? refObj : null;
 }
 

package/src/adapters/types.ts

@@ -204,6 +204,14 @@ export interface GenericMemberWire {
    * distinguishes this specific concept from its coordinate concepts.
    * Required on every GenericMember. LocalizedString shape. */
   delimitingCharacteristic: Record<string, string>;
+  /** Inline external concept (concept-model PR #91). No dataset node —
+   * rendered as a dashed `(text)` ghost, never resolved to a URI. */
+  external?: boolean;
+  /** Author-acknowledged gap (concept-model PR #91). Rendered as a
+   * muted `...` ghost. */
+  ellipsis?: boolean;
+  /** Display text for external members (the parenthetical label). */
+  text?: string;
 }
 
 export interface GraphNode {

package/src/adapters/wire-keys.ts

@@ -108,6 +108,12 @@ export const GL = {
   VERSION: 'gl:version',
   TEXT: 'gl:text',
 
+  // ConceptRef external/ellipsis flags (concept-model PR #91).
+  // external = parenthetical (ISO 704:2022 §5.5.4.3.1); renders as `(text)`.
+  // ellipsis = author-acknowledged gap; renders as `...`.
+  EXTERNAL: 'gl:external',
+  ELLIPSIS: 'gl:ellipsis',
+
   // Locally-scoped id within source/origin/ref (NOT JSON-LD's @id)
   LOCAL_ID: 'gl:id',
 

package/src/components/relation-sphere/pipe-bundles.ts

@@ -80,7 +80,16 @@ export function drawGenericPipes(
     if (!compPos) continue;
 
     const memberPositions: PipeLayoutMember[] = [];
+    const ghostMembers: Array<{ member: GenericRelationWire['members'][number]; pos: NodePos }> = [];
     for (const m of rel.members) {
+      /* Ghost members (external / ellipsis, concept-model PR #91) carry
+         synthetic urn:gloss:* URIs that never resolve to a node — they
+         get virtual positions on an arc beyond the middle node and are
+         drawn as dashed ghosts after the layout. */
+      if (m.ellipsis === true || m.external === true) {
+        ghostMembers.push({ member: m, pos: { x: 0, y: 0 } });
+        continue;
+      }
       const parsed = UriRouter.parseUri(m.uri);
       if (!parsed) continue;
       const nid = `${parsed.registerId}/${parsed.conceptId}`;
@@ -89,7 +98,31 @@ export function drawGenericPipes(
       memberPositions.push({ pos: p, delimitingCharacteristic: m.delimitingCharacteristic });
     }
 
-    const layout = computePipeLayout(compPos, memberPositions);
+    /* Ghosts need a middle-node estimate to fan around. With ≥2
+       positioned members the layout gives it directly; with exactly 1
+       use the comp→member midpoint (computePipeLayout requires ≥2 and
+       would return null). Zero positioned members means the ghosts have
+       no anchor — drop the rake. */
+    if (memberPositions.length === 0 && ghostMembers.length > 0) continue;
+    let provisionalMiddle: NodePos | null = null;
+    if (memberPositions.length >= 2) {
+      const l = computePipeLayout(compPos, memberPositions);
+      provisionalMiddle = l ? l.middleNode : null;
+    } else if (memberPositions.length === 1) {
+      provisionalMiddle = {
+        x: (compPos.x + memberPositions[0].pos.x) / 2,
+        y: (compPos.y + memberPositions[0].pos.y) / 2,
+      };
+    }
+    if (!provisionalMiddle) continue;
+    assignGhostPositions(provisionalMiddle, compPos, memberPositions, ghostMembers);
+
+    const allPositions = [
+      ...memberPositions,
+      ...ghostMembers.map(g => ({ pos: g.pos, delimitingCharacteristic: g.member.delimitingCharacteristic })),
+    ];
+
+    const layout = computePipeLayout(compPos, allPositions);
     if (!layout) continue;
 
     /* 1. Thick parent pipe: comp → middle node. The characteristic
@@ -98,9 +131,25 @@ export function drawGenericPipes(
 
     /* 2. Thin threads: middle → each member. No per-thread labels —
           the characteristic is a single hyperedge-level field shared
-          by all members, rendered once on the pipe body. */
-    for (const thread of layout.threads) {
+          by all members, rendered once on the pipe body.
+          Ghost members are excluded here (step 2b draws their dashed
+          threads separately) — layout.threads preserves the
+          allPositions order: positioned members first, ghosts last. */
+    layout.threads.forEach((thread, i) => {
+      if (i >= memberPositions.length) return;
       drawSegment(svg, opts.color, thread.start, thread.end, THREAD_WIDTH);
+    });
+
+    /* 2b. Ghost members — external concepts and ellipsis gaps. Dashed
+          threads + dashed pills so they read as "present but not a
+          node of this dataset" (ISO 704:2022 §5.5.4.3.1). */
+    for (const ghost of ghostMembers) {
+      drawSegment(svg, opts.color, layout.middleNode, ghost.pos, THREAD_WIDTH, { dashed: true, opacity: 0.55 });
+      if (ghost.member.ellipsis === true) {
+        drawEllipsisGhost(svg, ghost.pos, opts.color);
+      } else {
+        drawExternalGhost(svg, ghost.pos, ghost.member.text ?? '', opts.color, opts.isDark);
+      }
     }
 
     /* 3. Square junction at the middle node (distinct from the rake's
@@ -129,7 +178,7 @@ export function drawGenericPipes(
   }
 }
 
-function drawSegment(svg: SVGSVGElement, color: string, from: NodePos, to: NodePos, width: number): void {
+function drawSegment(svg: SVGSVGElement, color: string, from: NodePos, to: NodePos, width: number, style?: { dashed?: boolean; opacity?: number }): void {
   const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
   line.setAttribute('class', 'pipe-seg');
   line.setAttribute('x1', String(from.x));
@@ -139,10 +188,93 @@ function drawSegment(svg: SVGSVGElement, color: string, from: NodePos, to: NodeP
   line.setAttribute('stroke', color);
   line.setAttribute('stroke-width', String(width));
   line.setAttribute('stroke-linecap', 'round');
-  line.setAttribute('opacity', '0.9');
+  line.setAttribute('opacity', String(style?.opacity ?? 0.9));
+  if (style?.dashed) line.setAttribute('stroke-dasharray', '3 3');
   svg.appendChild(line);
 }
 
+/**
+ * Place ghost members (external / ellipsis) on an arc beyond the middle
+ * node, on the side away from the comprehensive, fanned to match the
+ * spread of the positioned members. Pure 2D — ghosts never enter the
+ * 3D force layout.
+ */
+function assignGhostPositions(
+  middleNode: NodePos,
+  compPos: NodePos,
+  positioned: readonly { pos: NodePos }[],
+  ghosts: Array<{ pos: NodePos }>,
+): void {
+  if (ghosts.length === 0) return;
+  /* Fan radius: a bit beyond the average positioned-member distance
+     from the middle node so ghosts sit outside the resolved set. */
+  const avgDist = positioned.length > 0
+    ? positioned.reduce((s, m) => s + Math.hypot(m.pos.x - middleNode.x, m.pos.y - middleNode.y), 0) / positioned.length
+    : 40;
+  const radius = Math.max(avgDist, 40);
+  /* Base direction: away from the comprehensive. */
+  const awayX = middleNode.x - compPos.x;
+  const awayY = middleNode.y - compPos.y;
+  const awayLen = Math.hypot(awayX, awayY) || 1;
+  const baseAngle = Math.atan2(awayY / awayLen, awayX / awayLen);
+  const spread = 0.5; /* radians between consecutive ghosts */
+  ghosts.forEach((g, i) => {
+    const offset = ghosts.length === 1 ? 0 : (i - (ghosts.length - 1) / 2) * spread;
+    const a = baseAngle + offset;
+    g.pos.x = middleNode.x + Math.cos(a) * radius;
+    g.pos.y = middleNode.y + Math.sin(a) * radius;
+  });
+}
+
+/** Ellipsis ghost: a muted "..." — the author knew more members exist. */
+function drawEllipsisGhost(svg: SVGSVGElement, at: NodePos, color: string): void {
+  const text = document.createElementNS('http://www.w3.org/2000/svg', 'text');
+  text.setAttribute('class', 'pipe-ghost-ellipsis');
+  text.setAttribute('x', String(at.x));
+  text.setAttribute('y', String(at.y + 3));
+  text.setAttribute('text-anchor', 'middle');
+  text.setAttribute('fill', color);
+  text.setAttribute('font-size', '11');
+  text.setAttribute('font-family', 'JetBrains Mono, monospace');
+  text.setAttribute('font-weight', '600');
+  text.setAttribute('opacity', '0.8');
+  text.textContent = '...';
+  svg.appendChild(text);
+}
+
+/** External ghost: dashed-border pill with the parenthetical label. */
+function drawExternalGhost(svg: SVGSVGElement, at: NodePos, label: string, color: string, isDark: boolean): void {
+  const fontSize = 9;
+  const text = label ? `(${label})` : '(external)';
+  const w = Math.max(text.length * (fontSize * 0.55) + 10, 34);
+  const h = 15;
+  const rect = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
+  rect.setAttribute('class', 'pipe-ghost-external');
+  rect.setAttribute('x', String(at.x - w / 2));
+  rect.setAttribute('y', String(at.y - h / 2));
+  rect.setAttribute('width', String(w));
+  rect.setAttribute('height', String(h));
+  rect.setAttribute('rx', '4');
+  rect.setAttribute('fill', isDark ? 'rgba(26,18,8,0.85)' : 'rgba(255,255,255,0.92)');
+  rect.setAttribute('stroke', color);
+  rect.setAttribute('stroke-width', '1');
+  rect.setAttribute('stroke-dasharray', '3 2');
+  rect.setAttribute('opacity', '0.92');
+  svg.appendChild(rect);
+
+  const t = document.createElementNS('http://www.w3.org/2000/svg', 'text');
+  t.setAttribute('class', 'pipe-ghost-external-label');
+  t.setAttribute('x', String(at.x));
+  t.setAttribute('y', String(at.y + 3));
+  t.setAttribute('text-anchor', 'middle');
+  t.setAttribute('fill', color);
+  t.setAttribute('font-size', String(fontSize));
+  t.setAttribute('font-family', 'JetBrains Mono, monospace');
+  t.setAttribute('font-style', 'italic');
+  t.textContent = text;
+  svg.appendChild(t);
+}
+
 function drawSquare(svg: SVGSVGElement, cx: number, cy: number, half: number, fill: string, stroke: string): void {
   const rect = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
   rect.setAttribute('class', 'pipe-junction');

package/src/composables/use-concept-edges.ts

@@ -190,7 +190,26 @@ export function useConceptEdges(
     const isGeneric = rel instanceof GenericHyperedge;
     const members: any[] = (rel?.members ?? rel?.partitives ?? [])
       .map((m: any): any | null => {
-        const uri = resolveConceptRefUri(m?.ref);
+        const ref = m?.ref;
+        /* Ghost members (concept-model PR #91): external parenthetical
+           concepts and ellipsis gaps have no dataset node, so they get a
+           synthetic urn: URI plus flags. Renderers draw them as ghosts
+           without resolving the URI. */
+        if (ref?.ellipsis === true) {
+          return { uri: 'urn:gloss:ellipsis', presence: m?.presence, count: m?.count, ellipsis: true };
+        }
+        if (ref?.external === true || ref?.isExternal === true) {
+          const text = ref?.text ?? '';
+          return {
+            uri: `urn:gloss:ext:${text}`,
+            presence: m?.presence,
+            count: m?.count,
+            external: true,
+            text,
+            ...(isGeneric ? { delimitingCharacteristic: m?.delimitingCharacteristic } : {}),
+          };
+        }
+        const uri = resolveConceptRefUri(ref);
         if (!uri || uri === source) return null;
         const base: any = {
           uri,