@transitrix/diagrams 1.0.0

package/dist/scenarios/types.d.ts

@@ -0,0 +1,45 @@
+export type ScenarioStatus = 'Draft' | 'Active' | 'Archived';
+export type FactorRelevance = 'High' | 'Medium' | 'Low';
+export interface FactorView {
+    factor_id: string;
+    relevance?: FactorRelevance;
+    impact?: string;
+}
+export interface GoalRef {
+    goal_id: string;
+}
+export interface CapabilityRef {
+    capability_id: string;
+}
+export interface ActivityRef {
+    activity_id: string;
+}
+export interface ProductRef {
+    product_id: string;
+}
+export interface ProcessRef {
+    process_id: string;
+}
+export interface ApplicationRef {
+    app_id: string;
+}
+export interface ScenarioHeader {
+    id: string;
+    name: string;
+    description?: string;
+    status: ScenarioStatus;
+    created_at?: string;
+    vision?: string;
+    factors_view?: FactorView[];
+    goals?: GoalRef[];
+    capabilities?: CapabilityRef[];
+    activities?: ActivityRef[];
+    products?: ProductRef[];
+    processes?: ProcessRef[];
+    applications?: ApplicationRef[];
+}
+export interface ScenarioFile {
+    notation: string;
+    spec_version?: string;
+    scenario: ScenarioHeader;
+}

package/dist/scenarios/types.js

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

package/dist/scenarios/validate.d.ts

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

package/dist/scenarios/validate.js

