@transitrix/diagrams 1.0.0

package/src/process-blueprint/types.ts

@@ -0,0 +1,242 @@
+export type AspectCategory = 'systems' | 'actors' | 'equipment' | 'information_entities';
+
+// ── Compliance lane types ────────────────────────────────────────────────────
+
+/**
+ * One of the three orthogonal decoration signals that can appear on a compliance
+ * law chip (ADR 2026-06-09-compliance-impact-as-blueprint-lane §3):
+ * - `new`      — law's impact on this stage appeared since the previous snapshot
+ * - `gap`      — a bound assertion has status `non_compliant` or `partial`
+ * - `deadline` — gap is present AND the requirement carries a deadline that is
+ *                past, imminent, or in-force
+ */
+export type ComplianceDecoration = 'new' | 'gap' | 'deadline';
+
+/** Input shape for a requirement — minimal projection the compliance lane needs. */
+export interface ComplianceLaneRequirement {
+  id: string;
+  /** Typed IDs of codex sources (law IDs displayed as chips). */
+  derived_from?: string[];
+  /**
+   * ISO 8601 compliance deadline on the external regulatory source.
+   * Used to compute the `deadline` decoration.
+   */
+  deadline?: string;
+}
+
+/** Input shape for an assertion — minimal projection the compliance lane needs. */
+export interface ComplianceLaneAssertion {
+  /** Requirement ID this assertion is about. */
+  about: string;
+  /** Compliance realisation status. */
+  status: 'compliant' | 'partial' | 'non_compliant' | 'under_review' | '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.
+   */
+  realised_via?: string[];
+}
+
+/**
+ * Input data for the compliance lane derivation.
+ * Passed via `ProcessBlueprintLayoutOptions.complianceInput`.
+ */
+export interface ComplianceLaneInput {
+  assertions: ComplianceLaneAssertion[];
+  requirements: ComplianceLaneRequirement[];
+  /**
+   * Codex jurisdiction map: codexId → jurisdiction code.
+   * Required only when `ComplianceLaneConfig.jurisdictions` is non-empty.
+   */
+  codexJurisdictions?: Record<string, string>;
+}
+
+/**
+ * Runtime configuration for the compliance lane.
+ * Passed via `ProcessBlueprintLayoutOptions.complianceLane`.
+ */
+export interface ComplianceLaneConfig {
+  /** When false (default), the compliance lane is not rendered. */
+  enabled: boolean;
+  /**
+   * Jurisdiction filter: if non-empty, only show laws whose codex jurisdiction
+   * is in this list. Requires `ComplianceLaneInput.codexJurisdictions`.
+   */
+  jurisdictions?: string[];
+  /**
+   * Per-stage map of law IDs known from the previous generated snapshot.
+   * Key: stage ID; Value: array of law IDs.
+   * A law not present in the previous snapshot is decorated as `new`.
+   */
+  previousSnapshot?: Record<string, string[]>;
+  /**
+   * Reference date for deadline-status computation (YYYY-MM-DD).
+   * Defaults to today when not supplied.
+   */
+  referenceDate?: string;
+}
+
+/** One law chip rendered inside a compliance cell. */
+export interface ComplianceChip {
+  stageIndex: number;
+  /** Codex / law ID shown as the chip label. */
+  lawId: string;
+  /** Active decorations — a subset of the three orthogonal signals. */
+  decorations: ComplianceDecoration[];
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+/** Laid-out compliance row (one per blueprint when the lane is enabled). */
+export interface ComplianceRow {
+  y: number;
+  height: number;
+  chips: ComplianceChip[];
+}
+
+export interface Stage {
+  id: string;
+  name: string;
+  goal: string;
+  result: string;
+  description?: string;
+}
+
+export interface AspectEntry {
+  id?: string;
+  name: string;
+  stages: string[];
+  description?: string;
+}
+
+/** Rendering-config block that selects which lanes are visible (spec §5 `lane_config:`). */
+export interface LaneConfig {
+  /** Enable the derived compliance lane. Default: false. */
+  compliance?: boolean;
+  compliance_filter?: {
+    /** ISO jurisdiction codes; empty array means all jurisdictions. */
+    jurisdictions?: string[];
+  };
+}
+
+export interface ProcessBlueprintHeader {
+  id: string;
+  name: string;
+  description?: string;
+  period?: string;
+  version?: string;
+  date?: string;
+  author?: string;
+  process?: string;
+  scenario?: string;
+  stages: Stage[];
+  systems?: AspectEntry[];
+  actors?: AspectEntry[];
+  equipment?: AspectEntry[];
+  information_entities?: AspectEntry[];
+  /** Optional rendering config selecting which lanes to show. */
+  lane_config?: LaneConfig;
+}
+
+export interface ProcessBlueprintFile {
+  notation: string;
+  spec_version?: string;
+  process_blueprint: ProcessBlueprintHeader;
+}
+
+export interface ProcessBlueprintLayoutOptions {
+  legendColumnWidth?: number;
+  stageColumnWidth?: number;
+  stageHeaderHeight?: number;
+  goalRowHeight?: number;
+  resultRowHeight?: number;
+  aspectRowMinHeight?: number;
+  pillHeight?: number;
+  pillGap?: number;
+  cellPadding?: number;
+  /** Vertical advance between wrapped text lines in goal/result cells (px). */
+  textLineHeight?: number;
+  /** Approximate glyph width used to estimate wrap width (px per char). */
+  textCharWidth?: number;
+  /** Horizontal text inset inside goal/result cells (px, both sides). */
+  cellTextPadX?: number;
+  /** Top+bottom padding added around wrapped goal/result text (px). */
+  cellTextPadY?: number;
+  /** Maximum wrapped lines per goal/result cell before truncating with an ellipsis. */
+  maxTextLines?: number;
+  /** Enable and configure the derived compliance lane. Default: disabled. */
+  complianceLane?: ComplianceLaneConfig;
+  /** Assertion + requirement data for the compliance lane derivation. */
+  complianceInput?: ComplianceLaneInput;
+}
+
+import type { LayoutBounds } from '../geometry.js';
+export type { LayoutBounds };
+
+export interface LegendCell {
+  kind: 'goal' | 'result' | 'aspect' | 'compliance';
+  category?: AspectCategory;
+  label: string;
+  y: number;
+  height: number;
+}
+
+export interface StageHeaderCell {
+  stageIndex: number;
+  id: string;
+  name: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface StageTextCell {
+  stageIndex: number;
+  text: string;
+  /** Word-wrapped lines of `text`, pre-fitted to the cell width by the layout. */
+  lines: string[];
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface AspectPill {
+  category: AspectCategory;
+  entryIndex: number;
+  name: string;
+  id?: string;
+  startStageIndex: number;
+  endStageIndex: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface AspectRow {
+  category: AspectCategory;
+  y: number;
+  height: number;
+  pills: AspectPill[];
+}
+
+export interface ProcessBlueprintLayout {
+  bounds: LayoutBounds;
+  legendColumnWidth: number;
+  stageColumnWidth: number;
+  /** Vertical advance between wrapped text lines, so renderers stack tspans consistently. */
+  textLineHeight: number;
+  /** Horizontal text inset used for goal/result cells (px). */
+  cellTextPadX: number;
+  legend: LegendCell[];
+  stageHeaders: StageHeaderCell[];
+  goalCells: StageTextCell[];
+  resultCells: StageTextCell[];
+  aspectRows: AspectRow[];
+  /** Compliance lane row — present only when the lane is enabled and has data. */
+  complianceRow?: ComplianceRow;
+}

package/src/process-blueprint/validate.ts

@@ -0,0 +1,181 @@
+import type { AspectCategory } from './types.js';
+import type { ValidationError, ValidationWarning, ValidationResult } from '../validation-types.js';
+
+export type { ValidationError, ValidationWarning, ValidationResult };
+
+const ID_GRAMMAR_RE = /^[A-Z][A-Z_]*(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+const PROCESS_BLUEPRINT_ID_RE = /^PROCESS_BLUEPRINT(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+const STAGE_ID_RE = /^STAGE(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+const APPLICATION_ID_RE = /^APPLICATION(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+const ROLE_ID_RE = /^ROLE(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+
+const ASPECT_CATEGORIES: AspectCategory[] = ['systems', 'actors', 'equipment', 'information_entities'];
+
+function isNonEmptyString(v: unknown): v is string {
+  return typeof v === 'string' && v.trim().length > 0;
+}
+
+export function validateProcessBlueprint(input: unknown): ValidationResult {
+  const errors: ValidationError[] = [];
+  const warnings: ValidationWarning[] = [];
+
+  if (!input || typeof input !== 'object') {
+    return {
+      valid: false,
+      errors: [{ code: 'BP-001', message: 'Input must be an object' }],
+      warnings,
+    };
+  }
+
+  const raw = input as Record<string, unknown>;
+
+  if ('notation' in raw && raw['notation'] !== 'process-blueprint') {
+    errors.push({
+      code: 'BP-001',
+      message: `notation must be "process-blueprint", got "${String(raw['notation'])}"`,
+    });
+  }
+
+  if (!('process_blueprint' in raw) || !raw['process_blueprint'] || typeof raw['process_blueprint'] !== 'object') {
+    errors.push({ code: 'BP-001', message: 'Missing required root key: process_blueprint' });
+    return { valid: false, errors, warnings };
+  }
+
+  const pb = raw['process_blueprint'] as Record<string, unknown>;
+
+  if (!isNonEmptyString(pb['id'])) {
+    errors.push({ code: 'BP-002', message: 'process_blueprint.id is required' });
+  } else if (!PROCESS_BLUEPRINT_ID_RE.test(pb['id'])) {
+    errors.push({
+      code: 'BP-002',
+      message: `process_blueprint.id "${pb['id']}" must match PROCESS_BLUEPRINT-[<middle>-]<INTEGER>`,
+    });
+  }
+
+  if (!isNonEmptyString(pb['name'])) {
+    errors.push({ code: 'BP-003', message: 'process_blueprint.name is required' });
+  }
+
+  const stagesRaw = pb['stages'];
+  if (!Array.isArray(stagesRaw) || stagesRaw.length === 0) {
+    errors.push({ code: 'BP-004', message: 'process_blueprint.stages must be a non-empty array' });
+    return { valid: false, errors, warnings };
+  }
+
+  const stageIds = new Set<string>();
+  for (let i = 0; i < stagesRaw.length; i++) {
+    const s = stagesRaw[i] as Record<string, unknown> | undefined;
+    const path = `stages[${i}]`;
+    if (!s || typeof s !== 'object') {
+      errors.push({ code: 'BP-005', message: `${path} must be an object` });
+      continue;
+    }
+    if (!isNonEmptyString(s['id'])) {
+      errors.push({ code: 'BP-005', message: `${path}.id is required` });
+    } else {
+      const sid = s['id'].trim();
+      if (stageIds.has(sid)) {
+        errors.push({ code: 'BP-006', message: `Duplicate stage id: "${sid}"` });
+      } else {
+        stageIds.add(sid);
+      }
+      if (!STAGE_ID_RE.test(sid)) {
+        errors.push({
+          code: 'BP-006',
+          message: `${path}.id "${sid}" must match STAGE-[<middle>-]<INTEGER>`,
+        });
+      }
+    }
+    if (!isNonEmptyString(s['name'])) {
+      errors.push({ code: 'BP-005', message: `${path}.name is required` });
+    }
+    if (!isNonEmptyString(s['goal'])) {
+      errors.push({ code: 'BP-005', message: `${path}.goal is required` });
+    }
+    if (!isNonEmptyString(s['result'])) {
+      errors.push({ code: 'BP-005', message: `${path}.result is required` });
+    }
+  }
+
+  const usedStageIds = new Set<string>();
+
+  for (const category of ASPECT_CATEGORIES) {
+    const arr = pb[category];
+    if (arr === undefined) continue;
+    if (!Array.isArray(arr)) {
+      errors.push({ code: 'BP-007', message: `process_blueprint.${category} must be an array` });
+      continue;
+    }
+
+    for (let i = 0; i < arr.length; i++) {
+      const e = arr[i] as Record<string, unknown> | undefined;
+      const path = `${category}[${i}]`;
+      if (!e || typeof e !== 'object') {
+        errors.push({ code: 'BP-007', message: `${path} must be an object` });
+        continue;
+      }
+
+      if (!isNonEmptyString(e['name'])) {
+        errors.push({ code: 'BP-007', message: `${path}.name is required` });
+      }
+
+      const entryStages = e['stages'];
+      if (!Array.isArray(entryStages) || entryStages.length === 0) {
+        errors.push({
+          code: 'BP-007',
+          message: `${path}.stages must be a non-empty array of STAGE-… ids`,
+        });
+      } else {
+        for (let j = 0; j < entryStages.length; j++) {
+          const ref = entryStages[j];
+          if (typeof ref !== 'string') {
+            errors.push({ code: 'BP-008', message: `${path}.stages[${j}] must be a string` });
+            continue;
+          }
+          const refTrimmed = ref.trim();
+          if (!stageIds.has(refTrimmed)) {
+            errors.push({
+              code: 'BP-008',
+              message: `${path}.stages[${j}] references undeclared stage "${ref}"`,
+            });
+          } else {
+            usedStageIds.add(refTrimmed);
+          }
+        }
+      }
+
+      const entryId = e['id'];
+      if (entryId !== undefined) {
+        if (typeof entryId !== 'string') {
+          errors.push({ code: 'BP-009', message: `${path}.id must be a string` });
+        } else if (!ID_GRAMMAR_RE.test(entryId)) {
+          errors.push({
+            code: 'BP-009',
+            message: `${path}.id "${entryId}" must match <TYPE>-[<middle>-]<INTEGER>`,
+          });
+        } else if (category === 'systems' && !APPLICATION_ID_RE.test(entryId)) {
+          errors.push({
+            code: 'BP-010',
+            message: `${path}.id "${entryId}" must use the APPLICATION- prefix`,
+          });
+        } else if (category === 'actors' && !ROLE_ID_RE.test(entryId)) {
+          errors.push({
+            code: 'BP-010',
+            message: `${path}.id "${entryId}" must use the ROLE- prefix`,
+          });
+        }
+      }
+    }
+  }
+
+  for (const sid of stageIds) {
+    if (!usedStageIds.has(sid)) {
+      warnings.push({
+        code: 'BP-011',
+        message: `Stage "${sid}" has no aspect entries pointing at it — structurally empty`,
+      });
+    }
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}

package/src/process-map/__tests__/validate.test.ts

@@ -0,0 +1,223 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import yaml from 'js-yaml';
+import { validateProcessMap } from '../validate.js';
+
+const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'process-map');
+
+const VALID_MAP = {
+  notation: 'process-map',
+  process_map: {
+    id: 'PM-ENT-001',
+    name: 'Enterprise Process Landscape',
+    updated_at: '2026-05-08',
+    groups: [
+      {
+        id: 'GRP-OPERATING',
+        name: 'Operating Processes',
+        type: 'operating',
+        processes: [
+          { process_id: 'PROC-ORD-FULFILL-001', name: 'Order Fulfilment', status: 'Active', maturity: 2 },
+          { process_id: 'PROC-CUST-ONBOARD-001', name: 'Customer Onboarding', status: 'Draft' },
+        ],
+      },
+      {
+        id: 'GRP-SUPPORTING',
+        name: 'Supporting Processes',
+        type: 'supporting',
+        processes: [
+          { process_id: 'PROC-HR-RECRUIT-001', name: 'Recruitment', status: 'Active' },
+        ],
+      },
+    ],
+  },
+};
+
+describe('validateProcessMap', () => {
+  it('passes on valid input', () => {
+    const r = validateProcessMap(VALID_MAP);
+    expect(r.valid).toBe(true);
+    expect(r.errors).toHaveLength(0);
+  });
+
+  it('PMAP-001: rejects non-object input', () => {
+    const r = validateProcessMap(null);
+    expect(r.valid).toBe(false);
+    expect(r.errors[0].code).toBe('PMAP-001');
+  });
+
+  it('PMAP-001: rejects missing notation', () => {
+    const { notation: _, ...rest } = VALID_MAP;
+    const r = validateProcessMap(rest);
+    expect(r.errors.some(e => e.code === 'PMAP-001')).toBe(true);
+  });
+
+  it('PMAP-001: rejects wrong notation value', () => {
+    const r = validateProcessMap({ ...VALID_MAP, notation: 'goals' });
+    expect(r.errors.some(e => e.code === 'PMAP-001')).toBe(true);
+  });
+
+  it('PMAP-002: rejects missing process_map', () => {
+    const r = validateProcessMap({ notation: 'process-map' });
+    expect(r.errors.some(e => e.code === 'PMAP-002')).toBe(true);
+  });
+
+  it('PMAP-002: rejects missing id/name/updated_at', () => {
+    const r = validateProcessMap({ notation: 'process-map', process_map: { groups: [] } });
+    expect(r.errors.filter(e => e.code === 'PMAP-002').length).toBeGreaterThanOrEqual(3);
+  });
+
+  it('PMAP-002: rejects non-array groups', () => {
+    const map = { ...VALID_MAP.process_map, groups: 'oops' };
+    const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+    expect(r.errors.some(e => e.code === 'PMAP-002')).toBe(true);
+  });
+
+  it('PMAP-003: rejects group missing id/name/type', () => {
+    const map = { ...VALID_MAP.process_map, groups: [{ processes: [] }] };
+    const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+    expect(r.errors.filter(e => e.code === 'PMAP-003').length).toBeGreaterThanOrEqual(3);
+  });
+
+  it('PMAP-004: rejects invalid group type', () => {
+    const map = {
+      ...VALID_MAP.process_map,
+      groups: [{ id: 'g1', name: 'X', type: 'random', processes: [] }],
+    };
+    const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+    expect(r.errors.some(e => e.code === 'PMAP-004')).toBe(true);
+  });
+
+  it('PMAP-004: accepts all valid group types', () => {
+    for (const type of ['operating', 'supporting', 'management']) {
+      const map = {
+        ...VALID_MAP.process_map,
+        groups: [{ id: 'g1', name: 'X', type, processes: [] }],
+      };
+      const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+      expect(r.errors.some(e => e.code === 'PMAP-004')).toBe(false);
+    }
+  });
+
+  it('PMAP-005: rejects process missing process_id/name/status', () => {
+    const map = {
+      ...VALID_MAP.process_map,
+      groups: [{ id: 'g1', name: 'G', type: 'operating', processes: [{}] }],
+    };
+    const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+    expect(r.errors.filter(e => e.code === 'PMAP-005').length).toBeGreaterThanOrEqual(3);
+  });
+
+  it('PMAP-006: rejects invalid status', () => {
+    const map = {
+      ...VALID_MAP.process_map,
+      groups: [{ id: 'g1', name: 'G', type: 'operating', processes: [
+        { process_id: 'p1', name: 'X', status: 'Retired' },
+      ]}],
+    };
+    const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+    expect(r.errors.some(e => e.code === 'PMAP-006')).toBe(true);
+  });
+
+  it('PMAP-007: rejects out-of-range maturity', () => {
+    const map = {
+      ...VALID_MAP.process_map,
+      groups: [{ id: 'g1', name: 'G', type: 'operating', processes: [
+        { process_id: 'p1', name: 'X', status: 'Active', maturity: 6 },
+      ]}],
+    };
+    const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+    expect(r.errors.some(e => e.code === 'PMAP-007')).toBe(true);
+  });
+
+  it('PMAP-007: accepts maturity 1-5', () => {
+    for (const maturity of [1, 2, 3, 4, 5]) {
+      const map = {
+        ...VALID_MAP.process_map,
+        groups: [{ id: 'g1', name: 'G', type: 'operating', processes: [
+          { process_id: 'p1', name: 'X', status: 'Active', maturity },
+        ]}],
+      };
+      const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+      expect(r.errors.some(e => e.code === 'PMAP-007')).toBe(false);
+    }
+  });
+
+  it('PMAP-008: rejects malformed updated_at', () => {
+    const map = { ...VALID_MAP.process_map, updated_at: '13-05-2026' };
+    const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+    expect(r.errors.some(e => e.code === 'PMAP-008')).toBe(true);
+  });
+
+  it('PMAP-009: rejects duplicate process_id across groups', () => {
+    const map = {
+      ...VALID_MAP.process_map,
+      groups: [
+        { id: 'g1', name: 'A', type: 'operating', processes: [{ process_id: 'P1', name: 'X', status: 'Active' }] },
+        { id: 'g2', name: 'B', type: 'supporting', processes: [{ process_id: 'P1', name: 'Y', status: 'Active' }] },
+      ],
+    };
+    const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+    expect(r.errors.some(e => e.code === 'PMAP-009')).toBe(true);
+  });
+
+  it('PMAP-010: rejects duplicate group id', () => {
+    const map = {
+      ...VALID_MAP.process_map,
+      groups: [
+        { id: 'gdup', name: 'A', type: 'operating', processes: [] },
+        { id: 'gdup', name: 'B', type: 'supporting', processes: [] },
+      ],
+    };
+    const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+    expect(r.errors.some(e => e.code === 'PMAP-010')).toBe(true);
+  });
+
+  it('accepts empty groups array', () => {
+    const map = { ...VALID_MAP.process_map, groups: [] };
+    const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+    expect(r.valid).toBe(true);
+  });
+
+  it('accepts group with no processes field', () => {
+    const map = {
+      ...VALID_MAP.process_map,
+      groups: [{ id: 'g1', name: 'G', type: 'operating' }],
+    };
+    const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+    expect(r.valid).toBe(true);
+  });
+
+  // Pre-release blocker regression (orchestrator review 2026-05-21).
+  it('[blocker] tolerates a null element in groups[] without throwing', () => {
+    const map = { ...VALID_MAP.process_map, groups: [null] };
+    const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+    expect(r.valid).toBe(false);
+    expect(r.errors.some(e => e.code === 'PMAP-003')).toBe(true);
+  });
+
+  it('[blocker] tolerates a null element in processes[] without throwing', () => {
+    const map = {
+      ...VALID_MAP.process_map,
+      groups: [{ id: 'g1', name: 'G', type: 'operating', processes: [null] }],
+    };
+    const r = validateProcessMap({ ...VALID_MAP, process_map: map });
+    expect(r.valid).toBe(false);
+    expect(r.errors.some(e => e.code === 'PMAP-005')).toBe(true);
+  });
+});
+
+describe('process-map examples (regression)', () => {
+  const files = fs.readdirSync(EXAMPLES_DIR).filter(f => f.endsWith('.yaml'));
+  expect(files.length).toBeGreaterThan(0);
+  for (const file of files) {
+    it(`validates tests/fixtures/notation-corpus/process-map/${file}`, () => {
+      const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
+      const parsed = yaml.load(text);
+      const r = validateProcessMap(parsed);
+      expect(r.errors).toEqual([]);
+      expect(r.valid).toBe(true);
+    });
+  }
+});

package/src/process-map/index.ts

@@ -0,0 +1,10 @@
+export type {
+  ProcessGroupType,
+  ProcessStatus,
+  MapProcess,
+  ProcessGroup,
+  ProcessMapHeader,
+  ProcessMapFile,
+} from './types.js';
+
+export { validateProcessMap } from './validate.js';

package/src/process-map/types.ts

@@ -0,0 +1,36 @@
+export type ProcessGroupType = 'operating' | 'supporting' | 'management';
+export type ProcessStatus = 'Draft' | 'Active' | 'Deprecated';
+
+export interface MapProcess {
+  process_id: string;
+  name: string;
+  status: ProcessStatus;
+  owner_role?: string;
+  capability?: string;
+  maturity?: number;
+  bpmn_file?: string;
+  description?: string;
+}
+
+export interface ProcessGroup {
+  id: string;
+  name: string;
+  type: ProcessGroupType;
+  description?: string;
+  processes: MapProcess[];
+}
+
+export interface ProcessMapHeader {
+  id: string;
+  name: string;
+  description?: string;
+  version?: string;
+  updated_at: string;
+  groups: ProcessGroup[];
+}
+
+export interface ProcessMapFile {
+  notation: string;
+  spec_version?: string;
+  process_map: ProcessMapHeader;
+}