@transitrix/diagrams 1.2.0 → 1.4.0

package/dist/activity-card/__tests__/validate.test.js

@@ -1,9 +1,9 @@
 import { describe, it, expect } from 'vitest';
 import { validateActivityCard } from '../validate.js';
 const VALID = {
-    notation: 'activity-card',
+    notation: 'action-card',
     spec_version: '0.1',
-    activity_card: {
+    action_card: {
         id: 'ACTIVITY_CARD-EU-PROGRAMME-1',
         project: 'ACTIVITY-EU-PROGRAMME-1',
         description: 'Executive summary.',
@@ -18,11 +18,22 @@ const VALID = {
     },
 };
 describe('validateActivityCard', () => {
-    it('accepts a well-formed card (deprecated notation: activity-card)', () => {
+    it('accepts a well-formed card (notation: action-card)', () => {
         const r = validateActivityCard(VALID);
         expect(r.valid).toBe(true);
         expect(r.errors).toHaveLength(0);
-        expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(true);
+        expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(false);
+    });
+    it('rejects deprecated notation: activity-card', () => {
+        const r = validateActivityCard({
+            notation: 'activity-card',
+            activity_card: {
+                id: 'ACTIVITY_CARD-EU-PROGRAMME-1',
+                project: 'ACTIVITY-EU-PROGRAMME-1',
+            },
+        });
+        expect(r.valid).toBe(false);
+        expect(r.errors.some(e => e.code === 'HDR-002')).toBe(true);
     });
     it('accepts notation: action-card with action_card block (canonical)', () => {
         const r = validateActivityCard({
@@ -59,33 +70,33 @@ describe('validateActivityCard', () => {
         const r = validateActivityCard({ ...VALID, notation: 'activities' });
         expect(r.errors.some((e) => e.code === 'HDR-002')).toBe(true);
     });
-    it('AC-001 on missing activity_card block', () => {
-        const r = validateActivityCard({ notation: 'activity-card' });
+    it('AC-001 on missing action_card block', () => {
+        const r = validateActivityCard({ notation: 'action-card' });
         expect(r.valid).toBe(false);
         expect(r.errors.some((e) => e.code === 'AC-001')).toBe(true);
     });
     it('AC-002 on malformed card id', () => {
-        const r = validateActivityCard({ ...VALID, activity_card: { ...VALID.activity_card, id: 'CARD-1' } });
+        const r = validateActivityCard({ ...VALID, action_card: { ...VALID.action_card, id: 'CARD-1' } });
         expect(r.errors.some((e) => e.code === 'AC-002')).toBe(true);
     });
     it('PC-001 on missing project', () => {
         const r = validateActivityCard({
             ...VALID,
-            activity_card: { ...VALID.activity_card, project: undefined },
+            action_card: { ...VALID.action_card, project: undefined },
         });
         expect(r.errors.some((e) => e.code === 'PC-001')).toBe(true);
     });
     it('PC-001 on malformed project id', () => {
         const r = validateActivityCard({
             ...VALID,
-            activity_card: { ...VALID.activity_card, project: 'GOAL-1' },
+            action_card: { ...VALID.action_card, project: 'GOAL-1' },
         });
         expect(r.errors.some((e) => e.code === 'PC-001')).toBe(true);
     });
     it('AC-003 on milestone missing required fields', () => {
         const r = validateActivityCard({
             ...VALID,
-            activity_card: { ...VALID.activity_card, milestones: [{ id: 'MILESTONE-X-1' }] },
+            action_card: { ...VALID.action_card, milestones: [{ id: 'MILESTONE-X-1' }] },
         });
         expect(r.valid).toBe(false);
         expect(r.errors.some((e) => e.code === 'AC-003')).toBe(true);
@@ -93,8 +104,8 @@ describe('validateActivityCard', () => {
     it('AC-004 on malformed milestone id', () => {
         const r = validateActivityCard({
             ...VALID,
-            activity_card: {
-                ...VALID.activity_card,
+            action_card: {
+                ...VALID.action_card,
                 milestones: [{ id: 'MS-1', name: 'x', date: '2027-01-01' }],
             },
         });
@@ -104,15 +115,15 @@ describe('validateActivityCard', () => {
         const m = { id: 'MILESTONE-X-1', name: 'x', date: '2027-01-01' };
         const r = validateActivityCard({
             ...VALID,
-            activity_card: { ...VALID.activity_card, milestones: [m, { ...m }] },
+            action_card: { ...VALID.action_card, milestones: [m, { ...m }] },
         });
         expect(r.errors.some((e) => e.code === 'AC-004' && /Duplicate/.test(e.message))).toBe(true);
     });
     it('AC-005 on bad milestone date format', () => {
         const r = validateActivityCard({
             ...VALID,
-            activity_card: {
-                ...VALID.activity_card,
+            action_card: {
+                ...VALID.action_card,
                 milestones: [{ id: 'MILESTONE-X-1', name: 'x', date: '31/01/2027' }],
             },
         });
@@ -121,8 +132,8 @@ describe('validateActivityCard', () => {
     it('AC-006 on malformed delivers_changes entry', () => {
         const r = validateActivityCard({
             ...VALID,
-            activity_card: {
-                ...VALID.activity_card,
+            action_card: {
+                ...VALID.action_card,
                 milestones: [{ id: 'MILESTONE-X-1', name: 'x', date: '2027-01-01', delivers_changes: ['GOAL-1'] }],
             },
         });
@@ -131,7 +142,7 @@ describe('validateActivityCard', () => {
     it('accepts a card with no milestones', () => {
         const r = validateActivityCard({
             ...VALID,
-            activity_card: { id: 'ACTIVITY_CARD-X-1', project: 'ACTIVITY-X-1' },
+            action_card: { id: 'ACTIVITY_CARD-X-1', project: 'ACTIVITY-X-1' },
         });
         expect(r.valid).toBe(true);
     });

package/dist/activity-card/layout.js

@@ -164,7 +164,7 @@ export function layoutActivityCard(card, options) {
         descriptionRow = { label: 'Description', valueLines: lines, x: contentX, y: cursorY, width: contentW, height };
         cursorY += height + SECTION_GAP;
     }
-    // ── 5. Chain: Drivers → Assessments → Goals → Changes ────────────────────
+    // ── 5. Chain: Drivers → Goals → Changes ──────────────────────────────────
     // Each section is a full-width band with a header label and stacked node rows.
     // An empty section shows a gap indicator ("— not on file") so the author
     // sees which parts of the narrative are missing.
@@ -192,9 +192,7 @@ export function layoutActivityCard(card, options) {
         cursorY += sectionH + CONNECTOR_H;
     }
     const { drivers, goals, changes } = card.motivation;
-    const assessments = card.assessments ?? [];
     pushChainSection('drivers', 'Drivers', 'What prompted this initiative?', drivers.map((d) => ({ id: d.id, name: d.name })));
-    pushChainSection('assessments', 'Assessments', 'What is the current gap?', assessments.map((a) => ({ id: a.id, name: a.name, meta: a.observed_at })));
     pushChainSection('goals', 'Goals', 'What outcome do we target?', goals.map((g) => ({ id: g.id, name: g.name })));
     pushChainSection('changes', 'Changes', 'What will change?', changes.map((c) => ({ id: c.id, name: c.name })));
     // Remove trailing CONNECTOR_H — last section connects to milestones with SECTION_GAP.
@@ -202,10 +200,6 @@ export function layoutActivityCard(card, options) {
     // Node-level chain edges.
     const driverIdSet = new Set(drivers.map((d) => d.id));
     const goalIdSet = new Set(goals.map((g) => g.id));
-    for (const a of assessments) {
-        if (driverIdSet.has(a.driverId))
-            chainEdges.push({ sourceId: a.driverId, targetId: a.id });
-    }
     for (const g of goals) {
         for (const did of g.driverIds) {
             if (driverIdSet.has(did))

package/dist/activity-card/resolver.js

@@ -350,10 +350,19 @@ export function resolveActivityCard(doc, sources) {
     // goals referenced only by in-scope changes). Resolve each id to its GOAL
     // element name, falling back to the id when the element is absent.
     const goalNames = projectGoalIds.map((gid) => str(goalElems.get(gid)?.['name']) ?? gid);
-    // ── Stakeholders — active `activity_stakeholder` relations from the project ──
+    // ── Stakeholders — inline `stakeholders: []` on the Action element PLUS active
+    //    `action_stakeholder` / `activity_stakeholder` REL files. Both sources are
+    //    merged; REL entries take precedence (they carry the role field).
     const stakeholderElems = collectByNotation(sources.elements, 'stakeholder');
+    const relStakeholderRefs = activeActivityStakeholders(sources.relations, projectId);
+    const relStakeholderIds = new Set(relStakeholderRefs.map((s) => s.id));
+    const inlineStakeholderIds = strArray(projectRec['stakeholders']).filter((id) => !relStakeholderIds.has(id));
+    const allStakeholderRefs = [
+        ...relStakeholderRefs,
+        ...inlineStakeholderIds.map((id) => ({ id })),
+    ];
     const stakeholders = [];
-    for (const { id: sid, role } of activeActivityStakeholders(sources.relations, projectId)) {
+    for (const { id: sid, role } of allStakeholderRefs) {
         const rec = stakeholderElems.get(sid);
         if (!rec) {
             warnings.push({

package/dist/activity-card/types.d.ts

@@ -214,7 +214,7 @@ export interface ChainEdge {
  * so the author sees the missing data.
  */
 export interface ChainSectionLayout {
-    type: 'drivers' | 'assessments' | 'goals' | 'changes';
+    type: 'drivers' | 'goals' | 'changes';
     /** Section header label. */
     label: string;
     /** Short question answered by this section, shown in grey after the label. */

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 };
+}