@transitrix/diagrams 1.2.0 → 1.4.0

package/src/repo-validate/validate-repo.ts

@@ -141,17 +141,240 @@ function checkReferentialIntegrity(input: RepoModelInput, findings: RepoFinding[
   }
 }
 
-/** Phase 5 — ArchiMate layer-semantics on relations.
+/** Phase 5 — ArchiMate layer-semantics on relations and elements.
  *
- * lint.py ships `_check_semantic_rules` as a no-op stub (`pass`). It is ported
- * here faithfully as a no-op so repo-scope validation reaches parity with
- * lint.py on the reference fixture. Real layer-semantics rules are DEFERRED
- * until the methodology defines them; when it does, they land here (a relation
- * whose `type` is illegal between its endpoints' ArchiMate layers). Kept as a
- * named hook so the intent — and the gap — is explicit rather than missing. */
-function checkLayerSemantics(_input: RepoModelInput, _findings: RepoFinding[]): void {
-  // Intentionally empty — parity with lint.py's stubbed phase 5. Do not add
-  // rules here without coordinating the methodology semantics canon.
+ * Enforces endpoint-type constraints for relation kinds whose methodology
+ * semantics are formally defined. Rules added here must have a corresponding
+ * entry in methodology `notations/elements/17-relations.md`; do not add
+ * speculative rules.
+ *
+ * Implemented relation kinds:
+ *   unit_located_at — ACTOR(business_unit) → LOCATION        (21-locations.md)
+ *   located_at      — ACTOR(person|business_unit) → LOCATION (canonical form)
+ *   offers          — ACTOR(business_unit)|ROLE → BUSINESS_SERVICE (25-business-services.md)
+ *   realizes        — BUSINESS_SERVICE → CAPABILITY           (25-business-services.md)
+ *   hosts           — NODE → TECHNOLOGY_SERVICE               (25-nodes.md / 26-technology-services.md)
+ *   uses            — APPLICATION → TECHNOLOGY_SERVICE        (26-technology-services.md)
+ *
+ * Implemented element checks:
+ *   TSVC-003        — TECHNOLOGY_SERVICE.node must resolve to NODE notation
+ *                     (26-technology-services.md §5)
+ *
+ * Implemented element checks:
+ *   INT-002 — INTEGRATION(interface_semantics: true) source/target → APPLICATION
+ *             (ELEMENT_PRIMITIVES.md §7.8.1)
+ *
+ * lint.py ships this as a no-op stub; Studio is ahead of the Python tool here.
+ * These findings are non-blocking for cross-tool parity — they surface only in
+ * the TypeScript validator path (CLI `validate --scope=repo`). */
+function checkLayerSemantics(input: RepoModelInput, findings: RepoFinding[]): void {
+  const elementById = new Map<string, Record<string, unknown>>();
+  for (const doc of input.elements) {
+    const id = docId(doc);
+    if (id && doc.data) elementById.set(id, doc.data);
+  }
+
+  for (const doc of input.relations) {
+    if (!doc.data) continue;
+    const relId = docId(doc) ?? '';
+    const relType = doc.data['type'];
+    if (typeof relType !== 'string') continue;
+
+    const fromId = endpointId(doc.data['from']) ?? endpointId(doc.data['source']);
+    const toId = endpointId(doc.data['to']) ?? endpointId(doc.data['target']);
+
+    if (relType === 'unit_located_at') {
+      if (fromId) {
+        const from = elementById.get(fromId);
+        if (from && (from['notation'] !== 'actor' || from['type'] !== 'business_unit')) {
+          findings.push({
+            scope: PScope,
+            id: relId,
+            message:
+              `Layer-semantics: '${relId}' type 'unit_located_at' requires from to be ` +
+              `ACTOR(business_unit); got notation='${from['notation']}', type='${from['type']}'.`,
+          });
+        }
+      }
+      if (toId) {
+        const to = elementById.get(toId);
+        if (to && to['notation'] !== 'location') {
+          findings.push({
+            scope: PScope,
+            id: relId,
+            message:
+              `Layer-semantics: '${relId}' type 'unit_located_at' requires to to be a LOCATION; ` +
+              `got notation='${to['notation']}'.`,
+          });
+        }
+      }
+    } else if (relType === 'located_at') {
+      if (fromId) {
+        const from = elementById.get(fromId);
+        if (
+          from &&
+          (from['notation'] !== 'actor' ||
+            (from['type'] !== 'person' && from['type'] !== 'business_unit'))
+        ) {
+          findings.push({
+            scope: PScope,
+            id: relId,
+            message:
+              `Layer-semantics: '${relId}' type 'located_at' requires from to be ` +
+              `ACTOR(person|business_unit); got notation='${from['notation']}', type='${from['type']}'.`,
+          });
+        }
+      }
+      if (toId) {
+        const to = elementById.get(toId);
+        if (to && to['notation'] !== 'location') {
+          findings.push({
+            scope: PScope,
+            id: relId,
+            message:
+              `Layer-semantics: '${relId}' type 'located_at' requires to to be a LOCATION; ` +
+              `got notation='${to['notation']}'.`,
+          });
+        }
+      }
+    } else if (relType === 'offers') {
+      if (fromId) {
+        const from = elementById.get(fromId);
+        if (
+          from &&
+          from['notation'] !== 'actor' &&
+          from['notation'] !== 'role'
+        ) {
+          findings.push({
+            scope: PScope,
+            id: relId,
+            message:
+              `Layer-semantics: '${relId}' type 'offers' requires from to be ` +
+              `ACTOR(business_unit) or ROLE; got notation='${from['notation']}'.`,
+          });
+        }
+      }
+      if (toId) {
+        const to = elementById.get(toId);
+        if (to && to['notation'] !== 'business-service') {
+          findings.push({
+            scope: PScope,
+            id: relId,
+            message:
+              `Layer-semantics: '${relId}' type 'offers' requires to to be a BUSINESS_SERVICE; ` +
+              `got notation='${to['notation']}'.`,
+          });
+        }
+      }
+    } else if (relType === 'realizes') {
+      if (fromId) {
+        const from = elementById.get(fromId);
+        if (from && from['notation'] !== 'business-service') {
+          findings.push({
+            scope: PScope,
+            id: relId,
+            message:
+              `Layer-semantics: '${relId}' type 'realizes' requires from to be ` +
+              `BUSINESS_SERVICE; got notation='${from['notation']}'.`,
+          });
+        }
+      }
+    } else if (relType === 'hosts') {
+      if (fromId) {
+        const from = elementById.get(fromId);
+        if (from && from['notation'] !== 'node') {
+          findings.push({
+            scope: PScope,
+            id: relId,
+            message:
+              `Layer-semantics: '${relId}' type 'hosts' requires from to be a NODE; ` +
+              `got notation='${from['notation']}'.`,
+          });
+        }
+      }
+      if (toId) {
+        const to = elementById.get(toId);
+        if (to && to['notation'] !== 'technology-service') {
+          findings.push({
+            scope: PScope,
+            id: relId,
+            message:
+              `Layer-semantics: '${relId}' type 'hosts' requires to to be a TECHNOLOGY_SERVICE; ` +
+              `got notation='${to['notation']}'.`,
+          });
+        }
+      }
+    } else if (relType === 'uses') {
+      if (fromId) {
+        const from = elementById.get(fromId);
+        if (from && from['notation'] !== 'application') {
+          findings.push({
+            scope: PScope,
+            id: relId,
+            message:
+              `Layer-semantics: '${relId}' type 'uses' requires from to be an APPLICATION; ` +
+              `got notation='${from['notation']}'.`,
+          });
+        }
+      }
+      if (toId) {
+        const to = elementById.get(toId);
+        if (to && to['notation'] !== 'technology-service') {
+          findings.push({
+            scope: PScope,
+            id: relId,
+            message:
+              `Layer-semantics: '${relId}' type 'uses' requires to to be a TECHNOLOGY_SERVICE; ` +
+              `got notation='${to['notation']}'.`,
+          });
+        }
+      }
+    }
+  }
+
+  // TSVC-003 — TECHNOLOGY_SERVICE.node must resolve to a NODE-notation element.
+  for (const doc of input.elements) {
+    if (!doc.data) continue;
+    if (doc.data['notation'] !== 'technology-service') continue;
+    const nodeRef = doc.data['node'];
+    if (typeof nodeRef !== 'string' || nodeRef.trim() === '') continue;
+
+    const svcId = docId(doc) ?? '';
+    const resolved = elementById.get(nodeRef);
+    if (resolved && resolved['notation'] !== 'node') {
+      findings.push({
+        scope: PScope,
+        id: svcId,
+        message:
+          `TSVC-003: TECHNOLOGY_SERVICE '${svcId}' node '${nodeRef}' ` +
+          `must resolve to a NODE element; got notation='${resolved['notation']}'.`,
+      });
+    }
+  }
+
+  // INT-002 — INTEGRATION elements with interface_semantics: true must have
+  // source and target that resolve to APPLICATION-notation elements.
+  for (const doc of input.elements) {
+    if (!doc.data) continue;
+    if (doc.data['notation'] !== 'integration') continue;
+    if (doc.data['interface_semantics'] !== true) continue;
+
+    const intId = docId(doc) ?? '';
+    for (const field of ['source', 'target'] as const) {
+      const endpointId = doc.data[field];
+      if (typeof endpointId !== 'string' || endpointId.trim() === '') continue;
+      const resolved = elementById.get(endpointId);
+      if (resolved && resolved['notation'] !== 'application') {
+        findings.push({
+          scope: PScope,
+          id: intId,
+          message:
+            `INT-002: INTEGRATION '${intId}' interface_semantics endpoint '${endpointId}' ` +
+            `(${field}) must resolve to an APPLICATION element; got notation='${resolved['notation']}'.`,
+        });
+      }
+    }
+  }
 }
 
 /** Phase 6 — an element that is Active/Production must declare an owner. */

package/src/technology-service/__tests__/validate.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect } from 'vitest';
+import { validateTechnologyService } from '../validate.js';
+
+function valid(): Record<string, unknown> {
+  return {
+    notation: 'technology-service',
+    id: 'TECHNOLOGY_SERVICE-KAFKA-1',
+    name: 'Kafka Event Bus',
+    type: 'messaging',
+    description: 'Managed Kafka cluster for async event streaming.',
+    node: 'NODE-KAFKA-HOST-1',
+    endpoint: 'kafka.internal:9092',
+    zone: 'canon',
+    admitted_at: '2026-06-28',
+    admitted_by: 'v.korobeinikov',
+    gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
+    valid_from: '2024-01-01',
+    valid_to: null,
+  };
+}
+
+const codes = (input: unknown): string[] =>
+  validateTechnologyService(input).errors.map(e => e.code);
+
+describe('validateTechnologyService — positive', () => {
+  it('accepts a well-formed messaging service with all optional fields', () => {
+    const r = validateTechnologyService(valid());
+    expect(r.valid, JSON.stringify(r.errors)).toBe(true);
+  });
+
+  it('accepts a storage service with no optional fields', () => {
+    const a = valid();
+    a.id = 'TECHNOLOGY_SERVICE-S3-1';
+    a.name = 'Object Storage';
+    a.type = 'storage';
+    delete a.description;
+    delete a.node;
+    delete a.endpoint;
+    expect(validateTechnologyService(a).valid).toBe(true);
+  });
+
+  it('accepts all five type values', () => {
+    for (const t of ['messaging', 'storage', 'api_gateway', 'database', 'compute']) {
+      expect(validateTechnologyService({ ...valid(), type: t }).valid).toBe(true);
+    }
+  });
+
+  it('accepts valid_to as a date string', () => {
+    expect(validateTechnologyService({ ...valid(), valid_to: '2026-12-31' }).valid).toBe(true);
+  });
+
+  it('accepts absent node without error', () => {
+    const a = valid();
+    delete a.node;
+    expect(validateTechnologyService(a).valid).toBe(true);
+  });
+});
+
+describe('validateTechnologyService — TSVC-001 (shape / id grammar)', () => {
+  it('flags a non-object input', () => {
+    expect(codes(null)).toEqual(['TSVC-001']);
+  });
+
+  it('flags an id that violates the grammar', () => {
+    expect(codes({ ...valid(), id: 'TECHNOLOGY_SERVICE-001' })).toContain('TSVC-001');
+    expect(codes({ ...valid(), id: 'TSVC-1' })).toContain('TSVC-001');
+    expect(codes({ ...valid(), id: 'technology-service-kafka-1' })).toContain('TSVC-001');
+  });
+
+  it('flags a wrong notation tag', () => {
+    expect(codes({ ...valid(), notation: 'technology_service' })).toContain('TSVC-001');
+    expect(codes({ ...valid(), notation: 'service' })).toContain('TSVC-001');
+  });
+
+  it('flags a non-canon zone', () => {
+    expect(codes({ ...valid(), zone: 'sandbox' })).toContain('TSVC-001');
+  });
+
+  it('flags a missing zone', () => {
+    const a = valid();
+    delete a.zone;
+    expect(codes(a)).toContain('TSVC-001');
+  });
+
+  it('flags a missing name', () => {
+    const a = valid();
+    delete a.name;
+    expect(codes(a)).toContain('TSVC-001');
+  });
+
+  it('flags a missing valid_to key', () => {
+    const a = valid();
+    delete a.valid_to;
+    expect(codes(a)).toContain('TSVC-001');
+  });
+
+  it('flags missing gate_checks', () => {
+    const a = valid();
+    delete a.gate_checks;
+    expect(codes(a)).toContain('TSVC-001');
+  });
+
+  it('flags a missing type', () => {
+    const a = valid();
+    delete a.type;
+    expect(codes(a)).toContain('TSVC-001');
+  });
+});
+
+describe('validateTechnologyService — TSVC-002 (type enum)', () => {
+  it('flags a type outside the allowed enum', () => {
+    expect(codes({ ...valid(), type: 'queue' })).toContain('TSVC-002');
+    expect(codes({ ...valid(), type: 'event_streaming' })).toContain('TSVC-002');
+    expect(codes({ ...valid(), type: 'cache' })).toContain('TSVC-002');
+  });
+
+  it('does not flag a missing type with TSVC-002 (TSVC-001 fires instead)', () => {
+    const a = valid();
+    delete a.type;
+    expect(codes(a)).not.toContain('TSVC-002');
+    expect(codes(a)).toContain('TSVC-001');
+  });
+});
+
+describe('validateTechnologyService — TSVC-003 (node grammar)', () => {
+  it('flags a node reference that is not a NODE-… id', () => {
+    expect(codes({ ...valid(), node: 'ACTOR-OPS-1' })).toContain('TSVC-003');
+    expect(codes({ ...valid(), node: 'not-an-id' })).toContain('TSVC-003');
+    expect(codes({ ...valid(), node: 'NODE-001' })).toContain('TSVC-003');
+  });
+
+  it('accepts a null or absent node without error', () => {
+    expect(codes({ ...valid(), node: undefined })).not.toContain('TSVC-003');
+    const a = valid();
+    delete a.node;
+    expect(codes(a)).not.toContain('TSVC-003');
+  });
+
+  it('accepts a well-formed NODE-… id', () => {
+    expect(codes({ ...valid(), node: 'NODE-KAFKA-HOST-1' })).not.toContain('TSVC-003');
+    expect(codes({ ...valid(), node: 'NODE-K8S-CLUSTER-1' })).not.toContain('TSVC-003');
+  });
+});

