@transitrix/diagrams 1.0.0 → 1.0.1

package/dist/process-blueprint/__tests__/layout.test.js

@@ -156,4 +156,41 @@ describe('layoutProcessBlueprint', () => {
         expect(layout.stageColumnWidth).toBe(300);
         expect(layout.stageHeaders[1].x).toBe(200 + 300);
     });
+    describe('visibleAspects', () => {
+        const FILE_WITH_ALL = build({
+            stages: [{ id: 'STAGE-1', name: 'A', goal: 'g', result: 'r' }],
+            systems: [{ name: 'OMS', stages: ['STAGE-1'] }],
+            actors: [{ name: 'Ops', stages: ['STAGE-1'] }],
+            equipment: [{ name: 'Printer', stages: ['STAGE-1'] }],
+        });
+        it('shows all categories when visibleAspects is not set', () => {
+            const layout = layoutProcessBlueprint(FILE_WITH_ALL);
+            expect(layout.aspectRows.map(r => r.category)).toEqual(expect.arrayContaining(['systems', 'actors', 'equipment']));
+            expect(layout.aspectRows).toHaveLength(3);
+        });
+        it('limits rows to those in visibleAspects', () => {
+            const layout = layoutProcessBlueprint(FILE_WITH_ALL, {
+                visibleAspects: ['systems'],
+            });
+            expect(layout.aspectRows).toHaveLength(1);
+            expect(layout.aspectRows[0].category).toBe('systems');
+        });
+        it('suppresses all aspect rows when visibleAspects is empty', () => {
+            const layout = layoutProcessBlueprint(FILE_WITH_ALL, { visibleAspects: [] });
+            expect(layout.aspectRows).toHaveLength(0);
+        });
+        it('preserves the canonical ASPECT_CATEGORIES order within the filtered set', () => {
+            const layout = layoutProcessBlueprint(FILE_WITH_ALL, {
+                visibleAspects: ['equipment', 'systems'],
+            });
+            expect(layout.aspectRows.map(r => r.category)).toEqual(['systems', 'equipment']);
+        });
+        it('ignores categories in visibleAspects that have no data', () => {
+            const layout = layoutProcessBlueprint(FILE_WITH_ALL, {
+                visibleAspects: ['systems', 'information_entities'],
+            });
+            expect(layout.aspectRows).toHaveLength(1);
+            expect(layout.aspectRows[0].category).toBe('systems');
+        });
+    });
 });

package/dist/process-blueprint/layout.js

@@ -331,9 +331,13 @@ export function layoutProcessBlueprint(file, options) {
     }));
     const aspectsStartY = resultRowY + resultRowHeight;
     // Aspect rows: only categories with at least one entry, in fixed order.
+    // When visibleAspects is set, skip categories not in the list.
+    const aspectCategoriesToRender = opts.visibleAspects !== undefined
+        ? ASPECT_CATEGORIES.filter(c => opts.visibleAspects.includes(c))
+        : ASPECT_CATEGORIES;
     const aspectRows = [];
     let aspectCursorY = aspectsStartY;
