@transitrix/diagrams 1.3.0 → 1.5.0

package/dist/repo-validate/validate-repo.js

@@ -134,17 +134,231 @@ function checkReferentialIntegrity(input, findings) {
         }
     }
 }
-/** 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, _findings) {
-    // 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, findings) {
+    const elementById = new Map();
+    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']) {
+            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. */
 function checkPolicy(input, findings) {

package/dist/technology-service/__tests__/validate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/technology-service/__tests__/validate.test.js

@@ -0,0 +1,121 @@
+import { describe, it, expect } from 'vitest';
+import { validateTechnologyService } from '../validate.js';
+function valid() {
+    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) => 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/dist/technology-service/index.d.ts

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

package/dist/technology-service/index.js

@@ -0,0 +1 @@
+export { validateTechnologyService } from './validate.js';

package/dist/technology-service/types.d.ts

@@ -0,0 +1,18 @@
+import type { GateChecks } from '../requirement/types.js';
+export declare const TECHNOLOGY_SERVICE_TYPES: readonly ["messaging", "storage", "api_gateway", "database", "compute"];
+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;
+    zone: 'canon';
+    admitted_at: string;
+    admitted_by: string;
+    gate_checks: GateChecks;
+    valid_from: string;
+    valid_to: string | null;
+}

package/dist/technology-service/types.js

@@ -0,0 +1,3 @@
+// TECHNOLOGY_SERVICE — technology-layer platform service primitive (ArchiMate Technology Service).
+// Schema: methodology notations/elements/26-technology-services.md
+export const TECHNOLOGY_SERVICE_TYPES = ['messaging', 'storage', 'api_gateway', 'database', 'compute'];

package/dist/technology-service/validate.d.ts

@@ -0,0 +1,2 @@
+import type { ValidationResult } from '../validation-types.js';
+export declare function validateTechnologyService(input: unknown): ValidationResult;

package/dist/technology-service/validate.js

@@ -0,0 +1,64 @@
+// 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 { isCanonicalIdOfType } from '../typed-id.js';
+import { TECHNOLOGY_SERVICE_TYPES } from './types.js';
+const REQUIRED_STRING_FIELDS = [
+    'name', 'admitted_at', 'admitted_by', 'valid_from',
+];
+const TYPES = TECHNOLOGY_SERVICE_TYPES;
+export function validateTechnologyService(input) {
+    const errors = [];
+    const warnings = [];
+    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;
+    // 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/dist/webview/__tests__/entry-notations.test.js

@@ -17,10 +17,8 @@ const FIXTURES = [
     { 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/dist/webview/__tests__/render-activities.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webview/__tests__/render-activities.test.js

@@ -0,0 +1,91 @@
+/**
+ * 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';
+const BASE_DOC = {
+    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 = {
+            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 = {
+            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 = {
+            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');
+    });
+});

package/dist/webview/__tests__/render-blocks.test.d.ts

@@ -0,0 +1 @@
+export {};