package/src/technology-service/index.ts

@@ -0,0 +1,2 @@
+export { validateTechnologyService } from './validate.js';
+export type { TechnologyService, TechnologyServiceType } from './types.js';

package/src/technology-service/types.ts

@@ -0,0 +1,27 @@
+// TECHNOLOGY_SERVICE — technology-layer platform service primitive (ArchiMate Technology Service).
+// Schema: methodology notations/elements/26-technology-services.md
+
+import type { GateChecks } from '../requirement/types.js';
+
+export const TECHNOLOGY_SERVICE_TYPES = ['messaging', 'storage', 'api_gateway', 'database', 'compute'] as const;
+export type TechnologyServiceType = typeof TECHNOLOGY_SERVICE_TYPES[number];
+
+export interface TechnologyService {
+  notation: 'technology-service';
+  id: string;
+  name: string;
+  type: TechnologyServiceType;
+  description?: string;
+  node?: string;
+  endpoint?: string;
+
+  // Admission record (CONTRACT.md §6).
+  zone: 'canon';
+  admitted_at: string;
+  admitted_by: string;
+  gate_checks: GateChecks;
+
+  // Primitive lifecycle (CONTRACT.md §7).
+  valid_from: string;
+  valid_to: string | null;
+}

package/src/technology-service/validate.ts