-    for (const category of ASPECT_CATEGORIES) {
+    for (const category of aspectCategoriesToRender) {
         const arr = pb?.[category];
         if (!Array.isArray(arr) || arr.length === 0)
             continue;

package/dist/process-blueprint/types.d.ts

@@ -24,7 +24,7 @@ export interface ComplianceLaneAssertion {
     /** Requirement ID this assertion is about. */
     about: string;
     /** Compliance realisation status. */
-    status: 'compliant' | 'partial' | 'non_compliant' | 'under_review' | 'n_a';
+    status: 'compliant' | 'partial' | 'non_compliant' | 'under_review' | 'pending_owner' | 'n_a';
     /**
      * Typed IDs of stages / process steps where the requirement is realised.
      * When empty/absent, the assertion covers the entire subject, not a specific stage.
@@ -106,7 +106,22 @@ export interface LaneConfig {
     compliance_filter?: {
         /** ISO jurisdiction codes; empty array means all jurisdictions. */
         jurisdictions?: string[];
+        /**
+         * Per-stage map of law IDs known from the previous generated snapshot.
+         * Key: stage ID; Value: array of law IDs present in that stage's previous report.
+         * Laws absent from the previous snapshot receive the `new` decoration.
+         * When absent, every law chip is treated as new.
+         */
+        previous_snapshot?: Record<string, string[]>;
     };
+    /**
+     * Lanes to show; controls which aspect rows and the compliance lane are rendered.
+     * Valid values: `"systems"` | `"actors"` | `"equipment"` | `"information_entities"` | `"compliance"`.
+     * When absent, all lanes with data are shown (current default behaviour).
+     * Named report config — committed, versioned. Per-user overrides live in
+     * `.transitrix/display-preferences/process-blueprint.json` (gitignored, never committed).
+     */
+    visible_lanes?: string[];
 }
 export interface ProcessBlueprintHeader {
     id: string;
@@ -155,6 +170,12 @@ export interface ProcessBlueprintLayoutOptions {
     complianceLane?: ComplianceLaneConfig;
     /** Assertion + requirement data for the compliance lane derivation. */
     complianceInput?: ComplianceLaneInput;
+    /**
+     * Restrict which aspect-category rows are rendered.
+     * When absent, all categories that have at least one entry are shown.
+     * Pass an empty array to suppress all aspect rows.
+     */
+    visibleAspects?: AspectCategory[];
 }
 import type { LayoutBounds } from '../geometry.js';
 export type { LayoutBounds };

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

@@ -7,7 +7,7 @@ function valid() {
         name: 'Data Protection Authority',
         type: 'external',
         actor: 'ACTOR-DPA-1',
-        concern: 'Lawful processing and timely erasure of EU customer personal data.',
+        concern: 'Lawful processing and timely erasure of personal data.',
         interest: 'high',
         influence: 'high',
         description: 'External oversight stakeholder.',
@@ -19,68 +19,70 @@ function valid() {
         valid_to: null,
     };
 }
-const codes = (input) => validateStakeholder(input).errors.map(e => e.code);
+const codes = (input, opts) => validateStakeholder(input, opts).errors.map(e => e.code);
 describe('validateStakeholder — positive', () => {
-    it('accepts the worked-example STAKEHOLDER-DPA-1', () => {
+    it('accepts a well-formed external stakeholder', () => {
         const r = validateStakeholder(valid());
         expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-        expect(r.errors).toHaveLength(0);
     });
-    it('accepts a minimal stakeholder (no concern / interest / influence)', () => {
-        const r = valid();
-        delete r.concern;
-        delete r.interest;
-        delete r.influence;
-        expect(validateStakeholder(r).valid).toBe(true);
+    it('accepts a minimal internal stakeholder with no optional profile fields', () => {
+        const s = valid();
+        s.id = 'STAKEHOLDER-OPS-1';
+        s.name = 'Operations';
+        s.type = 'internal';
+        s.actor = 'ACTOR-OPS-1';
+        delete s.concern;
+        delete s.interest;
+        delete s.influence;
+        delete s.description;
+        expect(validateStakeholder(s).valid).toBe(true);
     });
-});
-describe('validateStakeholder — STAKEHOLDER-001 (envelope / shape)', () => {
-    it('flags a non-object', () => {
-        expect(codes(null)).toEqual(['STAKEHOLDER-001']);
+    it('accepts when the catalog resolves the actor', () => {
+        const catalog = { typeOf: id => (id === 'ACTOR-DPA-1' ? 'ACTOR' : undefined) };
+        expect(validateStakeholder(valid(), { catalog }).valid).toBe(true);
     });
-    it('flags a wrong notation tag', () => {
-        expect(codes({ ...valid(), notation: 'stake' })).toContain('STAKEHOLDER-001');
+});
+describe('validateStakeholder — STAKE-001 (shape / id grammar / levels)', () => {
+    it('flags a missing required envelope field', () => {
+        const s = valid();
+        delete s.name;
+        expect(codes(s)).toContain('STAKE-001');
     });
-    it('flags an id with the wrong TYPE prefix', () => {
-        expect(codes({ ...valid(), id: 'ACTOR-DPA-1' })).toContain('STAKEHOLDER-001');
+    it('flags an id that violates the grammar', () => {
+        expect(codes({ ...valid(), id: 'STAKEHOLDER-DPA-001' })).toContain('STAKE-001');
+        expect(codes({ ...valid(), id: 'STAKE-1' })).toContain('STAKE-001');
     });
-});
-describe('validateStakeholder — STAKEHOLDER-002 (type enum)', () => {
-    it('flags a missing type', () => {
-        const r = valid();
-        delete r.type;
-        expect(codes(r)).toContain('STAKEHOLDER-002');
+    it('flags a wrong notation tag', () => {
+        expect(codes({ ...valid(), notation: 'stakeholders' })).toContain('STAKE-001');
     });
-    it('flags a type outside internal/external', () => {
-        expect(codes({ ...valid(), type: 'regulator' })).toContain('STAKEHOLDER-002');
+    it('flags an interest / influence value outside {high, medium, low}', () => {
+        expect(codes({ ...valid(), interest: 'critical' })).toContain('STAKE-001');
+        expect(codes({ ...valid(), influence: 'none' })).toContain('STAKE-001');
     });
-    it('accepts both internal and external', () => {
-        for (const t of ['internal', 'external']) {
-            expect(validateStakeholder({ ...valid(), type: t }).valid).toBe(true);
-        }
+    it('rejects a non-object', () => {
+        expect(codes(null)).toEqual(['STAKE-001']);
     });
 });
-describe('validateStakeholder — STAKEHOLDER-003 (actor binding)', () => {
+describe('validateStakeholder — STAKE-002 (actor binding)', () => {
     it('flags a missing actor', () => {
-        const r = valid();
-        delete r.actor;
-        expect(codes(r)).toContain('STAKEHOLDER-003');
+        const s = valid();
+        delete s.actor;
+        expect(codes(s)).toContain('STAKE-002');
     });
-    it('flags an actor that is not an ACTOR typed id', () => {
-        expect(codes({ ...valid(), actor: 'ROLE-CEO-1' })).toContain('STAKEHOLDER-003');
-        expect(codes({ ...valid(), actor: 'not an id' })).toContain('STAKEHOLDER-003');
+    it('flags an actor of the wrong TYPE', () => {
+        expect(codes({ ...valid(), actor: 'ROLE-OPS-1' })).toContain('STAKE-002');
     });
-});
-describe('validateStakeholder — STAKEHOLDER-004 (level enums)', () => {
-    it('flags an interest outside high/medium/low', () => {
-        expect(codes({ ...valid(), interest: 'extreme' })).toContain('STAKEHOLDER-004');
+    it('flags an actor that does not resolve when a catalog is supplied', () => {
+        const catalog = { typeOf: () => undefined };
+        expect(codes(valid(), { catalog })).toContain('STAKE-002');
     });
-    it('flags an influence outside high/medium/low', () => {
-        expect(codes({ ...valid(), influence: 'extreme' })).toContain('STAKEHOLDER-004');
+    it('flags an actor whose catalog TYPE is not ACTOR', () => {
+        const catalog = { typeOf: () => 'ROLE' };
+        expect(codes(valid(), { catalog })).toContain('STAKE-002');
     });
-    it('accepts each permitted level', () => {
-        for (const l of ['high', 'medium', 'low']) {
-            expect(validateStakeholder({ ...valid(), interest: l, influence: l }).valid).toBe(true);
-        }
+});
+describe('validateStakeholder — STAKE-003 (type enum)', () => {
+    it('flags a type outside {internal, external}', () => {
+        expect(codes({ ...valid(), type: 'partner' })).toContain('STAKE-003');
     });
 });

package/dist/stakeholder/index.d.ts

@@ -1,3 +1,4 @@
 export type { Stakeholder, StakeholderType, StakeholderLevel } from './types.js';
 export { STAKEHOLDER_TYPES, STAKEHOLDER_LEVELS } from './types.js';
 export { validateStakeholder } from './validate.js';
+export type { StakeholderValidateOptions } from './validate.js';

package/dist/stakeholder/types.d.ts

@@ -1,15 +1,14 @@
 import type { GateChecks } from '../requirement/types.js';
-export type StakeholderType = 'internal' | 'external';
 export declare const STAKEHOLDER_TYPES: readonly ["internal", "external"];
-export type StakeholderLevel = 'high' | 'medium' | 'low';
+export type StakeholderType = typeof STAKEHOLDER_TYPES[number];
 export declare const STAKEHOLDER_LEVELS: readonly ["high", "medium", "low"];
+export type StakeholderLevel = typeof STAKEHOLDER_LEVELS[number];
 export interface Stakeholder {
     notation: 'stakeholder';
     id: string;
     name: string;
-    /** Required subtype — internal | external. */
     type: StakeholderType;
-    /** Required ACTOR-… typed id — identity binding (never inline). */
+    /** ACTOR-… whose identity this stake attaches to (STAKE-002). */
     actor: string;
     concern?: string;
     interest?: StakeholderLevel;

package/dist/stakeholder/types.js

@@ -1,5 +1,4 @@
-// STAKEHOLDER — motivation-layer interest primitive.
-// Schema: methodology notations/ELEMENT_PRIMITIVES.md §7.15 +
-//         notations/elements/20-stakeholders.md + envelope §3.
+// STAKEHOLDER — motivation-layer interest primitive (ArchiMate Stakeholder).
+// Schema: methodology notations/elements/20-stakeholders.md + ELEMENT_PRIMITIVES.md §7.16.
 export const STAKEHOLDER_TYPES = ['internal', 'external'];
 export const STAKEHOLDER_LEVELS = ['high', 'medium', 'low'];

package/dist/stakeholder/validate.d.ts

@@ -1,2 +1,7 @@
 import type { ValidationResult } from '../validation-types.js';
-export declare function validateStakeholder(input: unknown): ValidationResult;
+import { type CanonCatalog } from '../typed-id.js';
+export interface StakeholderValidateOptions {
+    /** When provided, STAKE-002 enforces that `actor` resolves to an admitted ACTOR. */
+    catalog?: CanonCatalog;
+}
+export declare function validateStakeholder(input: unknown, options?: StakeholderValidateOptions): ValidationResult;

package/dist/stakeholder/validate.js

@@ -1,57 +1,78 @@
-// STAKEHOLDER validator — methodology notations/ELEMENT_PRIMITIVES.md §7.15
-// + notations/elements/20-stakeholders.md.
+// STAKEHOLDER validator — methodology notations/elements/20-stakeholders.md §5.
 //
-// Implements STAKEHOLDER-001..004. Stake-in-a-specific-object lives on
-// `stakeholding` REL records (elements/17-relations.md §3) and is out of
-// scope for this single-artefact validator.
-import { typeOfId } from '../typed-id.js';
-import { validateElementEnvelope } from '../element-envelope.js';
-import { STAKEHOLDER_LEVELS, STAKEHOLDER_TYPES } from './types.js';
-export function validateStakeholder(input) {
+// Codes:
+//   STAKE-001 — shape / id grammar / required envelope / interest|influence enum.
+//   STAKE-002 — `actor` missing, malformed, wrong TYPE, or unresolved in catalog.
+//   STAKE-003 — `type` outside {internal, external}.
+import { typeOfId, isCanonicalIdOfType } from '../typed-id.js';
+import { STAKEHOLDER_TYPES, STAKEHOLDER_LEVELS } from './types.js';
+const REQUIRED_STRING_FIELDS = [
+    'name', 'admitted_at', 'admitted_by', 'valid_from',
+];
+const TYPES = STAKEHOLDER_TYPES;
+const LEVELS = STAKEHOLDER_LEVELS;
+export function validateStakeholder(input, options = {}) {
     const errors = [];
     const warnings = [];
-    const { record, errors: envErrors } = validateElementEnvelope(input, {
-        notation: 'stakeholder',
-        idType: 'STAKEHOLDER',
-        code: 'STAKEHOLDER-001',
-    });
-    errors.push(...envErrors);
-    if (!record)
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        errors.push({ code: 'STAKE-001', message: 'Stakeholder must be a YAML mapping.' });
         return { valid: false, errors, warnings };
-    // STAKEHOLDER-002 — type subtype required.
-    if (record.type === undefined || record.type === null) {
-        errors.push({ code: 'STAKEHOLDER-002', message: 'type is required (internal | external).', path: 'type' });
-    }
-    else if (!STAKEHOLDER_TYPES.includes(record.type)) {
-        errors.push({
-            code: 'STAKEHOLDER-002',
-            message: `type "${String(record.type)}" must be one of ${STAKEHOLDER_TYPES.join(', ')}.`,
-            path: 'type',
-        });
-    }
-    // STAKEHOLDER-003 — actor identity binding (REQUIRED, must be ACTOR-…).
-    if (record.actor === undefined || record.actor === null || record.actor === '') {
-        errors.push({
-            code: 'STAKEHOLDER-003',
-            message: 'actor is required — identity lives in an ACTOR-… record, never inline.',
-            path: 'actor',
-        });
-    }
-    else if (typeOfId(record.actor) !== 'ACTOR') {
-        errors.push({
-            code: 'STAKEHOLDER-003',
-            message: `actor "${String(record.actor)}" must be an ACTOR typed ID.`,
-            path: 'actor',
-        });
-    }
-    // STAKEHOLDER-004 — interest / influence level enums (optional fields).
-    for (const f of ['interest', 'influence']) {
-        if (record[f] !== undefined && !STAKEHOLDER_LEVELS.includes(record[f])) {
-            errors.push({
-                code: 'STAKEHOLDER-004',
-                message: `${f} "${String(record[f])}" must be one of ${STAKEHOLDER_LEVELS.join(', ')}.`,
-                path: f,
-            });
+    }
+    const s = input;
+    // STAKE-001 — id grammar + notation tag + envelope.
+    if (!isCanonicalIdOfType(s.id, 'STAKEHOLDER')) {
+        errors.push({ code: 'STAKE-001', message: `id "${String(s.id)}" must match STAKEHOLDER-[<middle>-]<INTEGER>.`, path: 'id' });
+    }
+    if (s.notation !== 'stakeholder') {
+        errors.push({ code: 'STAKE-001', message: 'notation must be the fixed value "stakeholder".', path: 'notation' });
+    }
+    if (s.zone !== undefined && s.zone !== 'canon') {
+        errors.push({ code: 'STAKE-001', message: 'zone must be "canon" for a STAKEHOLDER.', path: 'zone' });
+    }
+    else if (s.zone === undefined) {
+        errors.push({ code: 'STAKE-001', message: 'zone is required.', path: 'zone' });
+    }
+    for (const field of REQUIRED_STRING_FIELDS) {
+        const v = s[field];
+        if (typeof v !== 'string' || v.trim() === '') {
+            errors.push({ code: 'STAKE-001', message: `${field} is required.`, path: field });
+        }
+    }
+    if (s.gate_checks === null || typeof s.gate_checks !== 'object') {
+        errors.push({ code: 'STAKE-001', message: 'gate_checks is required and must be a mapping.', path: 'gate_checks' });
+    }
+    if (!('valid_to' in s) || !(typeof s.valid_to === 'string' || s.valid_to === null)) {
+        errors.push({ code: 'STAKE-001', message: 'valid_to is required (an ISO date string or null).', path: 'valid_to' });
+    }
+    // STAKE-003 — type enum (required field).
+    if (typeof s.type !== 'string' || s.type.trim() === '') {
+        errors.push({ code: 'STAKE-001', message: 'type is required.', path: 'type' });
+    }
+    else if (!TYPES.includes(s.type)) {
+        errors.push({ code: 'STAKE-003', message: `type "${s.type}" must be one of ${TYPES.join(', ')}.`, path: 'type' });
+    }
+    // STAKE-002 — actor identity binding (required).
+    const actor = s.actor;
+    if (typeof actor !== 'string' || actor.trim() === '') {
+        errors.push({ code: 'STAKE-002', message: 'actor is required — identity must come from an ACTOR.', path: 'actor' });
+    }
+    else if (typeOfId(actor) !== 'ACTOR') {
+        errors.push({ code: 'STAKE-002', message: `actor "${actor}" must be a typed ACTOR id.`, path: 'actor' });
+    }
+    else if (options.catalog) {
+        const t = options.catalog.typeOf(actor);
+        if (t === undefined) {
+            errors.push({ code: 'STAKE-002', message: `actor "${actor}" does not resolve to an admitted ACTOR.`, path: 'actor' });
+        }
+        else if (t !== 'ACTOR') {
+            errors.push({ code: 'STAKE-002', message: `actor "${actor}" resolves to a ${t}, not an ACTOR.`, path: 'actor' });
+        }
+    }
+    // STAKE-001 — interest / influence levels.
+    for (const field of ['interest', 'influence']) {
+        const v = s[field];
+        if (v !== undefined && (typeof v !== 'string' || !LEVELS.includes(v))) {
+            errors.push({ code: 'STAKE-001', message: `${field} "${String(v)}" must be one of ${LEVELS.join(', ')}.`, path: field });
         }
     }
     return { valid: errors.length === 0, errors, warnings };

package/dist/target-state/__tests__/validate.test.js

@@ -5,7 +5,7 @@ function valid() {
         notation: 'target-state',
         id: 'TARGET_STATE-EU-LIVE-1',
         name: 'EU operations live — three markets, localised CRM and payments',
-        description: 'The structural end-state in which Acme operates in three EU markets.',
+        description: 'The structural end-state.',
         capabilities: ['CAPABILITY-V1', 'CAPABILITY-V1.2', 'CAPABILITY-V2'],
         processes: ['PROCESS-CUST-ONBOARD-1', 'PROCESS-ORD-FULFILL-1'],
         applications: ['APPLICATION-CRM-1', 'APPLICATION-OMS-1'],
@@ -17,46 +17,62 @@ function valid() {
         valid_to: null,
     };
 }
-const codes = (input) => validateTargetState(input).errors.map(e => e.code);
+const codes = (input, opts) => validateTargetState(input, opts).errors.map(e => e.code);
 describe('validateTargetState — positive', () => {
-    it('accepts the worked-example TARGET_STATE-EU-LIVE-1', () => {
+    it('accepts a well-formed target state', () => {
         const r = validateTargetState(valid());
         expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-        expect(r.errors).toHaveLength(0);
     });
-    it('accepts a minimal target state (name + envelope only)', () => {
-        const r = valid();
-        delete r.capabilities;
-        delete r.processes;
-        delete r.applications;
-        expect(validateTargetState(r).valid).toBe(true);
+    it('accepts a target state with empty composition lists', () => {
+        const t = valid();
+        delete t.capabilities;
+        delete t.processes;
+        delete t.applications;
+        expect(validateTargetState(t).valid).toBe(true);
+    });
+    it('accepts CAPABILITY V/H ids without integer terminal', () => {
+        const t = valid();
+        t.capabilities = ['CAPABILITY-V1.2.3', 'CAPABILITY-H1.2'];
+        expect(validateTargetState(t).valid).toBe(true);
     });
 });
-describe('validateTargetState — TARGET_STATE-001 (envelope / shape)', () => {
-    it('flags a non-object', () => {
-        expect(codes(null)).toEqual(['TARGET_STATE-001']);
+describe('validateTargetState — TSTATE-001 (shape / id grammar)', () => {
+    it('flags a missing required envelope field', () => {
+        const t = valid();
+        delete t.name;
+        expect(codes(t)).toContain('TSTATE-001');
+    });
+    it('flags an id that violates the grammar', () => {
+        expect(codes({ ...valid(), id: 'TARGET_STATE-EU-LIVE-001' })).toContain('TSTATE-001');
+        expect(codes({ ...valid(), id: 'TS-1' })).toContain('TSTATE-001');
     });
     it('flags a wrong notation tag', () => {
-        expect(codes({ ...valid(), notation: 'plateau' })).toContain('TARGET_STATE-001');
+        expect(codes({ ...valid(), notation: 'target_state' })).toContain('TSTATE-001');
     });
-    it('flags an id with the wrong TYPE prefix', () => {
-        expect(codes({ ...valid(), id: 'SCENARIO-EU-LIVE-1' })).toContain('TARGET_STATE-001');
+    it('flags a non-array composition list', () => {
+        expect(codes({ ...valid(), capabilities: 'CAPABILITY-V1' })).toContain('TSTATE-001');
     });
-    it('flags an inline goals field (it belongs on a REL)', () => {
-        expect(codes({ ...valid(), goals: ['GOAL-EU-1'] })).toContain('TARGET_STATE-001');
+    it('rejects a non-object', () => {
+        expect(codes(null)).toEqual(['TSTATE-001']);
     });
 });
-describe('validateTargetState — TARGET_STATE-002 (composition refs)', () => {
-    it('flags a non-CAPABILITY id in capabilities', () => {
-        expect(codes({ ...valid(), capabilities: ['PROCESS-X-1'] })).toContain('TARGET_STATE-002');
+describe('validateTargetState — TSTATE-002 (composition TYPEs)', () => {
+    it('flags a capabilities entry of the wrong TYPE', () => {
+        expect(codes({ ...valid(), capabilities: ['PROCESS-X-1'] })).toContain('TSTATE-002');
     });
-    it('flags a non-PROCESS id in processes', () => {
-        expect(codes({ ...valid(), processes: ['CAPABILITY-V1'] })).toContain('TARGET_STATE-002');
+    it('flags a processes entry of the wrong TYPE', () => {
+        expect(codes({ ...valid(), processes: ['APPLICATION-X-1'] })).toContain('TSTATE-002');
     });
-    it('flags a non-APPLICATION id in applications', () => {
-        expect(codes({ ...valid(), applications: ['PRODUCT-X-1'] })).toContain('TARGET_STATE-002');
+    it('flags an applications entry of the wrong TYPE', () => {
+        expect(codes({ ...valid(), applications: ['CAPABILITY-V1'] })).toContain('TSTATE-002');
     });
-    it('flags a composition field that is not an array', () => {
-        expect(codes({ ...valid(), capabilities: 'CAPABILITY-V1' })).toContain('TARGET_STATE-002');
+    it('flags an unresolved id when a catalog is supplied', () => {
+        const catalog = { typeOf: () => undefined };
+        expect(codes(valid(), { catalog })).toContain('TSTATE-002');
+    });
+});
+describe('validateTargetState — TSTATE-003 (forbidden inline goals)', () => {
+    it('flags an inline goals field', () => {
+        expect(codes({ ...valid(), goals: ['GOAL-EU-1'] })).toContain('TSTATE-003');
     });
 });

package/dist/target-state/index.d.ts

@@ -1,2 +1,4 @@
 export type { TargetState } from './types.js';
+export { TARGET_STATE_COMPOSITION_FIELDS } from './types.js';
 export { validateTargetState } from './validate.js';
+export type { TargetStateValidateOptions } from './validate.js';

package/dist/target-state/index.js

@@ -1 +1,2 @@
+export { TARGET_STATE_COMPOSITION_FIELDS } from './types.js';
 export { validateTargetState } from './validate.js';

package/dist/target-state/types.d.ts

@@ -1,9 +1,14 @@
 import type { GateChecks } from '../requirement/types.js';
+/** Composition list field → expected TYPE prefix of each entry. */
+export declare const TARGET_STATE_COMPOSITION_FIELDS: {
+    readonly capabilities: "CAPABILITY";
+    readonly processes: "PROCESS";
+    readonly applications: "APPLICATION";
+};
 export interface TargetState {
     notation: 'target-state';
     id: string;
     name: string;
-    /** Composition lists are inline; they are timeless on the element file. */
     capabilities?: string[];
     processes?: string[];
     applications?: string[];

package/dist/target-state/types.js

@@ -1,7 +1,8 @@
-// TARGET_STATE — implementation-layer plateau primitive (ArchiMate Plateau).
-// Schema: methodology notations/ELEMENT_PRIMITIVES.md §7.17 + envelope §3.
-//
-// The id TYPE prefix is `TARGET_STATE` (underscore — uppercase identifier in
-// IDS_AND_REFERENCES.md §3.1). The notation tag is the lowercased hyphenated
-// short name `target-state` (per ELEMENT_PRIMITIVES.md §4).
-export {};
+// TARGET_STATE — implementation-layer Plateau (ArchiMate).
+// Schema: methodology notations/ELEMENT_PRIMITIVES.md §7.18.
+/** Composition list field → expected TYPE prefix of each entry. */
+export const TARGET_STATE_COMPOSITION_FIELDS = {
+    capabilities: 'CAPABILITY',
+    processes: 'PROCESS',
+    applications: 'APPLICATION',
+};

package/dist/target-state/validate.d.ts

@@ -1,2 +1,7 @@
 import type { ValidationResult } from '../validation-types.js';
-export declare function validateTargetState(input: unknown): ValidationResult;
+import { type CanonCatalog } from '../typed-id.js';
+export interface TargetStateValidateOptions {
+    /** When provided, TSTATE-002 enforces that each composition id is admitted. */
+    catalog?: CanonCatalog;
+}
+export declare function validateTargetState(input: unknown, options?: TargetStateValidateOptions): ValidationResult;