@@ -0,0 +1,110 @@
+const VALID_STATUSES = new Set(['Draft', 'Active', 'Archived']);
+const VALID_RELEVANCE = new Set(['High', 'Medium', 'Low']);
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const REF_SPECS = [
+    { field: 'goals', idField: 'goal_id', errorCode: 'SCN-007' },
+    { field: 'capabilities', idField: 'capability_id', errorCode: 'SCN-008' },
+    { field: 'activities', idField: 'activity_id', errorCode: 'SCN-009' },
+    { field: 'products', idField: 'product_id', errorCode: 'SCN-010' },
+    { field: 'processes', idField: 'process_id', errorCode: 'SCN-011' },
+    { field: 'applications', idField: 'app_id', errorCode: 'SCN-012' },
+];
+export function validateScenario(input) {
+    const errors = [];
+    const warnings = [];
+    if (!input || typeof input !== 'object') {
+        return { valid: false, errors: [{ code: 'SCN-001', message: 'Input must be an object' }], warnings };
+    }
+    const raw = input;
+    if (!('notation' in raw)) {
+        errors.push({ code: 'SCN-001', message: 'Missing required field: notation' });
+    }
+    else if (raw['notation'] !== 'scenarios') {
+        errors.push({ code: 'SCN-001', message: `notation must be "scenarios", got "${raw['notation']}"` });
+    }
+    if (errors.length > 0)
+        return { valid: false, errors, warnings };
+    const scn = raw['scenario'];
+    if (!scn || typeof scn !== 'object') {
+        errors.push({ code: 'SCN-002', message: 'Missing required field: scenario' });
+        return { valid: false, errors, warnings };
+    }
+    const s = scn;
+    if (!s['id'] || typeof s['id'] !== 'string' || !s['id'].trim())
+        errors.push({ code: 'SCN-002', message: 'scenario.id is required' });
+    if (!s['name'] || typeof s['name'] !== 'string' || !s['name'].trim())
+        errors.push({ code: 'SCN-002', message: 'scenario.name is required' });
+    if (!s['status']) {
+        errors.push({ code: 'SCN-002', message: 'scenario.status is required' });
+    }
+    else if (!VALID_STATUSES.has(s['status'])) {
+        errors.push({ code: 'SCN-003', message: `scenario.status "${s['status']}" must be one of: Draft, Active, Archived` });
+    }
+    if (errors.length > 0)
+        return { valid: false, errors, warnings };
+    if (s['created_at'] !== undefined) {
+        if (typeof s['created_at'] !== 'string' || !DATE_RE.test(s['created_at'])) {
+            errors.push({ code: 'SCN-004', message: `scenario.created_at must be YYYY-MM-DD, got "${s['created_at']}"` });
+        }
+    }
+    if (s['factors_view'] !== undefined) {
+        if (!Array.isArray(s['factors_view'])) {
+            errors.push({ code: 'SCN-005', message: 'scenario.factors_view must be an array' });
+        }
+        else {
+            const seen = new Set();
+            const fv = s['factors_view'];
+            for (let i = 0; i < fv.length; i++) {
+                const rawFactor = fv[i];
+                const idx = `factors_view[${i}]`;
+                if (!rawFactor || typeof rawFactor !== 'object') {
+                    errors.push({ code: 'SCN-005', message: `${idx} must be an object` });
+                    continue;
+                }
+                const f = rawFactor;
+                if (!f['factor_id'] || typeof f['factor_id'] !== 'string' || !f['factor_id'].trim()) {
+                    errors.push({ code: 'SCN-005', message: `${idx}: factor_id is required` });
+                }
+                else {
+                    const fid = f['factor_id'];
+                    if (seen.has(fid))
+                        errors.push({ code: 'SCN-013', message: `Duplicate factor_id: "${fid}"` });
+                    seen.add(fid);
+                }
+                if (f['relevance'] !== undefined && !VALID_RELEVANCE.has(f['relevance'])) {
+                    errors.push({ code: 'SCN-006', message: `${idx}: relevance "${f['relevance']}" must be one of: High, Medium, Low` });
+                }
+            }
+        }
+    }
+    for (const spec of REF_SPECS) {
+        const list = s[spec.field];
+        if (list === undefined)
+            continue;
+        if (!Array.isArray(list)) {
+            errors.push({ code: spec.errorCode, message: `scenario.${spec.field} must be an array` });
+            continue;
+        }
+        const seen = new Set();
+        for (let i = 0; i < list.length; i++) {
+            const rawItem = list[i];
+            const idx = `${spec.field}[${i}]`;
+            if (!rawItem || typeof rawItem !== 'object') {
+                errors.push({ code: spec.errorCode, message: `${idx} must be an object` });
+                continue;
+            }
+            const item = rawItem;
+            const id = item[spec.idField];
+            if (!id || typeof id !== 'string' || !id.trim()) {
+                errors.push({ code: spec.errorCode, message: `${idx}: ${spec.idField} is required` });
+            }
+            else {
+                const sid = id;
+                if (seen.has(sid))
+                    errors.push({ code: spec.errorCode, message: `${idx}: duplicate ${spec.idField} "${sid}"` });
+                seen.add(sid);
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}

package/dist/schema-version.d.ts

@@ -0,0 +1,16 @@
+/**
+ * SCHEMA_VERSION — the methodology release whose notation schemas and validation
+ * rules this `@transitrix/diagrams` build conforms to (SV-1).
+ *
+ * Source of truth: the methodology `methodology_version`, declared in an adopter
+ * repository's `transitrix.yaml` per the methodology `notations/MANIFEST.md`
+ * (single source of truth for a repo's conformance). The current methodology
+ * release is **0.5.0**.
+ *
+ * This constant is kept in lockstep with the project manifest's
+ * `transitrix.methodologyVersion` (`package.json`); the
+ * `tests/schema-version.test.ts` unit test asserts the two are equal. A CI guard
+ * that additionally asserts both equal the methodology's published SoT lands
+ * separately (SV-1 PR2) — do not bundle it here.
+ */
+export declare const SCHEMA_VERSION = "0.5.0";

package/dist/schema-version.js

@@ -0,0 +1,16 @@
+/**
+ * SCHEMA_VERSION — the methodology release whose notation schemas and validation
+ * rules this `@transitrix/diagrams` build conforms to (SV-1).
+ *
+ * Source of truth: the methodology `methodology_version`, declared in an adopter
+ * repository's `transitrix.yaml` per the methodology `notations/MANIFEST.md`
+ * (single source of truth for a repo's conformance). The current methodology
+ * release is **0.5.0**.
+ *
+ * This constant is kept in lockstep with the project manifest's
+ * `transitrix.methodologyVersion` (`package.json`); the
+ * `tests/schema-version.test.ts` unit test asserts the two are equal. A CI guard
+ * that additionally asserts both equal the methodology's published SoT lands
+ * separately (SV-1 PR2) — do not bundle it here.
+ */
+export const SCHEMA_VERSION = '0.5.0';

package/dist/scope.d.ts

@@ -0,0 +1,23 @@
+import type { ValidationWarning } from './validation-types.js';
+export type Scope = {
+    mode: 'all';
+} | {
+    mode: 'level';
+    maxLevel: number;
+} | {
+    mode: 'root';
+    rootGoalId: string;
+};
+/** Default scope — render everything. */
+export declare const SCOPE_ALL: Scope;
+/** Warning code emitted when a root-mode scope names a goal that isn't in the document. */
+export declare const SCOPE_MISSING_ROOT_CODE = "SCOPE-001";
+/**
+ * Returns the SCOPE-001 warning when `scope` is root-mode and `rootGoalId` is
+ * not among the document's goal ids; otherwise null. Goal ids are compared as
+ * strings so numeric (FGCA/Goals) and string ids both work.
+ *
+ * Previews call this to surface the warning in their panel — the layout
+ * functions independently return an empty layout in the same situation.
+ */
+export declare function checkScopeRoot(scope: Scope, goalIds: Iterable<string | number>): ValidationWarning | null;

package/dist/scope.js

@@ -0,0 +1,38 @@
+// Scope filtering for hierarchical / relational previews (Goals, FGA, FGCA).
+//
+// A `Scope` trims what a preview renders to part of the hierarchy:
+//   - 'all'   → everything (default, today's behaviour)
+//   - 'level' → only goals at or below a level cap, plus the factors /
+//               changes / activities that touch a visible goal
+//   - 'root'  → only a chosen goal's subtree (Goals: descendants via
+//               parent_id; FGA/FGCA goals are flat, so the subtree is the
+//               single root goal), plus its connected factors / changes /
+//               activities
+//
+// This is intentionally a small, pure rendering primitive: a role's view in
+// a future access-control layer (DSM) can be expressed as a level cap or a
+// subtree root and reuse exactly this filter. No RBAC here — just the filter.
+/** Default scope — render everything. */
+export const SCOPE_ALL = { mode: 'all' };
+/** Warning code emitted when a root-mode scope names a goal that isn't in the document. */
+export const SCOPE_MISSING_ROOT_CODE = 'SCOPE-001';
+/**
+ * Returns the SCOPE-001 warning when `scope` is root-mode and `rootGoalId` is
+ * not among the document's goal ids; otherwise null. Goal ids are compared as
+ * strings so numeric (FGCA/Goals) and string ids both work.
+ *
+ * Previews call this to surface the warning in their panel — the layout
+ * functions independently return an empty layout in the same situation.
+ */
+export function checkScopeRoot(scope, goalIds) {
+    if (scope.mode !== 'root')
+        return null;
+    for (const id of goalIds) {
+        if (String(id) === scope.rootGoalId)
+            return null;
+    }
+    return {
+        code: SCOPE_MISSING_ROOT_CODE,
+        message: `Scope root goal "${scope.rootGoalId}" was not found in this document — nothing to show. Clear the scope or pick a goal that exists.`,
+    };
+}

package/dist/stakeholder/__tests__/validate.test.d.ts

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

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

@@ -0,0 +1,86 @@
+import { describe, it, expect } from 'vitest';
+import { validateStakeholder } from '../validate.js';
+function valid() {
+    return {
+        notation: 'stakeholder',
+        id: 'STAKEHOLDER-DPA-1',
+        name: 'Data Protection Authority',
+        type: 'external',
+        actor: 'ACTOR-DPA-1',
+        concern: 'Lawful processing and timely erasure of EU customer personal data.',
+        interest: 'high',
+        influence: 'high',
+        description: 'External oversight stakeholder.',
+        zone: 'canon',
+        admitted_at: '2026-05-29',
+        admitted_by: 'v.korobeinikov',
+        gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
+        valid_from: '2018-05-25',
+        valid_to: null,
+    };
+}
+const codes = (input) => validateStakeholder(input).errors.map(e => e.code);
+describe('validateStakeholder — positive', () => {
+    it('accepts the worked-example STAKEHOLDER-DPA-1', () => {
+        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);
+    });
+});
+describe('validateStakeholder — STAKEHOLDER-001 (envelope / shape)', () => {
+    it('flags a non-object', () => {
+        expect(codes(null)).toEqual(['STAKEHOLDER-001']);
+    });
+    it('flags a wrong notation tag', () => {
+        expect(codes({ ...valid(), notation: 'stake' })).toContain('STAKEHOLDER-001');
+    });
+    it('flags an id with the wrong TYPE prefix', () => {
+        expect(codes({ ...valid(), id: 'ACTOR-DPA-1' })).toContain('STAKEHOLDER-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 type outside internal/external', () => {
+        expect(codes({ ...valid(), type: 'regulator' })).toContain('STAKEHOLDER-002');
+    });
+    it('accepts both internal and external', () => {
+        for (const t of ['internal', 'external']) {
+            expect(validateStakeholder({ ...valid(), type: t }).valid).toBe(true);
+        }
+    });
+});
+describe('validateStakeholder — STAKEHOLDER-003 (actor binding)', () => {
+    it('flags a missing actor', () => {
+        const r = valid();
+        delete r.actor;
+        expect(codes(r)).toContain('STAKEHOLDER-003');
+    });
+    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');
+    });
+});
+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 influence outside high/medium/low', () => {
+        expect(codes({ ...valid(), influence: 'extreme' })).toContain('STAKEHOLDER-004');
+    });
+    it('accepts each permitted level', () => {
+        for (const l of ['high', 'medium', 'low']) {
+            expect(validateStakeholder({ ...valid(), interest: l, influence: l }).valid).toBe(true);
+        }
+    });
+});