@@ -0,0 +1,71 @@
+// TECHNOLOGY_SERVICE validator — methodology notations/elements/26-technology-services.md §5.
+//
+// Implements TSVC-001, TSVC-002, TSVC-003. The shared HDR-/LIFECYCLE- rules are
+// cross-cutting concerns (CONTRACT.md §8) and out of scope for the
+// single-artefact validator. TSVC-003 (node resolves to admitted NODE) is also
+// enforced at repo scope in validate-repo.ts checkLayerSemantics.
+
+import type { ValidationError, ValidationWarning, ValidationResult } from '../validation-types.js';
+import { isCanonicalIdOfType } from '../typed-id.js';
+import { TECHNOLOGY_SERVICE_TYPES } from './types.js';
+
+const REQUIRED_STRING_FIELDS = [
+  'name', 'admitted_at', 'admitted_by', 'valid_from',
+] as const;
+
+const TYPES: readonly string[] = TECHNOLOGY_SERVICE_TYPES;
+
+export function validateTechnologyService(input: unknown): ValidationResult {
+  const errors: ValidationError[] = [];
+  const warnings: ValidationWarning[] = [];
+
+  if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+    errors.push({ code: 'TSVC-001', message: 'Technology service must be a YAML mapping.' });
+    return { valid: false, errors, warnings };
+  }
+  const a = input as Record<string, unknown>;
+
+  // TSVC-001 — id grammar + notation tag + envelope.
+  if (!isCanonicalIdOfType(a.id, 'TECHNOLOGY_SERVICE')) {
+    errors.push({ code: 'TSVC-001', message: `id "${String(a.id)}" must match TECHNOLOGY_SERVICE-[<middle>-]<INTEGER>.`, path: 'id' });
+  }
+  if (a.notation !== 'technology-service') {
+    errors.push({ code: 'TSVC-001', message: 'notation must be the fixed value "technology-service".', path: 'notation' });
+  }
+  if (a.zone !== undefined && a.zone !== 'canon') {
+    errors.push({ code: 'TSVC-001', message: 'zone must be "canon" for a TECHNOLOGY_SERVICE.', path: 'zone' });
+  } else if (a.zone === undefined) {
+    errors.push({ code: 'TSVC-001', message: 'zone is required.', path: 'zone' });
+  }
+  for (const field of REQUIRED_STRING_FIELDS) {
+    const v = a[field];
+    if (typeof v !== 'string' || v.trim() === '') {
+      errors.push({ code: 'TSVC-001', message: `${field} is required.`, path: field });
+    }
+  }
+  if (a.gate_checks === null || typeof a.gate_checks !== 'object') {
+    errors.push({ code: 'TSVC-001', message: 'gate_checks is required and must be a mapping.', path: 'gate_checks' });
+  }
+  if (!('valid_to' in a) || !(typeof a.valid_to === 'string' || a.valid_to === null)) {
+    errors.push({ code: 'TSVC-001', message: 'valid_to is required (an ISO date string or null).', path: 'valid_to' });
+  }
+  if (typeof a.type !== 'string' || a.type.trim() === '') {
+    errors.push({ code: 'TSVC-001', message: 'type is required.', path: 'type' });
+  } else if (!TYPES.includes(a.type)) {
+    // TSVC-002 — type enum.
+    errors.push({ code: 'TSVC-002', message: `type "${a.type}" must be one of ${TYPES.join(', ')}.`, path: 'type' });
+  }
+
+  // TSVC-003 — node must be a NODE-… id when present.
+  if ('node' in a && a.node !== undefined && a.node !== null) {
+    if (typeof a.node !== 'string' || !isCanonicalIdOfType(a.node, 'NODE')) {
+      errors.push({
+        code: 'TSVC-003',
+        message: `node "${String(a.node)}" must be a canonical NODE-… id.`,
+        path: 'node',
+      });
+    }
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}

