@transitrix/diagrams 1.3.0 → 1.5.0

package/dist/activity-card/validate.js

@@ -40,21 +40,14 @@ export function validateActivityCard(input) {
     if (!('notation' in raw)) {
         errors.push({ code: 'HDR-001', message: 'notation field is required' });
     }
-    else if (raw['notation'] !== 'action-card' && raw['notation'] !== 'activity-card') {
+    else if (raw['notation'] !== 'action-card') {
         errors.push({
             code: 'HDR-002',
             message: `notation must be "action-card", got "${String(raw['notation'])}"`,
         });
     }
-    else if (raw['notation'] === 'activity-card') {
-        warnings.push({ code: 'DEPRECATED_NOTATION', message: 'notation: "activity-card" is deprecated — migrate to notation: "action-card"' });
-    }
-    // ── action_card / activity_card block ───────────────────────────────────────
-    // "action_card:" is canonical; "activity_card:" is accepted for compat.
-    const rawBlock = raw['action_card'] ?? raw['activity_card'];
-    if (raw['activity_card'] !== undefined && raw['action_card'] === undefined) {
-        warnings.push({ code: 'DEPRECATED_FIELD', message: 'Root key "activity_card:" is deprecated — rename to "action_card:"' });
-    }
+    // ── action_card block ────────────────────────────────────────────────────────
+    const rawBlock = raw['action_card'];
     const block = rawBlock;
     if (!block || typeof block !== 'object' || Array.isArray(block)) {
         errors.push({ code: 'AC-001', message: 'Missing required root key: action_card (object)' });

package/dist/actor/__tests__/validate.test.js

@@ -86,4 +86,10 @@ describe('validateActor — ACTOR-003 (engagement fields forbidden inline)', ()
     it('flags inline owner', () => {
         expect(codes({ ...valid(), owner: 'ACTOR-OPS-1' })).toContain('ACTOR-003');
     });
+    it('flags inline located_at (location belongs in a REL file)', () => {
+        expect(codes({ ...valid(), located_at: 'LOCATION-TBILISI-1' })).toContain('ACTOR-003');
+    });
+    it('flags inline unit_located_at (location belongs in a REL file)', () => {
+        expect(codes({ ...valid(), unit_located_at: 'LOCATION-TBILISI-1' })).toContain('ACTOR-003');
+    });
 });

package/dist/actor/types.d.ts

@@ -6,7 +6,7 @@ export type ActorType = typeof ACTOR_TYPES[number];
  * inline on an ACTOR file (§7.10, ACTOR-003). They belong in time-aware REL
  * records, never on the identity primitive.
  */
-export declare const ACTOR_FORBIDDEN_INLINE_FIELDS: readonly ["employment", "candidacy", "alumni_membership", "community_membership", "contracting", "unit_parent", "roles", "owner"];
+export declare const ACTOR_FORBIDDEN_INLINE_FIELDS: readonly ["employment", "candidacy", "alumni_membership", "community_membership", "contracting", "unit_parent", "located_at", "unit_located_at", "roles", "owner"];
 export interface Actor {
     notation: 'actor';
     id: string;

package/dist/actor/types.js

@@ -13,6 +13,8 @@ export const ACTOR_FORBIDDEN_INLINE_FIELDS = [
     'community_membership',
     'contracting',
     'unit_parent',
+    'located_at',
+    'unit_located_at',
     'roles',
     'owner',
 ];

package/dist/applications/types.d.ts

@@ -1,11 +1,18 @@
 export type ApplicationType = 'application' | 'integration' | 'platform' | 'data_store';
 export type ApplicationStatus = 'Draft' | 'Active' | 'Deprecated' | 'Decommissioning';
 export type IntegrationDirection = 'inbound' | 'outbound' | 'bidirectional';
+export type IntegrationSensitivity = 'public' | 'internal' | 'confidential' | 'restricted';
+export type IntegrationDirectionality = 'producer' | 'consumer' | 'request_reply' | 'bidirectional_stream';
 export interface ApplicationIntegration {
     target?: string;
+    source?: string;
     direction?: IntegrationDirection;
     protocol?: string;
     description?: string;
+    interface_semantics?: boolean;
+    payload_class?: string;
+    sensitivity?: IntegrationSensitivity;
+    directionality?: IntegrationDirectionality;
 }
 export interface Application {
     app_id: string;

package/dist/applications/validate.js

@@ -1,7 +1,10 @@
 const VALID_TYPES = new Set(['application', 'integration', 'platform', 'data_store']);
 const VALID_STATUSES = new Set(['Draft', 'Active', 'Deprecated', 'Decommissioning']);
 const VALID_DIRECTIONS = new Set(['inbound', 'outbound', 'bidirectional']);
+const VALID_SENSITIVITY = new Set(['public', 'internal', 'confidential', 'restricted']);
+const VALID_DIRECTIONALITY = new Set(['producer', 'consumer', 'request_reply', 'bidirectional_stream']);
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const IFACE_CONDITIONAL = ['protocol', 'payload_class', 'sensitivity', 'directionality'];
 export function validateApplicationsCatalogue(input) {
     const errors = [];
     const warnings = [];
@@ -102,6 +105,21 @@ export function validateApplicationsCatalogue(input) {
                 if (intg['direction'] !== undefined && !VALID_DIRECTIONS.has(intg['direction'])) {
                     errors.push({ code: 'APP-009', message: `${idx}.integrations[${j}]: direction "${intg['direction']}" must be one of: inbound, outbound, bidirectional` });
                 }
+                // INT-001 — when interface_semantics: true, four fields become required.
+                if (intg['interface_semantics'] === true) {
+                    for (const field of IFACE_CONDITIONAL) {
+                        const v = intg[field];
+                        if (typeof v !== 'string' || v.trim() === '') {
+                            errors.push({ code: 'INT-001', message: `${idx}.integrations[${j}]: ${field} is required when interface_semantics is true.`, path: `${idx}.integrations[${j}].${field}` });
+                        }
+                    }
+                    if (typeof intg['sensitivity'] === 'string' && !VALID_SENSITIVITY.has(intg['sensitivity'])) {
+                        errors.push({ code: 'INT-001', message: `${idx}.integrations[${j}]: sensitivity "${intg['sensitivity']}" must be one of public, internal, confidential, restricted.`, path: `${idx}.integrations[${j}].sensitivity` });
+                    }
+                    if (typeof intg['directionality'] === 'string' && !VALID_DIRECTIONALITY.has(intg['directionality'])) {
+                        errors.push({ code: 'INT-001', message: `${idx}.integrations[${j}]: directionality "${intg['directionality']}" must be one of producer, consumer, request_reply, bidirectional_stream.`, path: `${idx}.integrations[${j}].directionality` });
+                    }
+                }
             }
         }
     }

package/dist/blocks/__tests__/layout.test.js

@@ -109,7 +109,7 @@ describe('layoutNestedBlocks', () => {
         });
         const a = layout.blocks[0];
         expect(a.width).toBe(160);
-        expect(a.height).toBe(60);
+        expect(a.height).toBe(72);
     });
     it('honours custom layout options', () => {
         const layout = layoutNestedBlocks({

package/dist/blocks/layout.js

@@ -1,6 +1,6 @@
 const DEFAULTS = {
     leafWidth: 160,
-    leafHeight: 60,
+    leafHeight: 72,
     padding: 12,
     headerHeight: 28,
     childGap: 12,

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

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

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

@@ -0,0 +1,135 @@
+import { describe, it, expect } from 'vitest';
+import { validateBusinessService } from '../validate.js';
+function valid() {
+    return {
+        notation: 'business-service',
+        id: 'BUSINESS_SERVICE-CRM-1',
+        name: 'CRM Service',
+        type: 'internal',
+        description: 'Customer relationship management service offering contact management and deal tracking.',
+        offering_unit: 'ACTOR-SALES-OPS-1',
+        capability: 'CAPABILITY-V2.1',
+        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) => validateBusinessService(input).errors.map(e => e.code);
+describe('validateBusinessService — positive', () => {
+    it('accepts a well-formed internal service with all optional fields', () => {
+        const r = validateBusinessService(valid());
+        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
+    });
+    it('accepts an external service with no optional fields', () => {
+        const a = valid();
+        a.id = 'BUSINESS_SERVICE-ONBOARDING-1';
+        a.name = 'Onboarding Service';
+        a.type = 'external';
+        delete a.description;
+        delete a.offering_unit;
+        delete a.capability;
+        expect(validateBusinessService(a).valid).toBe(true);
+    });
+    it('accepts a shared service offered by a ROLE', () => {
+        expect(validateBusinessService({ ...valid(), type: 'shared', offering_unit: 'ROLE-PLATFORM-OWNER-1' }).valid).toBe(true);
+    });
+    it('accepts valid_to as a date string', () => {
+        expect(validateBusinessService({ ...valid(), valid_to: '2026-12-31' }).valid).toBe(true);
+    });
+    it('accepts a service with no offering_unit or capability', () => {
+        const a = valid();
+        delete a.offering_unit;
+        delete a.capability;
+        expect(validateBusinessService(a).valid).toBe(true);
+    });
+});
+describe('validateBusinessService — BSV-001 (shape / id grammar)', () => {
+    it('flags a missing required envelope field (name)', () => {
+        const a = valid();
+        delete a.name;
+        expect(codes(a)).toContain('BSV-001');
+    });
+    it('flags an id that violates the grammar', () => {
+        expect(codes({ ...valid(), id: 'BUSINESS_SERVICE-001' })).toContain('BSV-001');
+        expect(codes({ ...valid(), id: 'BSV-1' })).toContain('BSV-001');
+        expect(codes({ ...valid(), id: 'business-service-1' })).toContain('BSV-001');
+    });
+    it('flags a wrong notation tag', () => {
+        expect(codes({ ...valid(), notation: 'service' })).toContain('BSV-001');
+        expect(codes({ ...valid(), notation: 'business_service' })).toContain('BSV-001');
+    });
+    it('flags a non-canon zone', () => {
+        expect(codes({ ...valid(), zone: 'sandbox' })).toContain('BSV-001');
+    });
+    it('flags a missing zone', () => {
+        const a = valid();
+        delete a.zone;
+        expect(codes(a)).toContain('BSV-001');
+    });
+    it('flags a missing type', () => {
+        const a = valid();
+        delete a.type;
+        expect(codes(a)).toContain('BSV-001');
+    });
+    it('flags a missing valid_to key', () => {
+        const a = valid();
+        delete a.valid_to;
+        expect(codes(a)).toContain('BSV-001');
+    });
+    it('flags missing gate_checks', () => {
+        const a = valid();
+        delete a.gate_checks;
+        expect(codes(a)).toContain('BSV-001');
+    });
+    it('rejects a non-object', () => {
+        expect(codes(null)).toEqual(['BSV-001']);
+        expect(codes('string')).toEqual(['BSV-001']);
+    });
+});
+describe('validateBusinessService — BSV-002 (type enum)', () => {
+    it('flags a type outside the allowed enum', () => {
+        expect(codes({ ...valid(), type: 'public' })).toContain('BSV-002');
+        expect(codes({ ...valid(), type: 'platform' })).toContain('BSV-002');
+    });
+    it('accepts all valid type values', () => {
+        for (const t of ['internal', 'external', 'shared']) {
+            expect(codes({ ...valid(), type: t })).not.toContain('BSV-002');
+        }
+    });
+});
+describe('validateBusinessService — BSV-003 (offering_unit grammar)', () => {
+    it('flags an offering_unit that is not an ACTOR-… or ROLE-… id', () => {
+        expect(codes({ ...valid(), offering_unit: 'PRODUCT-PLATFORM-1' })).toContain('BSV-003');
+        expect(codes({ ...valid(), offering_unit: 'not-an-id' })).toContain('BSV-003');
+        expect(codes({ ...valid(), offering_unit: 'BUSINESS_SERVICE-CRM-1' })).toContain('BSV-003');
+    });
+    it('accepts a null or absent offering_unit without error', () => {
+        expect(codes({ ...valid(), offering_unit: undefined })).not.toContain('BSV-003');
+        const a = valid();
+        delete a.offering_unit;
+        expect(codes(a)).not.toContain('BSV-003');
+    });
+    it('accepts ACTOR-… and ROLE-… ids', () => {
+        expect(codes({ ...valid(), offering_unit: 'ACTOR-OPS-1' })).not.toContain('BSV-003');
+        expect(codes({ ...valid(), offering_unit: 'ROLE-SERVICE-OWNER-1' })).not.toContain('BSV-003');
+    });
+});
+describe('validateBusinessService — BSV-004 (capability grammar)', () => {
+    it('flags a capability that is not a CAPABILITY-… id', () => {
+        expect(codes({ ...valid(), capability: 'PRODUCT-MOBILE-1' })).toContain('BSV-004');
+        expect(codes({ ...valid(), capability: 'not-a-capability' })).toContain('BSV-004');
+    });
+    it('accepts a null or absent capability without error', () => {
+        expect(codes({ ...valid(), capability: undefined })).not.toContain('BSV-004');
+        const a = valid();
+        delete a.capability;
+        expect(codes(a)).not.toContain('BSV-004');
+    });
+    it('accepts a CAPABILITY-… id', () => {
+        expect(codes({ ...valid(), capability: 'CAPABILITY-V2.1' })).not.toContain('BSV-004');
+        expect(codes({ ...valid(), capability: 'CAPABILITY-H3.1' })).not.toContain('BSV-004');
+    });
+});

package/dist/business-service/index.d.ts

@@ -0,0 +1,3 @@
+export type { BusinessService, BusinessServiceType } from './types.js';
+export { BUSINESS_SERVICE_TYPES } from './types.js';
+export { validateBusinessService } from './validate.js';

package/dist/business-service/index.js

@@ -0,0 +1,2 @@
+export { BUSINESS_SERVICE_TYPES } from './types.js';
+export { validateBusinessService } from './validate.js';

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

@@ -0,0 +1,20 @@
+import type { GateChecks } from '../requirement/types.js';
+export declare const BUSINESS_SERVICE_TYPES: readonly ["internal", "external", "shared"];
+export type BusinessServiceType = typeof BUSINESS_SERVICE_TYPES[number];
+export interface BusinessService {
+    notation: 'business-service';
+    id: string;
+    name: string;
+    type: BusinessServiceType;
+    description?: string;
+    offering_unit?: string;
+    capability?: string;
+    owner_role?: string;
+    status?: string;
+    zone: 'canon';
+    admitted_at: string;
+    admitted_by: string;
+    gate_checks: GateChecks;
+    valid_from: string;
+    valid_to: string | null;
+}

package/dist/business-service/types.js

@@ -0,0 +1,3 @@
+// BUSINESS_SERVICE — externally visible behaviour primitive (ArchiMate Business Service).
+// Schema: methodology notations/elements/25-business-services.md
+export const BUSINESS_SERVICE_TYPES = ['internal', 'external', 'shared'];

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

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

package/dist/business-service/validate.js

@@ -0,0 +1,74 @@
+// BUSINESS_SERVICE validator — methodology notations/elements/25-business-services.md §5.
+//
+// Implements BSV-001..004. The shared HDR-/LIFECYCLE- rules are
+// cross-cutting concerns (CONTRACT.md §8) and out of scope for the
+// single-artefact validator.
+import { isCanonicalIdOfType, typeOfId } from '../typed-id.js';
+import { BUSINESS_SERVICE_TYPES } from './types.js';
+const REQUIRED_STRING_FIELDS = [
+    'name', 'admitted_at', 'admitted_by', 'valid_from',
+];
+const TYPES = BUSINESS_SERVICE_TYPES;
+export function validateBusinessService(input) {
+    const errors = [];
+    const warnings = [];
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        errors.push({ code: 'BSV-001', message: 'Business service must be a YAML mapping.' });
+        return { valid: false, errors, warnings };
+    }
+    const a = input;
+    // BSV-001 — id grammar + notation tag + envelope.
+    if (!isCanonicalIdOfType(a.id, 'BUSINESS_SERVICE')) {
+        errors.push({ code: 'BSV-001', message: `id "${String(a.id)}" must match BUSINESS_SERVICE-[<middle>-]<INTEGER>.`, path: 'id' });
+    }
+    if (a.notation !== 'business-service') {
+        errors.push({ code: 'BSV-001', message: 'notation must be the fixed value "business-service".', path: 'notation' });
+    }
+    if (a.zone !== undefined && a.zone !== 'canon') {
+        errors.push({ code: 'BSV-001', message: 'zone must be "canon" for a BUSINESS_SERVICE.', path: 'zone' });
+    }
+    else if (a.zone === undefined) {
+        errors.push({ code: 'BSV-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: 'BSV-001', message: `${field} is required.`, path: field });
+        }
+    }
+    if (a.gate_checks === null || typeof a.gate_checks !== 'object') {
+        errors.push({ code: 'BSV-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: 'BSV-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: 'BSV-001', message: 'type is required.', path: 'type' });
+    }
+    else if (!TYPES.includes(a.type)) {
+        // BSV-002 — type enum.
+        errors.push({ code: 'BSV-002', message: `type "${a.type}" must be one of ${TYPES.join(', ')}.`, path: 'type' });
+    }
+    // BSV-003 — offering_unit must resolve to ACTOR(business_unit) or ROLE when present.
+    if ('offering_unit' in a && a.offering_unit !== undefined && a.offering_unit !== null) {
+        const t = typeOfId(a.offering_unit);
+        if (t !== 'ACTOR' && t !== 'ROLE') {
+            errors.push({
+                code: 'BSV-003',
+                message: `offering_unit "${String(a.offering_unit)}" must be an ACTOR-… or ROLE-… canonical id.`,
+                path: 'offering_unit',
+            });
+        }
+    }
+    // BSV-004 — capability must resolve to CAPABILITY when present.
+    if ('capability' in a && a.capability !== undefined && a.capability !== null) {
+        if (typeOfId(a.capability) !== 'CAPABILITY') {
+            errors.push({
+                code: 'BSV-004',
+                message: `capability "${String(a.capability)}" must be a CAPABILITY-… canonical id.`,
+                path: 'capability',
+            });
+        }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}

package/dist/fgca/__tests__/parse-canonical.test.js

@@ -4,7 +4,7 @@ import * as path from 'node:path';
 import yaml from 'js-yaml';
 import { parseCanonicalFGCA, parseCanonicalFGA } from '../parse-canonical.js';
 const VALID = {
-    notation: 'fgca',
+    notation: 'dgca',
     spec_version: '0.1',
     id: 'FGCA-SAMPLE-1',
     name: 'Sample FGCA chain',
@@ -17,7 +17,7 @@ const VALID = {
     changes: [
         { id: 'CHANGE-1', name: 'Transformation', goals: ['GOAL-1'] },
     ],
-    activities: [
+    actions: [
         { id: 'ACTIVITY-1', name: 'Workstream', changes: ['CHANGE-1'] },
     ],
 };
@@ -96,7 +96,7 @@ describe('parseCanonicalFGCA', () => {
     it('FGCA-010: rejects activity.changes[] referencing undefined change', () => {
         const r = parseCanonicalFGCA({
             ...VALID,
-            activities: [{ id: 'ACTIVITY-1', name: 'A', changes: ['CHANGE-99'] }],
+            actions: [{ id: 'ACTIVITY-1', name: 'A', changes: ['CHANGE-99'] }],
         });
         expect(r.valid).toBe(false);
         expect(r.errors.some((e) => e.code === 'FGCA-010')).toBe(true);
@@ -120,7 +120,7 @@ describe('parseCanonicalFGCA', () => {
         const r = parseCanonicalFGCA({
             ...VALID,
             changes: [{ id: 'CHANGE-1', name: 'C', goals: ['GOAL-1'] }],
-            activities: [
+            actions: [
                 { id: 'ACTIVITY-1', name: 'A1', changes: ['CHANGE-1'] },
                 { id: 'ACTIVITY-2', name: 'A2', changes: ['CHANGE-1'] },
             ],
@@ -162,13 +162,13 @@ describe('parseCanonicalFGCA — edge-driving fields populated', () => {
 });
 describe('parseCanonicalFGA', () => {
     const VALID_FGA = {
-        notation: 'fga',
+        notation: 'dga',
         spec_version: '0.1',
         id: 'FGA-SAMPLE-1',
         name: 'Sample FGA chain',
         factors: [{ id: 'FACTOR-1', name: 'Driver' }],
         goals: [{ id: 'GOAL-1', name: 'Outcome', factors: ['FACTOR-1'] }],
-        activities: [{ id: 'ACTIVITY-1', name: 'Workstream', goals: ['GOAL-1'] }],
+        actions: [{ id: 'ACTIVITY-1', name: 'Workstream', goals: ['GOAL-1'] }],
     };
     it('accepts a valid canonical FGA document (no changes layer)', () => {
         const r = parseCanonicalFGA(VALID_FGA);
@@ -205,12 +205,12 @@ describe('parseCanonicalFGA', () => {
     });
 });
 describe('parseCanonicalFGCA — example file regression', () => {
-    const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'fgca');
+    const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'dgca');
     const files = fs.existsSync(EXAMPLES_DIR)
         ? fs.readdirSync(EXAMPLES_DIR).filter((f) => f.endsWith('.transitrix.yaml'))
         : [];
     for (const file of files) {
-        it(`accepts tests/fixtures/notation-corpus/fgca/${file}`, () => {
+        it(`accepts tests/fixtures/notation-corpus/dgca/${file}`, () => {
             const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
             const parsedYaml = yaml.load(text);
             const r = parseCanonicalFGCA(parsedYaml);
@@ -220,12 +220,12 @@ describe('parseCanonicalFGCA — example file regression', () => {
     }
 });
 describe('parseCanonicalFGA — example file regression', () => {
-    const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'fga');
+    const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'dga');
     const files = fs.existsSync(EXAMPLES_DIR)
         ? fs.readdirSync(EXAMPLES_DIR).filter((f) => f.endsWith('.transitrix.yaml'))
         : [];
     for (const file of files) {
-        it(`accepts tests/fixtures/notation-corpus/fga/${file} and resolves every activity to a goal`, () => {
+        it(`accepts tests/fixtures/notation-corpus/dga/${file} and resolves every activity to a goal`, () => {
             const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
             const r = parseCanonicalFGA(yaml.load(text));
             expect(r.errors).toEqual([]);

package/dist/fgca/__tests__/resolver.test.js

@@ -22,7 +22,7 @@ const ELEMENTS = [
 ];
 const SOURCES = { elements: ELEMENTS, relations: [] };
 const VIEW_DOC = {
-    notation: 'fgca',
+    notation: 'dgca',
     id: 'FGCA-STRAT-1',
     name: 'Strategy 2026 — FGCA chain',
     spec_version: '0.1',
@@ -40,7 +40,7 @@ describe('isFGCAViewDoc', () => {
     });
     it('returns false for an inline doc with factors/goals arrays', () => {
         expect(isFGCAViewDoc({
-            notation: 'fgca', id: 'FGCA-1', name: 'x',
+            notation: 'dgca', id: 'FGCA-1', name: 'x',
             factors: [], goals: [], changes: [], activities: [],
         })).toBe(false);
     });
@@ -56,7 +56,7 @@ describe('resolveFGCA — goals.filter=all', () => {
         const doc = resolveFGCA(VIEW_DOC, SOURCES);
         expect(doc['goals'].length).toBe(3);
         expect(doc['changes'].length).toBe(3);
-        expect(doc['activities'].length).toBe(5);
+        expect(doc['actions'].length).toBe(5);
     });
     it('derives factors from all goal.factors[] refs', () => {
         const doc = resolveFGCA(VIEW_DOC, SOURCES);
@@ -77,7 +77,7 @@ describe('resolveFGCA — goals.filter=all', () => {
     });
     it('carries view doc metadata (id, name, spec_version)', () => {
         const doc = resolveFGCA(VIEW_DOC, SOURCES);
-        expect(doc['notation']).toBe('fgca');
+        expect(doc['notation']).toBe('dgca');
         expect(doc['id']).toBe('FGCA-STRAT-1');
         expect(doc['name']).toBe('Strategy 2026 — FGCA chain');
         expect(doc['spec_version']).toBe('0.1');
@@ -95,7 +95,7 @@ describe('resolveFGCA — goals.filter=ids', () => {
         expect(goalIds).toEqual(['GOAL-1']);
         const changeIds = doc['changes'].map((c) => c.id);
         expect(changeIds).toEqual(['CHANGE-1']);
-        const actIds = doc['activities'].map((a) => a.id).sort();
+        const actIds = doc['actions'].map((a) => a.id).sort();
         expect(actIds).toEqual(['ACTIVITY-1', 'ACTIVITY-2']);
         const r = parseCanonicalFGCA(doc);
         expect(r.valid).toBe(true);
@@ -138,7 +138,7 @@ describe('resolveFGCA — empty sources', () => {
         expect(doc['goals'].length).toBe(0);
         expect(doc['factors'].length).toBe(0);
         expect(doc['changes'].length).toBe(0);
-        expect(doc['activities'].length).toBe(0);
+        expect(doc['actions'].length).toBe(0);
     });
     it('returns empty arrays for a non-object viewDoc', () => {
         const doc = resolveFGCA(null, SOURCES);
@@ -147,7 +147,7 @@ describe('resolveFGCA — empty sources', () => {
 });
 // ── File-based regression — resolver + canon fixture + parseCanonicalFGCA ─────
 describe('resolveFGCA — file-based regression against canon fixture', () => {
-    const CANON_ROOT = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'fgca', 'canon');
+    const CANON_ROOT = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'dgca', 'canon');
     const VIEW_DIR = path.join(CANON_ROOT, 'views');
     const ELEM_DIR = path.join(CANON_ROOT, 'elements');
     function loadYamlsUnder(dir) {

package/dist/fgca/__tests__/validate.test.js

@@ -1,11 +1,11 @@
 import { describe, it, expect } from 'vitest';
 import { validateFGCADoc } from '../validate.js';
 const VALID_DOC = {
-    notation: 'fgca',
+    notation: 'dgca',
     factors: [{ id: 1, name: 'Market pressure' }],
     goals: [{ id: 1, name: 'Grow revenue', factor: [{ id: 1 }] }],
     changes: [{ id: 1, name: 'Launch product', goal_id: 1, activity_ids: [1] }],
-    activities: [{ id: 1, name: 'Market research', goal_id: 1 }],
+    actions: [{ id: 1, name: 'Market research', goal_id: 1 }],
 };
 describe('validateFGCADoc', () => {
     it('accepts a valid document', () => {
@@ -31,25 +31,25 @@ describe('validateFGCADoc', () => {
     });
     it('errors when factors array is missing', () => {
         const { factors: _, ...without } = VALID_DOC;
-        const result = validateFGCADoc({ ...without, notation: 'fgca' });
+        const result = validateFGCADoc({ ...without, notation: 'dgca' });
         expect(result.valid).toBe(false);
         expect(result.errors.some(e => e.path === 'factors')).toBe(true);
     });
     it('errors when goals array is missing', () => {
         const { goals: _, ...without } = VALID_DOC;
-        const result = validateFGCADoc({ ...without, notation: 'fgca' });
+        const result = validateFGCADoc({ ...without, notation: 'dgca' });
         expect(result.valid).toBe(false);
         expect(result.errors.some(e => e.path === 'goals')).toBe(true);
     });
     it('errors when changes array is missing', () => {
         const { changes: _, ...without } = VALID_DOC;
-        const result = validateFGCADoc({ ...without, notation: 'fgca' });
+        const result = validateFGCADoc({ ...without, notation: 'dgca' });
         expect(result.valid).toBe(false);
         expect(result.errors.some(e => e.path === 'changes')).toBe(true);
     });
     it('errors when actions array is missing', () => {
-        const { activities: _, ...without } = VALID_DOC;
-        const result = validateFGCADoc({ ...without, notation: 'fgca' });
+        const { actions: _, ...without } = VALID_DOC;
+        const result = validateFGCADoc({ ...without, notation: 'dgca' });
         expect(result.valid).toBe(false);
         expect(result.errors.some(e => e.path === 'actions')).toBe(true);
     });
@@ -89,11 +89,11 @@ describe('validateFGCADoc', () => {
     });
     it('accepts a document with empty arrays', () => {
         const result = validateFGCADoc({
-            notation: 'fgca',
+            notation: 'dgca',
             factors: [],
             goals: [],
             changes: [],
-            activities: [],
+            actions: [],
         });
         expect(result.valid).toBe(true);
     });
@@ -117,8 +117,8 @@ describe('validateFGCADoc', () => {
         expect(r.valid).toBe(false);
         expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
     });
-    it('[blocker] tolerates a null element in activities[] without throwing', () => {
-        const r = validateFGCADoc({ ...VALID_DOC, activities: [null] });
+    it('[blocker] tolerates a null element in actions[] without throwing', () => {
+        const r = validateFGCADoc({ ...VALID_DOC, actions: [null] });
         expect(r.valid).toBe(false);
         expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
     });