package/dist/stakeholder/index.d.ts

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

package/dist/stakeholder/index.js

@@ -0,0 +1,2 @@
+export { STAKEHOLDER_TYPES, STAKEHOLDER_LEVELS } from './types.js';
+export { validateStakeholder } from './validate.js';

package/dist/stakeholder/types.d.ts

@@ -0,0 +1,24 @@
+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 declare const STAKEHOLDER_LEVELS: readonly ["high", "medium", "low"];
+export interface Stakeholder {
+    notation: 'stakeholder';
+    id: string;
+    name: string;
+    /** Required subtype — internal | external. */
+    type: StakeholderType;
+    /** Required ACTOR-… typed id — identity binding (never inline). */
+    actor: string;
+    concern?: string;
+    interest?: StakeholderLevel;
+    influence?: StakeholderLevel;
+    description?: string;
+    zone: 'canon';
+    admitted_at: string;
+    admitted_by: string;
+    gate_checks: GateChecks;
+    valid_from: string;
+    valid_to: string | null;
+}

package/dist/stakeholder/types.js

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

package/dist/stakeholder/validate.d.ts

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

package/dist/stakeholder/validate.js

@@ -0,0 +1,58 @@
+// STAKEHOLDER validator — methodology notations/ELEMENT_PRIMITIVES.md §7.15
+// + notations/elements/20-stakeholders.md.
+//
+// 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) {
+    const errors = [];
+    const warnings = [];
+    const { record, errors: envErrors } = validateElementEnvelope(input, {
+        notation: 'stakeholder',
+        idType: 'STAKEHOLDER',
+        code: 'STAKEHOLDER-001',
+    });
+    errors.push(...envErrors);
+    if (!record)
+        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,
+            });
+        }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}

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

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

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

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import { validateTargetState } from '../validate.js';
+function valid() {
+    return {
+        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.',
+        capabilities: ['CAPABILITY-V1', 'CAPABILITY-V1.2', 'CAPABILITY-V2'],
+        processes: ['PROCESS-CUST-ONBOARD-1', 'PROCESS-ORD-FULFILL-1'],
+        applications: ['APPLICATION-CRM-1', 'APPLICATION-OMS-1'],
+        zone: 'canon',
+        admitted_at: '2026-05-31',
+        admitted_by: 'v.korobeinikov',
+        gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
+        valid_from: '2026-05-31',
+        valid_to: null,
+    };
+}
+const codes = (input) => validateTargetState(input).errors.map(e => e.code);
+describe('validateTargetState — positive', () => {
+    it('accepts the worked-example TARGET_STATE-EU-LIVE-1', () => {
+        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);
+    });
+});
+describe('validateTargetState — TARGET_STATE-001 (envelope / shape)', () => {
+    it('flags a non-object', () => {
+        expect(codes(null)).toEqual(['TARGET_STATE-001']);
+    });
+    it('flags a wrong notation tag', () => {
+        expect(codes({ ...valid(), notation: 'plateau' })).toContain('TARGET_STATE-001');
+    });
+    it('flags an id with the wrong TYPE prefix', () => {
+        expect(codes({ ...valid(), id: 'SCENARIO-EU-LIVE-1' })).toContain('TARGET_STATE-001');
+    });
+    it('flags an inline goals field (it belongs on a REL)', () => {
+        expect(codes({ ...valid(), goals: ['GOAL-EU-1'] })).toContain('TARGET_STATE-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');
+    });
+    it('flags a non-PROCESS id in processes', () => {
+        expect(codes({ ...valid(), processes: ['CAPABILITY-V1'] })).toContain('TARGET_STATE-002');
+    });
+    it('flags a non-APPLICATION id in applications', () => {
+        expect(codes({ ...valid(), applications: ['PRODUCT-X-1'] })).toContain('TARGET_STATE-002');
+    });
+    it('flags a composition field that is not an array', () => {
+        expect(codes({ ...valid(), capabilities: 'CAPABILITY-V1' })).toContain('TARGET_STATE-002');
+    });
+});

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

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