package/src/webview/__tests__/entry-notations.test.ts

@@ -28,10 +28,8 @@ const FIXTURES: Fixture[] = [
   { kind: 'goals', file: 'goals/strategy-2026.goals.transitrix.yaml', markup: 'svg' },
   { kind: 'dgca', file: 'dgca/strategy-2026.dgca.transitrix.yaml', markup: 'svg' },
   { kind: 'dga', file: 'dga/strategy-2026.dga.transitrix.yaml', markup: 'svg' },
-  { kind: 'fgca', file: 'fgca/strategy-2026.fgca.transitrix.yaml', markup: 'svg' },
-  { kind: 'fga', file: 'fga/strategy-2026.fga.transitrix.yaml', markup: 'svg' },
-  { kind: 'activities', file: 'activities/platform-launch.activities.transitrix.yaml', markup: 'svg' },
-  { kind: 'activity-card', file: 'activity-card/eu-programme.activity-card.transitrix.yaml', markup: 'svg' },
+  { kind: 'action', file: 'action/platform-launch.action.transitrix.yaml', markup: 'svg' },
+  { kind: 'action-card', file: 'action-card/eu-programme.action-card.transitrix.yaml', markup: 'svg' },
   { kind: 'process-blueprint', file: 'process-blueprint/order-fulfilment.process-blueprint.transitrix.yaml', markup: 'svg' },
   { kind: 'blocks', file: 'blocks/architecture.blocks.transitrix.yaml', markup: 'svg' },
   { kind: 'applications', file: 'applications/portfolio-2026.applications.transitrix.yaml', markup: 'section' },

package/src/webview/__tests__/render-activities.test.ts

@@ -0,0 +1,100 @@
+/**
+ * Unit tests for renderActivitiesSvg — project-node suppression (#421).
+ *
+ * Convention: activities with activity_type === 'project' are omitted from
+ * the Network/PSND layout by default (suppressProjectNodes: true). Text/Tree
+ * views keep them via the caller; data is never mutated.
+ */
+import { describe, it, expect } from 'vitest';
+import { renderActivitiesSvg } from '../render-activities.js';
+import type { ActivityDoc } from '../../activities/types.js';
+
+const BASE_DOC: ActivityDoc = {
+  notation: 'action',
+  activities: [
+    {
+      id: 'PROJ-1',
+      name: 'Platform Launch',
+      activity_type: 'project',
+    },
+    {
+      id: 'TASK-1',
+      name: 'Design',
+      activity_type: 'task',
+      parent: 'PROJ-1',
+    },
+    {
+      id: 'TASK-2',
+      name: 'Implement',
+      activity_type: 'task',
+      parent: 'PROJ-1',
+      predecessors: ['TASK-1'],
+    },
+  ],
+};
+
+describe('renderActivitiesSvg — project-node suppression (#421)', () => {
+  it('suppresses project-type nodes in the network SVG by default', () => {
+    const svg = renderActivitiesSvg(BASE_DOC);
+    // TASK-1 and TASK-2 should appear as rendered nodes.
+    expect(svg).toContain('TASK-1');
+    expect(svg).toContain('TASK-2');
+    // The project container should not appear as a rendered node.
+    expect(svg).not.toContain('PROJ-1');
+  });
+
+  it('suppresses project nodes when suppressProjectNodes is explicitly true', () => {
+    const svg = renderActivitiesSvg(BASE_DOC, { suppressProjectNodes: true });
+    expect(svg).not.toContain('PROJ-1');
+    expect(svg).toContain('TASK-1');
+  });
+
+  it('renders project nodes when suppressProjectNodes is false', () => {
+    const svg = renderActivitiesSvg(BASE_DOC, { suppressProjectNodes: false });
+    expect(svg).toContain('PROJ-1');
+    expect(svg).toContain('TASK-1');
+    expect(svg).toContain('TASK-2');
+  });
+
+  it('does not mutate the original doc', () => {
+    const original = BASE_DOC.activities.length;
+    renderActivitiesSvg(BASE_DOC);
+    expect(BASE_DOC.activities).toHaveLength(original);
+  });
+
+  it('suppresses project_type matching case-insensitively', () => {
+    const doc: ActivityDoc = {
+      notation: 'action',
+      activities: [
+        { id: 'P1', name: 'Container', activity_type: 'Project' },
+        { id: 'T1', name: 'Leaf', activity_type: 'task' },
+      ],
+    };
+    const svg = renderActivitiesSvg(doc);
+    expect(svg).not.toContain('P1');
+    expect(svg).toContain('T1');
+  });
+
+  it('renders a valid SVG when all activities are project-type (graceful degrade)', () => {
+    const doc: ActivityDoc = {
+      notation: 'action',
+      activities: [{ id: 'P1', name: 'Only project', activity_type: 'project' }],
+    };
+    const svg = renderActivitiesSvg(doc);
+    // When all activities are filtered out, the renderer returns an empty SVG.
+    expect(svg).toContain('<svg');
+  });
+
+  it('renders activities without activity_type unchanged', () => {
+    const doc: ActivityDoc = {
+      notation: 'action',
+      activities: [
+        { id: 'A1', name: 'Analysis', duration: 5 },
+        { id: 'A2', name: 'Design', duration: 3, predecessors: ['A1'] },
+      ],
+    };
+    const svg = renderActivitiesSvg(doc);
+    expect(svg).toContain('A1');
+    expect(svg).toContain('A2');
+  });
+});