package/dist/target-state/index.js

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

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

@@ -0,0 +1,18 @@
+import type { GateChecks } from '../requirement/types.js';
+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[];
+    description?: string;
+    link?: string;
+    zone: 'canon';
+    admitted_at: string;
+    admitted_by: string;
+    gate_checks: GateChecks;
+    valid_from: string;
+    valid_to: string | null;
+}

package/dist/target-state/types.js

@@ -0,0 +1,7 @@
+// 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 {};

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

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

package/dist/target-state/validate.js

@@ -0,0 +1,61 @@
+// TARGET_STATE validator — methodology notations/ELEMENT_PRIMITIVES.md §7.17.
+//
+// Implements TARGET_STATE-001..002. Goal-satisfaction lives on the
+// `target_state_satisfies_goal` REL kind (elements/17-relations.md §3) and is
+// never inline here; a `goals:` field on a TARGET_STATE is flagged.
+import { typeOfId } from '../typed-id.js';
+import { validateElementEnvelope } from '../element-envelope.js';
+/** Composition fields and the TYPE each entry must carry. */
+const COMPOSITION_TYPES = {
+    capabilities: 'CAPABILITY',
+    processes: 'PROCESS',
+    applications: 'APPLICATION',
+};
+export function validateTargetState(input) {
+    const errors = [];
+    const warnings = [];
+    const { record, errors: envErrors } = validateElementEnvelope(input, {
+        notation: 'target-state',
+        idType: 'TARGET_STATE',
+        code: 'TARGET_STATE-001',
+    });
+    errors.push(...envErrors);
+    if (!record)
+        return { valid: false, errors, warnings };
+    // TARGET_STATE-002 — composition entries must carry the right TYPE prefix.
+    for (const [field, expectedType] of Object.entries(COMPOSITION_TYPES)) {
+        const value = record[field];
+        if (value === undefined)
+            continue;
+        if (!Array.isArray(value)) {
+            errors.push({
+                code: 'TARGET_STATE-002',
+                message: `${field} must be a list of ${expectedType} typed IDs.`,
+                path: field,
+            });
+            continue;
+        }
+        value.forEach((ref, i) => {
+            // CAPABILITY uses a V/H terminal (e.g. CAPABILITY-V1.2) rather than a
+            // plain integer; the prefix-TYPE gate is what this validator enforces,
+            // and the V/H grammar is owned by the capability-map module.
+            if (typeOfId(ref) !== expectedType) {
+                errors.push({
+                    code: 'TARGET_STATE-002',
+                    message: `${field}[${i}] "${String(ref)}" must be a ${expectedType} typed ID.`,
+                    path: `${field}[${i}]`,
+                });
+            }
+        });
+    }
+    // TARGET_STATE-001 — `goals:` is not an inline field on this element. Goal
+    // satisfaction is a target_state_satisfies_goal REL (§7.17).
+    if ('goals' in record) {
+        errors.push({
+            code: 'TARGET_STATE-001',
+            message: 'goals is not an inline field on TARGET_STATE — use a target_state_satisfies_goal REL.',
+            path: 'goals',
+        });
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}

package/dist/theme/index.d.ts

@@ -0,0 +1,4 @@
+export type { AdaptiveTokens } from './tokens.js';
+export { BRAND, FUNCTIONAL, LAYER_COLORS, LEVEL_COLORS, MATURITY_COLORS, STRUCTURAL, TYPOGRAPHY, CSS_VAR, getBaseResetCss } from './tokens.js';
+export type { ThemeId } from './themes.js';
+export { generateWebviewCss, generateSvgEmbedCss } from './themes.js';

package/dist/theme/index.js

@@ -0,0 +1,2 @@
+export { BRAND, FUNCTIONAL, LAYER_COLORS, LEVEL_COLORS, MATURITY_COLORS, STRUCTURAL, TYPOGRAPHY, CSS_VAR, getBaseResetCss } from './tokens.js';
+export { generateWebviewCss, generateSvgEmbedCss } from './themes.js';

package/dist/theme/themes.d.ts

@@ -0,0 +1,16 @@
+export type ThemeId = 'transitrix' | 'transitrix-dark' | 'vscode-adaptive';
+/**
+ * Generates a self-contained CSS block for embedding inside a standalone SVG file.
+ * Defines all --ts-* custom properties on :root so diagram classes resolve correctly
+ * when the SVG is opened outside of VS Code.
+ * vscode-adaptive falls back to the light palette (runtime VS Code variables are unavailable).
+ */
+export declare function generateSvgEmbedCss(themeId: ThemeId): string;
+/**
+ * Generates complete CSS for a static SVG diagram webview.
+ *
+ * For transitrix/transitrix-dark: sets --ts-* vars with fixed brand colors.
+ * For vscode-adaptive: maps --ts-* vars to --vscode-* CSS vars, with
+ * body.vscode-dark / body.vscode-high-contrast overrides for diagram colors.
+ */
+export declare function generateWebviewCss(themeId: ThemeId): string;