@qontinui/shared-types 0.2.4 → 0.3.0

package/dist/ui-bridge-ir.d.ts

@@ -22,6 +22,14 @@ interface IRProvenance {
     column?: number;
     /** Build-plugin version that produced this node, if applicable. */
     pluginVersion?: string;
+    /**
+     * Lifecycle status for the Stream E coverage-growth flywheel. Absent =
+     * implicitly `"promoted"` (legacy + on-disk specs that predate the field).
+     * Set to `"proposed"` by `spec_authoring`, `"pending"` when staged in
+     * `_pending/`, `"promoted"` after the 2-green sweep moves the file to
+     * `pages/<id>/`.
+     */
+    status?: "proposed" | "pending" | "promoted";
 }
 /**
  * Human-authored semantic context for an IR node. Aligns with the existing
@@ -129,6 +137,88 @@ interface IRElementCriteria {
     attributes?: Record<string, string>;
 }
 
+/**
+ * IR-side group + assertion types.
+ *
+ * The IR's primary authoring surface is `states + transitions`, which the
+ * projection maps into legacy `groups[]` (one group per state). However, the
+ * runner's `workflow_generation::spec_synthesis` pipeline produces "free-form"
+ * groups from acceptance criteria — these are NOT tied to any state and
+ * therefore have no home in the state-derived projection path.
+ *
+ * `IRGroup` is the dedicated channel for those synthesized groups. The IR
+ * carries them in the optional `IRDocument.synthesizedGroups` field; the
+ * projection appends them after the state-derived groups, in declared order,
+ * to preserve byte-stable output.
+ *
+ * The shape mirrors the legacy `SpecGroup` / `SpecAssertion` (canonical
+ * definitions live in `@qontinui/ui-bridge/specs`), but is re-defined here to
+ * keep `qontinui-schemas/ts` free of any runtime dep on `@qontinui/ui-bridge/*`
+ * (per the schemas package's "zero ui-bridge deps" policy).
+ *
+ * Note on field shape: the IR-side `IRAssertion` keeps the legacy assertion's
+ * field types as loose as the synthesis path emits them. Strict consumers
+ * (e.g. the canonical `SpecAssertion` in `@qontinui/ui-bridge/specs`) can
+ * narrow as needed at the consumer boundary; the projection preserves the
+ * objects verbatim into the legacy output.
+ */
+/**
+ * IR-side assertion target. Always `type: "search"` for synthesis-emitted
+ * assertions; the wider legacy schema also supports point/region targets but
+ * the IR doesn't express those today.
+ */
+interface IRAssertionTarget {
+    /** Always `"search"` for synthesis-emitted assertions. */
+    type: string;
+    /**
+     * Free-form criteria object. Kept as a loose record so synthesis can emit
+     * partially-populated criteria without tripping the schema.
+     */
+    criteria: Record<string, unknown>;
+    label: string;
+}
+/**
+ * IR-side assertion. Mirrors the legacy `SpecAssertion` shape.
+ */
+interface IRAssertion {
+    id: string;
+    description: string;
+    category: string;
+    severity: string;
+    assertionType: string;
+    target: IRAssertionTarget;
+    source: string;
+    reviewed: boolean;
+    enabled: boolean;
+    /**
+     * Optional human-readable precondition. Synthesis populates this from the
+     * acceptance criterion's verification hint.
+     */
+    precondition?: string;
+}
+/**
+ * IR-side group produced by workflow-criteria synthesis (i.e. NOT derived
+ * from `IRState` annotations). Mirrors the legacy `SpecGroup` shape one-to-one
+ * so the projection can pass it through to legacy `groups[]` without loss.
+ */
+interface IRGroup {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    assertions: IRAssertion[];
+    /**
+     * Provenance of the group itself (typically `"ai-generated"` for synthesis
+     * output, but kept open for future authoring channels).
+     */
+    source?: string;
+    /**
+     * Free-form tags. Synthesis emits e.g. `["workflow-generated",
+     * "acceptance-criteria"]` so downstream tooling can filter.
+     */
+    tags?: string[];
+}
+
 /**
  * IR-level state declaration.
  *
@@ -159,8 +249,14 @@ interface IRState {
     id: string;
     name: string;
     description?: string;
-    /** Element criteria that must ALL be satisfied for this state to be active. */
-    requiredElements: IRElementCriteria[];
+    /**
+     * State-scoped assertions. Each carries its own assertion_id, description,
+     * severity, category, and an IrElementCriteria target via target.criteria.
+     * Spec-Check (Plan 02) evaluates these against UI Bridge snapshots; policy
+     * filtering via `severity`/`category` is meaningful because each assertion
+     * carries its own metadata (no synthesized stubs).
+     */
+    assertions: IRAssertion[];
     /** Element criteria where NONE may be satisfied (any match disqualifies). */
     excludedElements?: IRElementCriteria[];
     /** Additional property checks on matched elements. */
@@ -281,88 +377,6 @@ interface IRTransition {
     crossRefs?: IRCrossRef[];
 }
 
-/**
- * IR-side group + assertion types.
- *
- * The IR's primary authoring surface is `states + transitions`, which the
- * projection maps into legacy `groups[]` (one group per state). However, the
- * runner's `workflow_generation::spec_synthesis` pipeline produces "free-form"
- * groups from acceptance criteria — these are NOT tied to any state and
- * therefore have no home in the state-derived projection path.
- *
- * `IRGroup` is the dedicated channel for those synthesized groups. The IR
- * carries them in the optional `IRDocument.synthesizedGroups` field; the
- * projection appends them after the state-derived groups, in declared order,
- * to preserve byte-stable output.
- *
- * The shape mirrors the legacy `SpecGroup` / `SpecAssertion` (canonical
- * definitions live in `@qontinui/ui-bridge/specs`), but is re-defined here to
- * keep `qontinui-schemas/ts` free of any runtime dep on `@qontinui/ui-bridge/*`
- * (per the schemas package's "zero ui-bridge deps" policy).
- *
- * Note on field shape: the IR-side `IRAssertion` keeps the legacy assertion's
- * field types as loose as the synthesis path emits them. Strict consumers
- * (e.g. the canonical `SpecAssertion` in `@qontinui/ui-bridge/specs`) can
- * narrow as needed at the consumer boundary; the projection preserves the
- * objects verbatim into the legacy output.
- */
-/**
- * IR-side assertion target. Always `type: "search"` for synthesis-emitted
- * assertions; the wider legacy schema also supports point/region targets but
- * the IR doesn't express those today.
- */
-interface IRAssertionTarget {
-    /** Always `"search"` for synthesis-emitted assertions. */
-    type: string;
-    /**
-     * Free-form criteria object. Kept as a loose record so synthesis can emit
-     * partially-populated criteria without tripping the schema.
-     */
-    criteria: Record<string, unknown>;
-    label: string;
-}
-/**
- * IR-side assertion. Mirrors the legacy `SpecAssertion` shape.
- */
-interface IRAssertion {
-    id: string;
-    description: string;
-    category: string;
-    severity: string;
-    assertionType: string;
-    target: IRAssertionTarget;
-    source: string;
-    reviewed: boolean;
-    enabled: boolean;
-    /**
-     * Optional human-readable precondition. Synthesis populates this from the
-     * acceptance criterion's verification hint.
-     */
-    precondition?: string;
-}
-/**
- * IR-side group produced by workflow-criteria synthesis (i.e. NOT derived
- * from `IRState` annotations). Mirrors the legacy `SpecGroup` shape one-to-one
- * so the projection can pass it through to legacy `groups[]` without loss.
- */
-interface IRGroup {
-    id: string;
-    name: string;
-    description: string;
-    category: string;
-    assertions: IRAssertion[];
-    /**
-     * Provenance of the group itself (typically `"ai-generated"` for synthesis
-     * output, but kept open for future authoring channels).
-     */
-    source?: string;
-    /**
-     * Free-form tags. Synthesis emits e.g. `["workflow-generated",
-     * "acceptance-criteria"]` so downstream tooling can filter.
-     */
-    tags?: string[];
-}
-
 /**
  * Top-level IR document.
  *

package/dist/ui-bridge-ir.js

@@ -4,7 +4,9 @@ function adaptIRState(state) {
   const out = {
     id: state.id,
     name: state.name,
-    requiredElements: state.requiredElements
+    requiredElements: state.assertions.map(
+      (a) => a.target.criteria
+    )
   };
   if (state.description !== void 0) out.description = state.description;
   if (state.excludedElements !== void 0) out.excludedElements = state.excludedElements;
@@ -108,34 +110,8 @@ function convertCriteria(criteria) {
   if (criteria.attributes !== void 0) out.dataAttributes = criteria.attributes;
   return out;
 }
-function buildAssertion(state, index, criteria) {
-  const description = state.metadata?.description ?? `Required element ${index} for state ${state.name}`;
-  const targetCriteria = convertCriteria(criteria);
-  const assertion = {
-    id: `${state.id}-elem-${index}`,
-    description,
-    category: "element-presence",
-    severity: "critical",
-    assertionType: "exists",
-    target: {
-      type: "search",
-      criteria: targetCriteria,
-      label: `Required element for ${state.name}`
-    },
-    source: "ai-generated",
-    reviewed: false,
-    enabled: true
-  };
-  if (state.precondition !== void 0) {
-    assertion.precondition = state.precondition;
-  }
-  return assertion;
-}
 function buildGroup(state) {
-  const elems = state.requiredElements ?? [];
-  const assertions = elems.map(
-    (c, i) => buildAssertion(state, i, c)
-  );
+  const assertions = state.assertions.map(synthesizedAssertionToLegacy);
   return {
     id: state.id,
     name: state.name,
@@ -206,7 +182,10 @@ function buildStateMachineState(state, transitions, doc) {
     id: state.id,
     name: state.name,
     description: state.description ?? "",
-    elements: (state.requiredElements ?? []).map(convertCriteria),
+    // Project legacy `elements[]` from each assertion's target.criteria.
+    elements: state.assertions.map(
+      (a) => convertCriteria(a.target.criteria)
+    ),
     isInitial,
     transitions: outgoing
   };
@@ -258,15 +237,33 @@ function firstPrecondition(group) {
   return void 0;
 }
 function buildIRState(group, smState) {
-  const requiredElements = group.assertions.map(
-    (a) => invertCriteria(a.target?.criteria)
-  );
+  const assertions = group.assertions.map((a) => {
+    const ir = {
+      id: a.id,
+      description: a.description,
+      category: a.category,
+      severity: a.severity,
+      assertionType: a.assertionType,
+      target: {
+        type: "search",
+        criteria: invertCriteria(a.target?.criteria),
+        label: a.target?.label ?? a.description
+      },
+      source: a.source,
+      reviewed: a.reviewed,
+      enabled: a.enabled
+    };
+    if (a.precondition !== void 0) {
+      ir.precondition = a.precondition;
+    }
+    return ir;
+  });
   const description = group.description !== void 0 && group.description.length > 0 ? group.description : smState?.description;
   const precondition = firstPrecondition(group);
   const state = {
     id: group.id,
     name: smState?.name ?? group.name,
-    requiredElements
+    assertions
   };
   if (description !== void 0 && description.length > 0) {
     state.description = description;

package/dist/ui-bridge-ir.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/ui-bridge-ir/adapter.ts","../src/ui-bridge-ir/projection.ts"],"sourcesContent":["/**\r\n * IR -> WorkflowConfig adapter.\r\n *\r\n * Single point of translation between authoring-time IR (with provenance,\r\n * metadata, effect, crossRefs, visualRefs) and the runtime/storage shape\r\n * that ui-bridge-auto consumes. See ADR-001 (decision #6 / #7) for the\r\n * boundary rationale.\r\n *\r\n * The output is intentionally typed structurally — this module has no\r\n * runtime dependency on ui-bridge-auto. ui-bridge-auto's own tests verify\r\n * end-to-end compatibility with `engine.defineStates(...)` /\r\n * `engine.defineTransitions(...)` (see\r\n * `ui-bridge-auto/src/__tests__/spike-ir-contract.test.ts`).\r\n */\r\n\r\nimport type { IRElementCriteria } from \"./element-criteria\";\r\nimport type { IRDocument } from \"./document\";\r\nimport type { IRState, IRStateCondition } from \"./state\";\r\nimport type { IRTransition, IRTransitionAction, IRWaitSpec } from \"./transition\";\r\n\r\n// ---------------------------------------------------------------------------\r\n// Output shapes — structural mirrors of ui-bridge-auto's WorkflowConfig.\r\n// Kept in sync via ui-bridge-auto's regression test, NOT compile-time\r\n// imports (qontinui-schemas has no runtime deps by design).\r\n// ---------------------------------------------------------------------------\r\n\r\n/** Mirrors `StateConfig` from ui-bridge-auto/src/config/workflow.ts:47. */\r\nexport interface AdaptedState {\r\n  id: string;\r\n  name: string;\r\n  description?: string;\r\n  requiredElements: IRElementCriteria[];\r\n  excludedElements?: IRElementCriteria[];\r\n  conditions?: IRStateCondition[];\r\n  isInitial?: boolean;\r\n  isTerminal?: boolean;\r\n  blocking?: boolean;\r\n  group?: string;\r\n  pathCost?: number;\r\n}\r\n\r\n/**\r\n * Mirrors the runtime `TransitionDefinition` shape from\r\n * ui-bridge-auto/src/state/state-machine.ts:40.\r\n *\r\n * Note: ui-bridge-auto has two related Transition shapes — the storage shape\r\n * (`TransitionConfig` in config/workflow.ts:54, with action field named\r\n * `type`) and the runtime engine shape (`TransitionDefinition` in\r\n * state-machine.ts:40, with action field named `action`). The runtime engine\r\n * is what consumers actually pass adapter output into via\r\n * `engine.defineTransitions(...)`, so the adapter targets the runtime shape.\r\n */\r\nexport interface AdaptedTransition {\r\n  id: string;\r\n  name: string;\r\n  description?: string;\r\n  fromStates: string[];\r\n  activateStates: string[];\r\n  /** Adapter normalizes IR's optional `exitStates` to a required array. */\r\n  exitStates: string[];\r\n  actions: AdaptedTransitionAction[];\r\n  pathCost?: number;\r\n  bidirectional?: boolean;\r\n}\r\n\r\n/**\r\n * Mirrors the runtime `TransitionAction` from\r\n * ui-bridge-auto/src/state/state-machine.ts:55.\r\n *\r\n * The IR uses `type` for the action verb (matching the storage-shape\r\n * convention); the adapter renames it to `action` for the runtime engine.\r\n *\r\n * `waitAfter` is narrower than `IRWaitSpec` — the runtime engine accepts\r\n * only a subset of wait types and a subset of fields. The adapter drops\r\n * IR-only wait variants (e.g., `state`, `condition`) and IR-only fields\r\n * (e.g., `property`, `quietPeriodMs`). Authors can still express richer\r\n * waits in the IR; they just don't survive the runtime contract.\r\n */\r\nexport interface AdaptedWaitAfter {\r\n  type: \"idle\" | \"element\" | \"time\" | \"vanish\" | \"change\" | \"stable\";\r\n  query?: IRElementCriteria;\r\n  ms?: number;\r\n  timeout?: number;\r\n}\r\n\r\nexport interface AdaptedTransitionAction {\r\n  /** Action verb — renamed from IR's `type` to match the runtime contract. */\r\n  action: string;\r\n  target: IRElementCriteria;\r\n  params?: Record<string, unknown>;\r\n  waitAfter?: AdaptedWaitAfter;\r\n}\r\n\r\n/** Mirrors `WorkflowConfig` from ui-bridge-auto/src/config/workflow.ts:67. */\r\nexport interface AdaptedWorkflowConfig {\r\n  id: string;\r\n  name: string;\r\n  description?: string;\r\n  version?: string;\r\n  states: AdaptedState[];\r\n  transitions: AdaptedTransition[];\r\n  initialState?: string;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Adapter implementation\r\n// ---------------------------------------------------------------------------\r\n\r\nconst SUPPORTED_IR_VERSIONS = new Set<string>([\"1.0\"]);\r\n\r\n/**\r\n * Convert an IR state declaration into the runtime/storage state shape.\r\n * Strips IR-only fields (metadata, provenance, elementIds,\r\n * incomingTransitions, crossRefs, visualRefs).\r\n */\r\nexport function adaptIRState(state: IRState): AdaptedState {\r\n  const out: AdaptedState = {\r\n    id: state.id,\r\n    name: state.name,\r\n    requiredElements: state.requiredElements,\r\n  };\r\n  if (state.description !== undefined) out.description = state.description;\r\n  if (state.excludedElements !== undefined) out.excludedElements = state.excludedElements;\r\n  if (state.conditions !== undefined) out.conditions = state.conditions;\r\n  if (state.isInitial !== undefined) out.isInitial = state.isInitial;\r\n  if (state.isTerminal !== undefined) out.isTerminal = state.isTerminal;\r\n  if (state.blocking !== undefined) out.blocking = state.blocking;\r\n  if (state.group !== undefined) out.group = state.group;\r\n  if (state.pathCost !== undefined) out.pathCost = state.pathCost;\r\n  return out;\r\n}\r\n\r\n/**\r\n * Wait types the runtime engine accepts. IR-authored waits with other types\r\n * (e.g., `state`, `condition`) are dropped from the adapter output.\r\n */\r\nconst RUNTIME_WAIT_TYPES = new Set<AdaptedWaitAfter[\"type\"]>([\r\n  \"idle\",\r\n  \"element\",\r\n  \"time\",\r\n  \"vanish\",\r\n  \"change\",\r\n  \"stable\",\r\n]);\r\n\r\nfunction adaptIRWaitAfter(wait: IRWaitSpec): AdaptedWaitAfter | undefined {\r\n  if (!RUNTIME_WAIT_TYPES.has(wait.type as AdaptedWaitAfter[\"type\"])) {\r\n    // IR-authored wait is richer than runtime supports — drop it.\r\n    // Runtime defaults (default idle behaviour) take over.\r\n    return undefined;\r\n  }\r\n  const out: AdaptedWaitAfter = { type: wait.type as AdaptedWaitAfter[\"type\"] };\r\n  if (wait.query !== undefined) out.query = wait.query;\r\n  if (wait.ms !== undefined) out.ms = wait.ms;\r\n  if (wait.timeout !== undefined) out.timeout = wait.timeout;\r\n  return out;\r\n}\r\n\r\n/**\r\n * Convert an IR transition action into the runtime action shape.\r\n * Renames IR's `type` to runtime's `action`; narrows `waitAfter` to the\r\n * runtime-accepted subset.\r\n */\r\nexport function adaptIRTransitionAction(action: IRTransitionAction): AdaptedTransitionAction {\r\n  const out: AdaptedTransitionAction = {\r\n    action: action.type,\r\n    target: action.target,\r\n  };\r\n  if (action.params !== undefined) out.params = action.params;\r\n  if (action.waitAfter !== undefined) {\r\n    const adaptedWait = adaptIRWaitAfter(action.waitAfter);\r\n    if (adaptedWait !== undefined) out.waitAfter = adaptedWait;\r\n  }\r\n  return out;\r\n}\r\n\r\n/**\r\n * Convert an IR transition declaration into the runtime/storage transition\r\n * shape. Strips IR-only fields (effect, metadata, provenance, crossRefs)\r\n * and defaults `exitStates` to `[]` when omitted.\r\n */\r\nexport function adaptIRTransition(transition: IRTransition): AdaptedTransition {\r\n  const out: AdaptedTransition = {\r\n    id: transition.id,\r\n    name: transition.name,\r\n    fromStates: transition.fromStates,\r\n    activateStates: transition.activateStates,\r\n    exitStates: transition.exitStates ?? [],\r\n    actions: transition.actions.map(adaptIRTransitionAction),\r\n  };\r\n  if (transition.description !== undefined) out.description = transition.description;\r\n  if (transition.pathCost !== undefined) out.pathCost = transition.pathCost;\r\n  if (transition.bidirectional !== undefined) out.bidirectional = transition.bidirectional;\r\n  return out;\r\n}\r\n\r\n/**\r\n * Convert a top-level IR document into the runtime `WorkflowConfig` shape.\r\n *\r\n * Throws on unknown IR versions to fail loudly rather than silently emit\r\n * stale shapes.\r\n */\r\nexport function adaptIRDocumentToWorkflowConfig(doc: IRDocument): AdaptedWorkflowConfig {\r\n  if (!SUPPORTED_IR_VERSIONS.has(doc.version)) {\r\n    throw new Error(\r\n      `adaptIRDocumentToWorkflowConfig: unsupported IR version \"${doc.version}\". ` +\r\n        `Supported: ${Array.from(SUPPORTED_IR_VERSIONS).join(\", \")}`,\r\n    );\r\n  }\r\n\r\n  const out: AdaptedWorkflowConfig = {\r\n    id: doc.id,\r\n    name: doc.name,\r\n    states: doc.states.map(adaptIRState),\r\n    transitions: doc.transitions.map(adaptIRTransition),\r\n  };\r\n  if (doc.description !== undefined) out.description = doc.description;\r\n  if (doc.initialState !== undefined) out.initialState = doc.initialState;\r\n  return out;\r\n}\r\n","/**\r\n * IR -> Bundled-Page Legacy Spec projection.\r\n *\r\n * Single point of translation between authoring-time IR (`IRDocument`) and the\r\n * legacy `*.spec.uibridge.json` shape that existing tooling still consumes\r\n * (`/update-spec`, runner spec drift / verify, error monitor curator,\r\n * spec experimentation, AI session). See ADR-001 (decision #6 / #7) for the\r\n * boundary rationale; section 2 of the UI Bridge redesign for the projection's\r\n * role in keeping legacy consumers working through the migration.\r\n *\r\n * The projection is a PURE FUNCTION — same input always produces byte-identical\r\n * output. Keys within objects are sorted lexicographically, arrays preserve\r\n * input order, and no timestamps / random IDs are introduced. Downstream tests\r\n * may hash the JSON output for byte-stable assertions.\r\n *\r\n * ---------------------------------------------------------------------------\r\n * Mapping rules (worked example below)\r\n * ---------------------------------------------------------------------------\r\n *\r\n *   IRDocument                                   LegacySpec\r\n *   ----------                                   ----------\r\n *   doc.id                                  ->   metadata.component\r\n *   doc.metadata?.purpose ?? doc.id         ->   metadata.component (purpose wins if present)\r\n *   doc.description ?? doc.name             ->   description\r\n *   doc.metadata?.tags                      ->   metadata.tags\r\n *\r\n *   For each IRState:\r\n *     state                                 ->   one entry in groups[]\r\n *       state.id                            ->   group.id\r\n *       state.name                          ->   group.name\r\n *       state.description ??\r\n *         state.metadata?.description       ->   group.description\r\n *       \"element-presence\"                  ->   group.category (default)\r\n *       state.provenance?.source ??\r\n *         \"ai-generated\"                    ->   group.source\r\n *\r\n *     For each requiredElement of state:\r\n *       (state, criteria, index)            ->   one assertion in group.assertions[]\r\n *         \"${state.id}-elem-${index}\"       ->   assertion.id\r\n *         state.metadata?.description ??    ->   assertion.description\r\n *           \"Required element ${index} ...\"\r\n *         \"element-presence\"                ->   assertion.category\r\n *         \"critical\"                        ->   assertion.severity\r\n *         \"exists\"                          ->   assertion.assertionType\r\n *         {\r\n *           type: \"search\",\r\n *           criteria: convert(criteria),   ->   assertion.target\r\n *           label: \"Required element ...\"\r\n *         }\r\n *         \"ai-generated\"                    ->   assertion.source\r\n *         false                             ->   assertion.reviewed\r\n *         true                              ->   assertion.enabled\r\n *\r\n *     If state has zero requiredElements, the projected `group.assertions[]`\r\n *     is the empty array — legacy specs ship architecture-only groups with\r\n *     empty assertions, and the inverse projection's identity round-trip\r\n *     depends on preserving that emptiness. (Earlier versions emitted a\r\n *     placeholder assertion here, which silently grew the assertion count\r\n *     during round-trip and tripped `check-spec-pairing`.)\r\n *\r\n *   Each IRState                            ->   one entry in stateMachine.states[]\r\n *     state.id                              ->   sm-state.id\r\n *     state.name                            ->   sm-state.name\r\n *     state.description ?? \"\"               ->   sm-state.description\r\n *     state.requiredElements (converted)    ->   sm-state.elements\r\n *     state.isInitial ??\r\n *       (state.id === doc.initialState)     ->   sm-state.isInitial\r\n *     transitions originating from state    ->   sm-state.transitions\r\n *\r\n *   For each IRTransition:\r\n *     For each fromState in transition.fromStates:\r\n *       transition                          ->   one entry in\r\n *                                                stateMachine.states[fromState].transitions[]\r\n *         transition.id                     ->   sm-transition.id\r\n *         transition.name                   ->   sm-transition.name\r\n *         transition.activateStates         ->   sm-transition.activateStates\r\n *         transition.exitStates ?? []       ->   sm-transition.deactivateStates\r\n *         (exitStates.length === 0)         ->   sm-transition.staysVisible\r\n *\r\n *         For each action in transition.actions:\r\n *           action.type                     ->   process[].action  (rename type -> action)\r\n *           action.target                   ->   process[].target  (criteria converted)\r\n *           action.waitAfter                ->   process[].waitAfter (passed through)\r\n *\r\n *   Element-criteria conversion (IRElementCriteria -> legacy criteria):\r\n *       text          ->   textContent\r\n *       ariaLabel     ->   accessibleName\r\n *       attributes    ->   dataAttributes\r\n *       (others — role, textContains, id — pass through unchanged)\r\n *\r\n * ---------------------------------------------------------------------------\r\n * Worked example\r\n * ---------------------------------------------------------------------------\r\n *\r\n *   const ir: IRDocument = {\r\n *     version: \"1.0\",\r\n *     id: \"active\",\r\n *     name: \"Active Dashboard\",\r\n *     description: \"Real-time monitoring hub\",\r\n *     metadata: { tags: [\"monitoring\", \"tier-1\"] },\r\n *     states: [\r\n *       {\r\n *         id: \"running\",\r\n *         name: \"Running\",\r\n *         description: \"Workflow executing\",\r\n *         requiredElements: [{ role: \"button\", text: \"Stop\" }],\r\n *         isInitial: false,\r\n *       },\r\n *     ],\r\n *     transitions: [\r\n *       {\r\n *         id: \"running-to-idle\",\r\n *         name: \"Stop\",\r\n *         fromStates: [\"running\"],\r\n *         activateStates: [\"idle\"],\r\n *         exitStates: [\"running\"],\r\n *         actions: [\r\n *           {\r\n *             type: \"click\",\r\n *             target: { role: \"button\", text: \"Stop\" },\r\n *             waitAfter: { type: \"idle\", timeout: 3000 },\r\n *           },\r\n *         ],\r\n *       },\r\n *     ],\r\n *     initialState: \"idle\",\r\n *   };\r\n *\r\n *   projectIRToBundledPage(ir, \"Notes from author\")\r\n *   // -> {\r\n *   //   version: \"1.0.0\",\r\n *   //   description: \"Real-time monitoring hub\\n\\nNotes from author\",\r\n *   //   groups: [{\r\n *   //     id: \"running\",\r\n *   //     name: \"Running\",\r\n *   //     description: \"Workflow executing\",\r\n *   //     category: \"element-presence\",\r\n *   //     assertions: [{\r\n *   //       id: \"running-elem-0\",\r\n *   //       description: \"Required element 0 for state Running\",\r\n *   //       category: \"element-presence\",\r\n *   //       severity: \"critical\",\r\n *   //       assertionType: \"exists\",\r\n *   //       target: {\r\n *   //         type: \"search\",\r\n *   //         criteria: { role: \"button\", textContent: \"Stop\" },\r\n *   //         label: \"Required element for Running\",\r\n *   //       },\r\n *   //       source: \"ai-generated\",\r\n *   //       reviewed: false,\r\n *   //       enabled: true,\r\n *   //     }],\r\n *   //     source: \"ai-generated\",\r\n *   //   }],\r\n *   //   stateMachine: {\r\n *   //     states: [{\r\n *   //       id: \"running\",\r\n *   //       name: \"Running\",\r\n *   //       description: \"Workflow executing\",\r\n *   //       elements: [{ role: \"button\", textContent: \"Stop\" }],\r\n *   //       isInitial: false,\r\n *   //       transitions: [{\r\n *   //         id: \"running-to-idle\",\r\n *   //         name: \"Stop\",\r\n *   //         activateStates: [\"idle\"],\r\n *   //         deactivateStates: [\"running\"],\r\n *   //         staysVisible: false,\r\n *   //         process: [{\r\n *   //           action: \"click\",\r\n *   //           target: { role: \"button\", textContent: \"Stop\" },\r\n *   //           waitAfter: { type: \"idle\", timeout: 3000 },\r\n *   //         }],\r\n *   //       }],\r\n *   //     }],\r\n *   //   },\r\n *   //   metadata: { component: \"active\", tags: [\"monitoring\", \"tier-1\"] },\r\n *   // }\r\n */\r\n\r\nimport type { IRElementCriteria } from \"./element-criteria\";\r\nimport type { IRDocument } from \"./document\";\r\nimport type { IRAssertion, IRGroup } from \"./group\";\r\nimport type { IRState } from \"./state\";\r\nimport type { IRTransition, IRTransitionAction, IRWaitSpec } from \"./transition\";\r\n\r\n/**\r\n * Projection version. Bump on shape changes that consumers must adapt to.\r\n * Independent from `IRVersion` because the legacy spec shape and the IR shape\r\n * evolve on different cadences.\r\n */\r\nexport const projectionVersion = \"1.0\";\r\n\r\n// ---------------------------------------------------------------------------\r\n// Legacy spec shapes — derived from active.spec.uibridge.json (the reference\r\n// the projection's output must structurally match).\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Legacy element-criteria shape (after conversion from `IRElementCriteria`).\r\n *\r\n * The differences from `IRElementCriteria`:\r\n *   - `text`        -> `textContent`\r\n *   - `ariaLabel`   -> `accessibleName` (when IR has no explicit `accessibleName`)\r\n *   - `attributes`  -> `dataAttributes`\r\n *\r\n * Other fields (`role`, `tagName`, `textContains`, `accessibleName`, `id`)\r\n * pass through unchanged. Index signature stays open for legacy fields the\r\n * IR doesn't yet model.\r\n */\r\nexport interface LegacyCriteria {\r\n  role?: string;\r\n  tagName?: string;\r\n  textContent?: string;\r\n  textContains?: string;\r\n  accessibleName?: string;\r\n  id?: string;\r\n  dataAttributes?: Record<string, string>;\r\n  [key: string]: unknown;\r\n}\r\n\r\n/**\r\n * Legacy assertion target. Always `type: \"search\"` for the projection — the\r\n * legacy schema also supports point/region targets, but the IR doesn't\r\n * express those.\r\n */\r\nexport interface LegacyAssertionTarget {\r\n  type: \"search\";\r\n  criteria: LegacyCriteria;\r\n  label: string;\r\n}\r\n\r\n/**\r\n * Legacy assertion. Mirrors the shape used by `groups[].assertions[]` in\r\n * `*.spec.uibridge.json`.\r\n */\r\nexport interface LegacyAssertion {\r\n  id: string;\r\n  description: string;\r\n  category: string;\r\n  severity: \"critical\" | \"warning\" | \"info\";\r\n  assertionType: string;\r\n  target: LegacyAssertionTarget;\r\n  source: string;\r\n  reviewed: boolean;\r\n  enabled: boolean;\r\n  precondition?: string;\r\n}\r\n\r\n/**\r\n * Legacy group. One per IR state.\r\n */\r\nexport interface LegacyGroup {\r\n  id: string;\r\n  name: string;\r\n  description: string;\r\n  category: string;\r\n  assertions: LegacyAssertion[];\r\n  source: string;\r\n}\r\n\r\n/**\r\n * Process step within a transition. Note `action` (not `type`) — matches the\r\n * runtime engine's `TransitionAction` shape.\r\n */\r\nexport interface LegacyProcessStep {\r\n  action: string;\r\n  target: LegacyCriteria;\r\n  waitAfter?: IRWaitSpec;\r\n}\r\n\r\n/**\r\n * Legacy state-machine transition.\r\n */\r\nexport interface LegacyTransition {\r\n  id: string;\r\n  name: string;\r\n  activateStates: string[];\r\n  deactivateStates: string[];\r\n  staysVisible: boolean;\r\n  process: LegacyProcessStep[];\r\n}\r\n\r\n/**\r\n * Legacy state-machine state.\r\n */\r\nexport interface LegacyStateMachineState {\r\n  id: string;\r\n  name: string;\r\n  description: string;\r\n  elements: LegacyCriteria[];\r\n  isInitial: boolean;\r\n  transitions: LegacyTransition[];\r\n}\r\n\r\n/**\r\n * Legacy state-machine block.\r\n */\r\nexport interface LegacyStateMachine {\r\n  states: LegacyStateMachineState[];\r\n}\r\n\r\n/**\r\n * Legacy spec metadata block. The projection writes a deterministic subset;\r\n * downstream tooling may layer additional keys on hand-authored specs.\r\n */\r\nexport interface LegacyMetadata {\r\n  component: string;\r\n  tags?: string[];\r\n  [key: string]: unknown;\r\n}\r\n\r\n/**\r\n * Top-level legacy spec shape.\r\n */\r\nexport interface LegacySpec {\r\n  version: string;\r\n  description: string;\r\n  groups: LegacyGroup[];\r\n  stateMachine: LegacyStateMachine;\r\n  metadata: LegacyMetadata;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Internal helpers\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Recursively sort object keys lexicographically. Arrays preserve input order\r\n * (ordering is meaningful for groups / assertions / transitions).\r\n *\r\n * Used as the final stage of every projected output to guarantee byte-stable\r\n * JSON serialization downstream.\r\n */\r\nfunction sortKeys<T>(value: T): T {\r\n  if (Array.isArray(value)) {\r\n    return value.map(sortKeys) as unknown as T;\r\n  }\r\n  if (value !== null && typeof value === \"object\") {\r\n    const sorted: Record<string, unknown> = {};\r\n    const keys = Object.keys(value as Record<string, unknown>).sort();\r\n    for (const key of keys) {\r\n      sorted[key] = sortKeys((value as Record<string, unknown>)[key]);\r\n    }\r\n    return sorted as unknown as T;\r\n  }\r\n  return value;\r\n}\r\n\r\n/**\r\n * Convert IR element criteria to legacy criteria. Renames `text` ->\r\n * `textContent`, `attributes` -> `dataAttributes`. `accessibleName` (or\r\n * `ariaLabel` as a fallback) maps to legacy `accessibleName`. `tagName`,\r\n * `role`, `textContains`, `id` pass through unchanged.\r\n */\r\nfunction convertCriteria(criteria: IRElementCriteria): LegacyCriteria {\r\n  const out: LegacyCriteria = {};\r\n  if (criteria.role !== undefined) out.role = criteria.role;\r\n  if (criteria.tagName !== undefined) out.tagName = criteria.tagName;\r\n  if (criteria.text !== undefined) out.textContent = criteria.text;\r\n  if (criteria.textContains !== undefined) out.textContains = criteria.textContains;\r\n  // Prefer explicit `accessibleName` when present; fall back to `ariaLabel`\r\n  // for IR documents authored against the section-1 shape.\r\n  if (criteria.accessibleName !== undefined) {\r\n    out.accessibleName = criteria.accessibleName;\r\n  } else if (criteria.ariaLabel !== undefined) {\r\n    out.accessibleName = criteria.ariaLabel;\r\n  }\r\n  if (criteria.id !== undefined) out.id = criteria.id;\r\n  if (criteria.attributes !== undefined) out.dataAttributes = criteria.attributes;\r\n  return out;\r\n}\r\n\r\n/**\r\n * Build a single legacy assertion from a state + index + criteria.\r\n *\r\n * Always produces one assertion per requiredElement; the caller is responsible\r\n * for iterating `state.requiredElements`. Empty `requiredElements` produces an\r\n * empty `assertions[]` — legitimate legacy specs (e.g. architecture-only\r\n * groups in `graphql-infrastructure`, `activity-timeline`, `opik-integration`,\r\n * `watchers`) ship with empty `assertions[]`, and the inverse projection\r\n * round-trip must preserve that emptiness or `check-spec-pairing` flags an\r\n * assertion-count drift.\r\n */\r\nfunction buildAssertion(\r\n  state: IRState,\r\n  index: number,\r\n  criteria: IRElementCriteria,\r\n): LegacyAssertion {\r\n  const description =\r\n    state.metadata?.description ?? `Required element ${index} for state ${state.name}`;\r\n  const targetCriteria: LegacyCriteria = convertCriteria(criteria);\r\n  const assertion: LegacyAssertion = {\r\n    id: `${state.id}-elem-${index}`,\r\n    description,\r\n    category: \"element-presence\",\r\n    severity: \"critical\",\r\n    assertionType: \"exists\",\r\n    target: {\r\n      type: \"search\",\r\n      criteria: targetCriteria,\r\n      label: `Required element for ${state.name}`,\r\n    },\r\n    source: \"ai-generated\",\r\n    reviewed: false,\r\n    enabled: true,\r\n  };\r\n  if (state.precondition !== undefined) {\r\n    assertion.precondition = state.precondition;\r\n  }\r\n  return assertion;\r\n}\r\n\r\n/**\r\n * Build the legacy `groups[]` entry for one IR state. Emits exactly one\r\n * assertion per `requiredElement`; states with zero requiredElements project\r\n * to a group with an empty `assertions[]` array. Legacy consumers (runner\r\n * spec drift / verify, error monitor curator, AI session) tolerate empty\r\n * groups — multiple shipping legacy specs already use them for\r\n * architecture-only / documentation-only groups.\r\n */\r\nfunction buildGroup(state: IRState): LegacyGroup {\r\n  const elems = state.requiredElements ?? [];\r\n  const assertions: LegacyAssertion[] = elems.map((c, i) =>\r\n    buildAssertion(state, i, c),\r\n  );\r\n  return {\r\n    id: state.id,\r\n    name: state.name,\r\n    description: state.description ?? state.metadata?.description ?? \"\",\r\n    category: \"element-presence\",\r\n    assertions,\r\n    source: state.provenance?.source ?? \"ai-generated\",\r\n  };\r\n}\r\n\r\n/**\r\n * Convert an `IRAssertion` (IR-side, free-form criteria) into a `LegacyAssertion`.\r\n * The shapes are near-identical; the only meaningful difference is that the\r\n * IR-side `target.criteria` is `Record<string, unknown>` while the legacy\r\n * shape is `LegacyCriteria` (a typed but extensible record). We pass the\r\n * criteria object through verbatim — the open `[key: string]: unknown` index\r\n * signature on `LegacyCriteria` accepts any record shape.\r\n */\r\nfunction synthesizedAssertionToLegacy(assertion: IRAssertion): LegacyAssertion {\r\n  const target: LegacyAssertionTarget = {\r\n    type: \"search\",\r\n    criteria: assertion.target.criteria as LegacyCriteria,\r\n    label: assertion.target.label,\r\n  };\r\n  const out: LegacyAssertion = {\r\n    id: assertion.id,\r\n    description: assertion.description,\r\n    category: assertion.category,\r\n    severity: assertion.severity as LegacyAssertion[\"severity\"],\r\n    assertionType: assertion.assertionType,\r\n    target,\r\n    source: assertion.source,\r\n    reviewed: assertion.reviewed,\r\n    enabled: assertion.enabled,\r\n  };\r\n  if (assertion.precondition !== undefined) {\r\n    out.precondition = assertion.precondition;\r\n  }\r\n  return out;\r\n}\r\n\r\n/**\r\n * Convert a synthesized `IRGroup` into a `LegacyGroup`. Mirrors the legacy\r\n * shape one-to-one (modulo the free-form criteria pass-through described in\r\n * `synthesizedAssertionToLegacy`). The synthesized group always carries a\r\n * `source` (synthesis emits `\"ai-generated\"`); fall back to `\"ai-generated\"`\r\n * for hand-written IR documents that omit it.\r\n */\r\nfunction synthesizedGroupToLegacy(group: IRGroup): LegacyGroup {\r\n  return {\r\n    id: group.id,\r\n    name: group.name,\r\n    description: group.description,\r\n    category: group.category,\r\n    assertions: group.assertions.map(synthesizedAssertionToLegacy),\r\n    source: group.source ?? \"ai-generated\",\r\n  };\r\n}\r\n\r\n/**\r\n * Convert an IR transition action into the legacy `process[]` step shape.\r\n * Renames IR's `type` to legacy `action` (matches the runtime engine\r\n * convention — same as the IR -> WorkflowConfig adapter does for runtime).\r\n */\r\nfunction buildProcessStep(action: IRTransitionAction): LegacyProcessStep {\r\n  const out: LegacyProcessStep = {\r\n    action: action.type,\r\n    target: convertCriteria(action.target),\r\n  };\r\n  if (action.waitAfter !== undefined) out.waitAfter = action.waitAfter;\r\n  return out;\r\n}\r\n\r\n/**\r\n * Convert one IR transition into the legacy state-machine transition shape.\r\n * Each fromState gets its own copy in the projected output (legacy specs put\r\n * the transition under each originating state's `transitions[]`).\r\n */\r\nfunction buildTransition(transition: IRTransition): LegacyTransition {\r\n  const exitStates = transition.exitStates ?? [];\r\n  return {\r\n    id: transition.id,\r\n    name: transition.name,\r\n    activateStates: transition.activateStates,\r\n    deactivateStates: exitStates,\r\n    // Modal-style transitions (no exit states) stay visible behind the\r\n    // activated state. Otherwise the originating state(s) deactivate, so the\r\n    // page no longer shows them.\r\n    staysVisible: exitStates.length === 0,\r\n    process: transition.actions.map(buildProcessStep),\r\n  };\r\n}\r\n\r\n/**\r\n * Build the legacy `stateMachine.states[]` entry for one IR state. Includes\r\n * any transitions that originate from this state (i.e. where state.id is in\r\n * transition.fromStates).\r\n */\r\nfunction buildStateMachineState(\r\n  state: IRState,\r\n  transitions: IRTransition[],\r\n  doc: IRDocument,\r\n): LegacyStateMachineState {\r\n  const outgoing = transitions\r\n    .filter((t) => t.fromStates.includes(state.id))\r\n    .map(buildTransition);\r\n  const isInitial =\r\n    state.isInitial !== undefined ? state.isInitial : state.id === doc.initialState;\r\n  return {\r\n    id: state.id,\r\n    name: state.name,\r\n    description: state.description ?? \"\",\r\n    elements: (state.requiredElements ?? []).map(convertCriteria),\r\n    isInitial,\r\n    transitions: outgoing,\r\n  };\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Public entry point\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Project an IR document into the legacy bundled-page spec shape.\r\n *\r\n * Pure / deterministic: same input always produces structurally identical\r\n * output (and byte-identical when JSON-serialized via the standard\r\n * `JSON.stringify` ordering). Arrays preserve input order; object keys are\r\n * sorted lexicographically.\r\n *\r\n * @param doc   The IR document to project.\r\n * @param notes Optional human-authored notes (carried in the page's\r\n *              `notes.md` companion file). Appended to `description` as a\r\n *              separate paragraph (separator: two newlines).\r\n */\r\nexport function projectIRToBundledPage(doc: IRDocument, notes?: string): LegacySpec {\r\n  const baseDescription = doc.description ?? doc.name;\r\n  const description =\r\n    notes !== undefined && notes.length > 0\r\n      ? `${baseDescription}\\n\\n${notes}`\r\n      : baseDescription;\r\n\r\n  const component = doc.metadata?.purpose ?? doc.id;\r\n  const metadata: LegacyMetadata = { component };\r\n  if (doc.metadata?.tags !== undefined) metadata.tags = doc.metadata.tags;\r\n\r\n  const groups: LegacyGroup[] = doc.states.map(buildGroup);\r\n  if (doc.synthesizedGroups !== undefined) {\r\n    // Append synthesis-produced groups AFTER state-derived ones, in declared\r\n    // order. Byte-stable output (see file header) requires this exact ordering\r\n    // — anything else breaks `check-spec-pairing` style hashes.\r\n    for (const g of doc.synthesizedGroups) {\r\n      groups.push(synthesizedGroupToLegacy(g));\r\n    }\r\n  }\r\n  const smStates: LegacyStateMachineState[] = doc.states.map((s) =>\r\n    buildStateMachineState(s, doc.transitions, doc),\r\n  );\r\n\r\n  const spec: LegacySpec = {\r\n    version: \"1.0.0\",\r\n    description,\r\n    groups,\r\n    stateMachine: { states: smStates },\r\n    metadata,\r\n  };\r\n\r\n  return sortKeys(spec);\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Inverse projection — Legacy spec -> IR document\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Options for the inverse projection.\r\n *\r\n * - `docId`        — explicit IRDocument.id override. Falls back to\r\n *                    `legacy.metadata.component` (or `fallbackName` if absent).\r\n * - `fallbackName` — used when `legacy.metadata.component` is missing AND no\r\n *                    `docId` was supplied.\r\n */\r\nexport interface ProjectLegacyToIROptions {\r\n  docId?: string;\r\n  fallbackName?: string;\r\n}\r\n\r\n/**\r\n * Best-effort field-by-field invert of `LegacyCriteria` back into\r\n * `IRElementCriteria`.\r\n *\r\n * Rename map (the structural inverse of `convertCriteria`):\r\n *   textContent     -> text\r\n *   accessibleName  -> accessibleName  (passes through; the forward direction\r\n *                                       collapses ariaLabel into accessibleName,\r\n *                                       so we cannot reliably distinguish them\r\n *                                       on the inverse — pick accessibleName).\r\n *   dataAttributes  -> attributes\r\n *   role / tagName / textContains / id pass through unchanged.\r\n *\r\n * Unknown legacy keys are dropped (lossy, but documented). Document-level\r\n * unknown criteria are rare; if they show up we'll surface them in Phase A4.\r\n */\r\nfunction invertCriteria(criteria: LegacyCriteria | undefined): IRElementCriteria {\r\n  if (criteria === undefined || criteria === null) return {};\r\n  const out: IRElementCriteria = {};\r\n  if (criteria.role !== undefined) out.role = criteria.role;\r\n  if (criteria.tagName !== undefined) out.tagName = criteria.tagName;\r\n  if (criteria.textContent !== undefined) out.text = criteria.textContent;\r\n  if (criteria.textContains !== undefined) out.textContains = criteria.textContains;\r\n  if (criteria.accessibleName !== undefined) out.accessibleName = criteria.accessibleName;\r\n  if (criteria.id !== undefined) out.id = criteria.id;\r\n  if (criteria.dataAttributes !== undefined) out.attributes = criteria.dataAttributes;\r\n  return out;\r\n}\r\n\r\n/**\r\n * Pick the first non-empty `precondition` across a group's assertions. Legacy\r\n * groups carry preconditions on individual assertions; IR carries it on the\r\n * state. If multiple distinct preconditions exist we keep the first\r\n * (deterministic, mirrors input ordering) — Phase A4 review will surface\r\n * conflicts for hand-fix.\r\n */\r\nfunction firstPrecondition(group: LegacyGroup): string | undefined {\r\n  for (const a of group.assertions) {\r\n    if (a.precondition !== undefined && a.precondition.length > 0) {\r\n      return a.precondition;\r\n    }\r\n  }\r\n  return undefined;\r\n}\r\n\r\n/**\r\n * Build an `IRState` from one legacy group + its corresponding state-machine\r\n * state (when present).\r\n *\r\n * IMPORTANT: `requiredElements` is sourced from the GROUP's assertion criteria\r\n * (one criteria per assertion, in input order), NOT from `smState.elements`.\r\n * This preserves the round-trip identity for the assertion-count check —\r\n * legacy specs sometimes carry an SM block whose `elements[]` is a coarse\r\n * page-state fingerprint (1-2 entries) while the group has many assertions.\r\n * Using `smState.elements` would silently collapse those into one\r\n * requiredElement per state, then the forward direction would emit only one\r\n * assertion per group.\r\n *\r\n * `smState` (when present and matched by id) contributes:\r\n *   - `name` override (legacy `smState.name` is human-readable; group.name is\r\n *     also human-readable but may differ — prefer smState's name since the\r\n *     forward direction's `buildStateMachineState` echoes `state.name` to\r\n *     `smState.name`).\r\n *   - `description` fallback (when group.description is empty).\r\n *   - `isInitial` (the only place this lives in legacy specs).\r\n */\r\nfunction buildIRState(\r\n  group: LegacyGroup,\r\n  smState: LegacyStateMachineState | undefined,\r\n): IRState {\r\n  // Always one requiredElement per assertion so the forward projection emits\r\n  // the same number of assertions on the round-trip.\r\n  const requiredElements: IRElementCriteria[] = group.assertions.map((a) =>\r\n    invertCriteria(a.target?.criteria),\r\n  );\r\n\r\n  const description =\r\n    group.description !== undefined && group.description.length > 0\r\n      ? group.description\r\n      : smState?.description;\r\n  const precondition = firstPrecondition(group);\r\n\r\n  const state: IRState = {\r\n    id: group.id,\r\n    name: smState?.name ?? group.name,\r\n    requiredElements,\r\n  };\r\n  if (description !== undefined && description.length > 0) {\r\n    state.description = description;\r\n  }\r\n  if (smState?.isInitial === true) {\r\n    state.isInitial = true;\r\n  } else if (smState?.isInitial === false) {\r\n    state.isInitial = false;\r\n  }\r\n  if (precondition !== undefined) {\r\n    state.precondition = precondition;\r\n  }\r\n  state.provenance = { source: \"migrated\" };\r\n  return state;\r\n}\r\n\r\n/**\r\n * Convert one legacy `process[]` step back into `IRTransitionAction`. Renames\r\n * `action` -> `type`. Legacy specs occasionally omit a target on no-op steps;\r\n * we coerce to an empty criteria object in that case.\r\n */\r\nfunction invertProcessStep(step: LegacyProcessStep): IRTransitionAction {\r\n  const out: IRTransitionAction = {\r\n    type: step.action,\r\n    target: invertCriteria(step.target),\r\n  };\r\n  if (step.waitAfter !== undefined) out.waitAfter = step.waitAfter;\r\n  return out;\r\n}\r\n\r\n/**\r\n * Collapse duplicate transitions across multiple originating states. The\r\n * forward projection emits the same transition under EACH `fromState`'s\r\n * `transitions[]` entry; the inverse must merge them back into ONE\r\n * `IRTransition` whose `fromStates` lists every originator.\r\n *\r\n * Same-id transitions are assumed to be byte-identical except for the\r\n * (implicit) originating state. If they differ in `process[]` /\r\n * `activateStates` / `deactivateStates`, we keep the first occurrence and\r\n * append the additional fromState. (Genuine divergence here is a defect to\r\n * surface in Phase A4 review.)\r\n */\r\nfunction buildIRTransitions(stateMachine: LegacyStateMachine | undefined): IRTransition[] {\r\n  if (stateMachine === undefined || !Array.isArray(stateMachine.states)) return [];\r\n  const byId = new Map<string, IRTransition>();\r\n  // Preserve insertion order — first state's transitions come first.\r\n  const order: string[] = [];\r\n\r\n  for (const smState of stateMachine.states) {\r\n    const transitions = Array.isArray(smState.transitions) ? smState.transitions : [];\r\n    for (const t of transitions) {\r\n      const existing = byId.get(t.id);\r\n      if (existing !== undefined) {\r\n        if (!existing.fromStates.includes(smState.id)) {\r\n          existing.fromStates.push(smState.id);\r\n        }\r\n        continue;\r\n      }\r\n      const ir: IRTransition = {\r\n        id: t.id,\r\n        name: t.name,\r\n        fromStates: [smState.id],\r\n        activateStates: Array.isArray(t.activateStates) ? [...t.activateStates] : [],\r\n        actions: Array.isArray(t.process) ? t.process.map(invertProcessStep) : [],\r\n      };\r\n      // The forward direction maps `exitStates` -> `deactivateStates`; preserve\r\n      // the field whenever it's present in legacy form (even if empty array)\r\n      // so modal-style transitions (staysVisible: true, deactivateStates: [])\r\n      // round-trip predictably.\r\n      if (Array.isArray(t.deactivateStates)) {\r\n        ir.exitStates = [...t.deactivateStates];\r\n      }\r\n      ir.provenance = { source: \"migrated\" };\r\n      byId.set(t.id, ir);\r\n      order.push(t.id);\r\n    }\r\n  }\r\n\r\n  return order.map((id) => byId.get(id)!);\r\n}\r\n\r\n/**\r\n * Project a legacy bundled-page spec back into IR.\r\n *\r\n * Pure / deterministic: same input always produces structurally identical\r\n * output. Collapses transition duplicates (forward emits one copy per\r\n * `fromState`), preserves group/assertion ordering, and tags every node with\r\n * `provenance.source = \"migrated\"` so downstream tooling can distinguish\r\n * migrated content from hand-authored.\r\n *\r\n * The mapping is the structural inverse of `projectIRToBundledPage`:\r\n *\r\n *   LegacySpec                                IRDocument\r\n *   ----------                                ----------\r\n *   metadata.component                  ->   id (or opts.docId override)\r\n *   metadata.tags                       ->   metadata.tags\r\n *   description                         ->   description (kept verbatim;\r\n *                                            authored notes appended via\r\n *                                            forward `notes` arg are not\r\n *                                            stripped — that round-trip is\r\n *                                            best-effort and Phase A4 will\r\n *                                            split them back out)\r\n *\r\n *   groups[]                            ->   states[] (one per group)\r\n *     group.id / name / description     ->   state.id / name / description\r\n *     assertion.target.criteria         ->   state.requiredElements[i] (or,\r\n *                                            preferred, smState.elements when\r\n *                                            the stateMachine block is present)\r\n *     first-found assertion.precondition ->  state.precondition\r\n *\r\n *   stateMachine.states[]               ->   contributes isInitial + elements\r\n *     smState.transitions[]             ->   transitions[] (deduped by id)\r\n *       transition.activateStates       ->   transition.activateStates\r\n *       transition.deactivateStates     ->   transition.exitStates\r\n *       transition.process[]            ->   transition.actions[]\r\n *         step.action                   ->   action.type\r\n *         step.target                   ->   action.target (criteria inverted)\r\n *         step.waitAfter                ->   action.waitAfter\r\n *\r\n * Documented losses (acceptable for Phase A2):\r\n *   - Legacy assertion ids (`{stateId}-elem-{i}`) are NOT preserved across the\r\n *     round-trip — the forward direction regenerates them from index, so any\r\n *     hand-edited ids are lost. See Phase A4.\r\n *   - Legacy `assertionType` / `severity` / `category` / `source` per\r\n *     assertion are reduced to defaults on round-trip.\r\n *   - Legacy `expected` / `assertionType: \"count\"` and `notExists` semantics\r\n *     are not modeled in IR — the assertion's criteria still survive (as a\r\n *     state requiredElement) but the assertion-flavor metadata is dropped.\r\n *   - Legacy `testing` block + extra metadata keys outside `component` /\r\n *     `tags` are ignored. Authors keep them via the legacy spec file directly\r\n *     during Phase A2 — they will move into IR companion files in Phase A4.\r\n *   - The forward `notes` argument's appended paragraph is currently kept\r\n *     in `description`; Phase A4 will split it back out into a dedicated\r\n *     companion file.\r\n *\r\n * @param legacy The legacy spec to invert.\r\n * @param opts   Optional doc-level overrides.\r\n */\r\nexport function projectLegacyToIR(\r\n  legacy: LegacySpec,\r\n  opts?: ProjectLegacyToIROptions,\r\n): IRDocument {\r\n  const component =\r\n    opts?.docId ??\r\n    legacy.metadata?.component ??\r\n    opts?.fallbackName ??\r\n    \"legacy-spec\";\r\n  const name = legacy.metadata?.component ?? opts?.fallbackName ?? component;\r\n\r\n  // Index state-machine states by id for quick lookup when building IR states\r\n  // out of groups. Older specs may not have a stateMachine block.\r\n  const smByGroupId = new Map<string, LegacyStateMachineState>();\r\n  if (legacy.stateMachine !== undefined && Array.isArray(legacy.stateMachine.states)) {\r\n    for (const s of legacy.stateMachine.states) {\r\n      smByGroupId.set(s.id, s);\r\n    }\r\n  }\r\n\r\n  const groups = Array.isArray(legacy.groups) ? legacy.groups : [];\r\n  const states: IRState[] = groups.map((group) =>\r\n    buildIRState(group, smByGroupId.get(group.id)),\r\n  );\r\n\r\n  // NOTE: Some legacy specs declare `stateMachine.states[]` whose ids do NOT\r\n  // correspond to any `groups[]` entry (e.g., page-level states like\r\n  // `wrappers-installed-tab` vs assertion-category groups like\r\n  // `page-structure`). The IR's group-state mapping is 1:1 with groups by\r\n  // construction (the forward projection emits one group per IR state), so\r\n  // these orphan SM states cannot survive the round-trip cleanly. They are\r\n  // dropped here as a documented loss — Phase A4 will revisit by either\r\n  // (a) introducing a separate IR concept for \"page state\" vs\r\n  // \"assertion group\", or (b) hand-merging the legacy specs so groups and\r\n  // SM states share ids.\r\n  // Transitions originating from orphan SM states are likewise omitted from\r\n  // IR (their fromStates would dangle). We filter them below.\r\n  const groupIds = new Set(groups.map((g) => g.id));\r\n\r\n  // Build transitions only from SM states whose ids appear in groups[]. Any\r\n  // transition with a fromState that isn't a known group is dropped — the\r\n  // forward direction would have nowhere to emit it.\r\n  let filteredStateMachine: LegacyStateMachine | undefined = legacy.stateMachine;\r\n  if (\r\n    legacy.stateMachine !== undefined &&\r\n    Array.isArray(legacy.stateMachine.states) &&\r\n    legacy.stateMachine.states.some((s) => !groupIds.has(s.id))\r\n  ) {\r\n    filteredStateMachine = {\r\n      states: legacy.stateMachine.states.filter((s) => groupIds.has(s.id)),\r\n    };\r\n  }\r\n  const transitions = buildIRTransitions(filteredStateMachine);\r\n\r\n  // Initial state: first state with isInitial:true wins (mirrors how the\r\n  // forward direction picks the document's `initialState`). Only consider\r\n  // SM states that correspond to a group (so initialState references a real\r\n  // IR state).\r\n  let initialState: string | undefined;\r\n  if (legacy.stateMachine !== undefined && Array.isArray(legacy.stateMachine.states)) {\r\n    const initial = legacy.stateMachine.states.find(\r\n      (s) => s.isInitial === true && groupIds.has(s.id),\r\n    );\r\n    if (initial !== undefined) initialState = initial.id;\r\n  }\r\n\r\n  const doc: IRDocument = {\r\n    version: \"1.0\",\r\n    id: component,\r\n    name,\r\n    states,\r\n    transitions,\r\n    provenance: { source: \"migrated\" },\r\n  };\r\n  if (legacy.description !== undefined && legacy.description.length > 0) {\r\n    doc.description = legacy.description;\r\n  }\r\n  if (legacy.metadata !== undefined && legacy.metadata.tags !== undefined) {\r\n    doc.metadata = { tags: legacy.metadata.tags };\r\n  }\r\n  if (initialState !== undefined) {\r\n    doc.initialState = initialState;\r\n  }\r\n  return doc;\r\n}\r\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/ui-bridge-ir/adapter.ts","../src/ui-bridge-ir/projection.ts"],"sourcesContent":["/**\n * IR -> WorkflowConfig adapter.\n *\n * Single point of translation between authoring-time IR (with provenance,\n * metadata, effect, crossRefs, visualRefs) and the runtime/storage shape\n * that ui-bridge-auto consumes. See ADR-001 (decision #6 / #7) for the\n * boundary rationale.\n *\n * The output is intentionally typed structurally — this module has no\n * runtime dependency on ui-bridge-auto. ui-bridge-auto's own tests verify\n * end-to-end compatibility with `engine.defineStates(...)` /\n * `engine.defineTransitions(...)` (see\n * `ui-bridge-auto/src/__tests__/spike-ir-contract.test.ts`).\n */\n\nimport type { IRElementCriteria } from \"./element-criteria\";\nimport type { IRDocument } from \"./document\";\nimport type { IRState, IRStateCondition } from \"./state\";\nimport type { IRTransition, IRTransitionAction, IRWaitSpec } from \"./transition\";\n\n// ---------------------------------------------------------------------------\n// Output shapes — structural mirrors of ui-bridge-auto's WorkflowConfig.\n// Kept in sync via ui-bridge-auto's regression test, NOT compile-time\n// imports (qontinui-schemas has no runtime deps by design).\n// ---------------------------------------------------------------------------\n\n/** Mirrors `StateConfig` from ui-bridge-auto/src/config/workflow.ts:47. */\nexport interface AdaptedState {\n  id: string;\n  name: string;\n  description?: string;\n  requiredElements: IRElementCriteria[];\n  excludedElements?: IRElementCriteria[];\n  conditions?: IRStateCondition[];\n  isInitial?: boolean;\n  isTerminal?: boolean;\n  blocking?: boolean;\n  group?: string;\n  pathCost?: number;\n}\n\n/**\n * Mirrors the runtime `TransitionDefinition` shape from\n * ui-bridge-auto/src/state/state-machine.ts:40.\n *\n * Note: ui-bridge-auto has two related Transition shapes — the storage shape\n * (`TransitionConfig` in config/workflow.ts:54, with action field named\n * `type`) and the runtime engine shape (`TransitionDefinition` in\n * state-machine.ts:40, with action field named `action`). The runtime engine\n * is what consumers actually pass adapter output into via\n * `engine.defineTransitions(...)`, so the adapter targets the runtime shape.\n */\nexport interface AdaptedTransition {\n  id: string;\n  name: string;\n  description?: string;\n  fromStates: string[];\n  activateStates: string[];\n  /** Adapter normalizes IR's optional `exitStates` to a required array. */\n  exitStates: string[];\n  actions: AdaptedTransitionAction[];\n  pathCost?: number;\n  bidirectional?: boolean;\n}\n\n/**\n * Mirrors the runtime `TransitionAction` from\n * ui-bridge-auto/src/state/state-machine.ts:55.\n *\n * The IR uses `type` for the action verb (matching the storage-shape\n * convention); the adapter renames it to `action` for the runtime engine.\n *\n * `waitAfter` is narrower than `IRWaitSpec` — the runtime engine accepts\n * only a subset of wait types and a subset of fields. The adapter drops\n * IR-only wait variants (e.g., `state`, `condition`) and IR-only fields\n * (e.g., `property`, `quietPeriodMs`). Authors can still express richer\n * waits in the IR; they just don't survive the runtime contract.\n */\nexport interface AdaptedWaitAfter {\n  type: \"idle\" | \"element\" | \"time\" | \"vanish\" | \"change\" | \"stable\";\n  query?: IRElementCriteria;\n  ms?: number;\n  timeout?: number;\n}\n\nexport interface AdaptedTransitionAction {\n  /** Action verb — renamed from IR's `type` to match the runtime contract. */\n  action: string;\n  target: IRElementCriteria;\n  params?: Record<string, unknown>;\n  waitAfter?: AdaptedWaitAfter;\n}\n\n/** Mirrors `WorkflowConfig` from ui-bridge-auto/src/config/workflow.ts:67. */\nexport interface AdaptedWorkflowConfig {\n  id: string;\n  name: string;\n  description?: string;\n  version?: string;\n  states: AdaptedState[];\n  transitions: AdaptedTransition[];\n  initialState?: string;\n}\n\n// ---------------------------------------------------------------------------\n// Adapter implementation\n// ---------------------------------------------------------------------------\n\nconst SUPPORTED_IR_VERSIONS = new Set<string>([\"1.0\"]);\n\n/**\n * Convert an IR state declaration into the runtime/storage state shape.\n * Strips IR-only fields (metadata, provenance, elementIds,\n * incomingTransitions, crossRefs, visualRefs).\n */\nexport function adaptIRState(state: IRState): AdaptedState {\n  // Project rich IR assertions down to the runtime's flat element-criteria\n  // list. The runtime engine (ui-bridge-auto's WorkflowConfig.StateConfig)\n  // doesn't carry per-element severity/category — those metadata fields stay\n  // IR-side, consumed by Spec-Check policies.\n  const out: AdaptedState = {\n    id: state.id,\n    name: state.name,\n    requiredElements: state.assertions.map(\n      (a) => a.target.criteria as unknown as IRElementCriteria,\n    ),\n  };\n  if (state.description !== undefined) out.description = state.description;\n  if (state.excludedElements !== undefined) out.excludedElements = state.excludedElements;\n  if (state.conditions !== undefined) out.conditions = state.conditions;\n  if (state.isInitial !== undefined) out.isInitial = state.isInitial;\n  if (state.isTerminal !== undefined) out.isTerminal = state.isTerminal;\n  if (state.blocking !== undefined) out.blocking = state.blocking;\n  if (state.group !== undefined) out.group = state.group;\n  if (state.pathCost !== undefined) out.pathCost = state.pathCost;\n  return out;\n}\n\n/**\n * Wait types the runtime engine accepts. IR-authored waits with other types\n * (e.g., `state`, `condition`) are dropped from the adapter output.\n */\nconst RUNTIME_WAIT_TYPES = new Set<AdaptedWaitAfter[\"type\"]>([\n  \"idle\",\n  \"element\",\n  \"time\",\n  \"vanish\",\n  \"change\",\n  \"stable\",\n]);\n\nfunction adaptIRWaitAfter(wait: IRWaitSpec): AdaptedWaitAfter | undefined {\n  if (!RUNTIME_WAIT_TYPES.has(wait.type as AdaptedWaitAfter[\"type\"])) {\n    // IR-authored wait is richer than runtime supports — drop it.\n    // Runtime defaults (default idle behaviour) take over.\n    return undefined;\n  }\n  const out: AdaptedWaitAfter = { type: wait.type as AdaptedWaitAfter[\"type\"] };\n  if (wait.query !== undefined) out.query = wait.query;\n  if (wait.ms !== undefined) out.ms = wait.ms;\n  if (wait.timeout !== undefined) out.timeout = wait.timeout;\n  return out;\n}\n\n/**\n * Convert an IR transition action into the runtime action shape.\n * Renames IR's `type` to runtime's `action`; narrows `waitAfter` to the\n * runtime-accepted subset.\n */\nexport function adaptIRTransitionAction(action: IRTransitionAction): AdaptedTransitionAction {\n  const out: AdaptedTransitionAction = {\n    action: action.type,\n    target: action.target,\n  };\n  if (action.params !== undefined) out.params = action.params;\n  if (action.waitAfter !== undefined) {\n    const adaptedWait = adaptIRWaitAfter(action.waitAfter);\n    if (adaptedWait !== undefined) out.waitAfter = adaptedWait;\n  }\n  return out;\n}\n\n/**\n * Convert an IR transition declaration into the runtime/storage transition\n * shape. Strips IR-only fields (effect, metadata, provenance, crossRefs)\n * and defaults `exitStates` to `[]` when omitted.\n */\nexport function adaptIRTransition(transition: IRTransition): AdaptedTransition {\n  const out: AdaptedTransition = {\n    id: transition.id,\n    name: transition.name,\n    fromStates: transition.fromStates,\n    activateStates: transition.activateStates,\n    exitStates: transition.exitStates ?? [],\n    actions: transition.actions.map(adaptIRTransitionAction),\n  };\n  if (transition.description !== undefined) out.description = transition.description;\n  if (transition.pathCost !== undefined) out.pathCost = transition.pathCost;\n  if (transition.bidirectional !== undefined) out.bidirectional = transition.bidirectional;\n  return out;\n}\n\n/**\n * Convert a top-level IR document into the runtime `WorkflowConfig` shape.\n *\n * Throws on unknown IR versions to fail loudly rather than silently emit\n * stale shapes.\n */\nexport function adaptIRDocumentToWorkflowConfig(doc: IRDocument): AdaptedWorkflowConfig {\n  if (!SUPPORTED_IR_VERSIONS.has(doc.version)) {\n    throw new Error(\n      `adaptIRDocumentToWorkflowConfig: unsupported IR version \"${doc.version}\". ` +\n        `Supported: ${Array.from(SUPPORTED_IR_VERSIONS).join(\", \")}`,\n    );\n  }\n\n  const out: AdaptedWorkflowConfig = {\n    id: doc.id,\n    name: doc.name,\n    states: doc.states.map(adaptIRState),\n    transitions: doc.transitions.map(adaptIRTransition),\n  };\n  if (doc.description !== undefined) out.description = doc.description;\n  if (doc.initialState !== undefined) out.initialState = doc.initialState;\n  return out;\n}\n","/**\n * IR -> Bundled-Page Legacy Spec projection.\n *\n * Single point of translation between authoring-time IR (`IRDocument`) and the\n * legacy `*.spec.uibridge.json` shape that existing tooling still consumes\n * (`/update-spec`, runner spec drift / verify, error monitor curator,\n * spec experimentation, AI session). See ADR-001 (decision #6 / #7) for the\n * boundary rationale; section 2 of the UI Bridge redesign for the projection's\n * role in keeping legacy consumers working through the migration.\n *\n * The projection is a PURE FUNCTION — same input always produces byte-identical\n * output. Keys within objects are sorted lexicographically, arrays preserve\n * input order, and no timestamps / random IDs are introduced. Downstream tests\n * may hash the JSON output for byte-stable assertions.\n *\n * ---------------------------------------------------------------------------\n * Mapping rules (worked example below)\n * ---------------------------------------------------------------------------\n *\n *   IRDocument                                   LegacySpec\n *   ----------                                   ----------\n *   doc.id                                  ->   metadata.component\n *   doc.metadata?.purpose ?? doc.id         ->   metadata.component (purpose wins if present)\n *   doc.description ?? doc.name             ->   description\n *   doc.metadata?.tags                      ->   metadata.tags\n *\n *   For each IRState:\n *     state                                 ->   one entry in groups[]\n *       state.id                            ->   group.id\n *       state.name                          ->   group.name\n *       state.description ??\n *         state.metadata?.description       ->   group.description\n *       \"element-presence\"                  ->   group.category (default)\n *       state.provenance?.source ??\n *         \"ai-generated\"                    ->   group.source\n *\n *     For each requiredElement of state:\n *       (state, criteria, index)            ->   one assertion in group.assertions[]\n *         \"${state.id}-elem-${index}\"       ->   assertion.id\n *         state.metadata?.description ??    ->   assertion.description\n *           \"Required element ${index} ...\"\n *         \"element-presence\"                ->   assertion.category\n *         \"critical\"                        ->   assertion.severity\n *         \"exists\"                          ->   assertion.assertionType\n *         {\n *           type: \"search\",\n *           criteria: convert(criteria),   ->   assertion.target\n *           label: \"Required element ...\"\n *         }\n *         \"ai-generated\"                    ->   assertion.source\n *         false                             ->   assertion.reviewed\n *         true                              ->   assertion.enabled\n *\n *     If state has zero requiredElements, the projected `group.assertions[]`\n *     is the empty array — legacy specs ship architecture-only groups with\n *     empty assertions, and the inverse projection's identity round-trip\n *     depends on preserving that emptiness. (Earlier versions emitted a\n *     placeholder assertion here, which silently grew the assertion count\n *     during round-trip and tripped `check-spec-pairing`.)\n *\n *   Each IRState                            ->   one entry in stateMachine.states[]\n *     state.id                              ->   sm-state.id\n *     state.name                            ->   sm-state.name\n *     state.description ?? \"\"               ->   sm-state.description\n *     state.requiredElements (converted)    ->   sm-state.elements\n *     state.isInitial ??\n *       (state.id === doc.initialState)     ->   sm-state.isInitial\n *     transitions originating from state    ->   sm-state.transitions\n *\n *   For each IRTransition:\n *     For each fromState in transition.fromStates:\n *       transition                          ->   one entry in\n *                                                stateMachine.states[fromState].transitions[]\n *         transition.id                     ->   sm-transition.id\n *         transition.name                   ->   sm-transition.name\n *         transition.activateStates         ->   sm-transition.activateStates\n *         transition.exitStates ?? []       ->   sm-transition.deactivateStates\n *         (exitStates.length === 0)         ->   sm-transition.staysVisible\n *\n *         For each action in transition.actions:\n *           action.type                     ->   process[].action  (rename type -> action)\n *           action.target                   ->   process[].target  (criteria converted)\n *           action.waitAfter                ->   process[].waitAfter (passed through)\n *\n *   Element-criteria conversion (IRElementCriteria -> legacy criteria):\n *       text          ->   textContent\n *       ariaLabel     ->   accessibleName\n *       attributes    ->   dataAttributes\n *       (others — role, textContains, id — pass through unchanged)\n *\n * ---------------------------------------------------------------------------\n * Worked example\n * ---------------------------------------------------------------------------\n *\n *   const ir: IRDocument = {\n *     version: \"1.0\",\n *     id: \"active\",\n *     name: \"Active Dashboard\",\n *     description: \"Real-time monitoring hub\",\n *     metadata: { tags: [\"monitoring\", \"tier-1\"] },\n *     states: [\n *       {\n *         id: \"running\",\n *         name: \"Running\",\n *         description: \"Workflow executing\",\n *         requiredElements: [{ role: \"button\", text: \"Stop\" }],\n *         isInitial: false,\n *       },\n *     ],\n *     transitions: [\n *       {\n *         id: \"running-to-idle\",\n *         name: \"Stop\",\n *         fromStates: [\"running\"],\n *         activateStates: [\"idle\"],\n *         exitStates: [\"running\"],\n *         actions: [\n *           {\n *             type: \"click\",\n *             target: { role: \"button\", text: \"Stop\" },\n *             waitAfter: { type: \"idle\", timeout: 3000 },\n *           },\n *         ],\n *       },\n *     ],\n *     initialState: \"idle\",\n *   };\n *\n *   projectIRToBundledPage(ir, \"Notes from author\")\n *   // -> {\n *   //   version: \"1.0.0\",\n *   //   description: \"Real-time monitoring hub\\n\\nNotes from author\",\n *   //   groups: [{\n *   //     id: \"running\",\n *   //     name: \"Running\",\n *   //     description: \"Workflow executing\",\n *   //     category: \"element-presence\",\n *   //     assertions: [{\n *   //       id: \"running-elem-0\",\n *   //       description: \"Required element 0 for state Running\",\n *   //       category: \"element-presence\",\n *   //       severity: \"critical\",\n *   //       assertionType: \"exists\",\n *   //       target: {\n *   //         type: \"search\",\n *   //         criteria: { role: \"button\", textContent: \"Stop\" },\n *   //         label: \"Required element for Running\",\n *   //       },\n *   //       source: \"ai-generated\",\n *   //       reviewed: false,\n *   //       enabled: true,\n *   //     }],\n *   //     source: \"ai-generated\",\n *   //   }],\n *   //   stateMachine: {\n *   //     states: [{\n *   //       id: \"running\",\n *   //       name: \"Running\",\n *   //       description: \"Workflow executing\",\n *   //       elements: [{ role: \"button\", textContent: \"Stop\" }],\n *   //       isInitial: false,\n *   //       transitions: [{\n *   //         id: \"running-to-idle\",\n *   //         name: \"Stop\",\n *   //         activateStates: [\"idle\"],\n *   //         deactivateStates: [\"running\"],\n *   //         staysVisible: false,\n *   //         process: [{\n *   //           action: \"click\",\n *   //           target: { role: \"button\", textContent: \"Stop\" },\n *   //           waitAfter: { type: \"idle\", timeout: 3000 },\n *   //         }],\n *   //       }],\n *   //     }],\n *   //   },\n *   //   metadata: { component: \"active\", tags: [\"monitoring\", \"tier-1\"] },\n *   // }\n */\n\nimport type { IRElementCriteria } from \"./element-criteria\";\nimport type { IRDocument } from \"./document\";\nimport type { IRAssertion, IRGroup } from \"./group\";\nimport type { IRState } from \"./state\";\nimport type { IRTransition, IRTransitionAction, IRWaitSpec } from \"./transition\";\n\n/**\n * Projection version. Bump on shape changes that consumers must adapt to.\n * Independent from `IRVersion` because the legacy spec shape and the IR shape\n * evolve on different cadences.\n */\nexport const projectionVersion = \"1.0\";\n\n// ---------------------------------------------------------------------------\n// Legacy spec shapes — derived from active.spec.uibridge.json (the reference\n// the projection's output must structurally match).\n// ---------------------------------------------------------------------------\n\n/**\n * Legacy element-criteria shape (after conversion from `IRElementCriteria`).\n *\n * The differences from `IRElementCriteria`:\n *   - `text`        -> `textContent`\n *   - `ariaLabel`   -> `accessibleName` (when IR has no explicit `accessibleName`)\n *   - `attributes`  -> `dataAttributes`\n *\n * Other fields (`role`, `tagName`, `textContains`, `accessibleName`, `id`)\n * pass through unchanged. Index signature stays open for legacy fields the\n * IR doesn't yet model.\n */\nexport interface LegacyCriteria {\n  role?: string;\n  tagName?: string;\n  textContent?: string;\n  textContains?: string;\n  accessibleName?: string;\n  id?: string;\n  dataAttributes?: Record<string, string>;\n  [key: string]: unknown;\n}\n\n/**\n * Legacy assertion target. Always `type: \"search\"` for the projection — the\n * legacy schema also supports point/region targets, but the IR doesn't\n * express those.\n */\nexport interface LegacyAssertionTarget {\n  type: \"search\";\n  criteria: LegacyCriteria;\n  label: string;\n}\n\n/**\n * Legacy assertion. Mirrors the shape used by `groups[].assertions[]` in\n * `*.spec.uibridge.json`.\n */\nexport interface LegacyAssertion {\n  id: string;\n  description: string;\n  category: string;\n  severity: \"critical\" | \"warning\" | \"info\";\n  assertionType: string;\n  target: LegacyAssertionTarget;\n  source: string;\n  reviewed: boolean;\n  enabled: boolean;\n  precondition?: string;\n}\n\n/**\n * Legacy group. One per IR state.\n */\nexport interface LegacyGroup {\n  id: string;\n  name: string;\n  description: string;\n  category: string;\n  assertions: LegacyAssertion[];\n  source: string;\n}\n\n/**\n * Process step within a transition. Note `action` (not `type`) — matches the\n * runtime engine's `TransitionAction` shape.\n */\nexport interface LegacyProcessStep {\n  action: string;\n  target: LegacyCriteria;\n  waitAfter?: IRWaitSpec;\n}\n\n/**\n * Legacy state-machine transition.\n */\nexport interface LegacyTransition {\n  id: string;\n  name: string;\n  activateStates: string[];\n  deactivateStates: string[];\n  staysVisible: boolean;\n  process: LegacyProcessStep[];\n}\n\n/**\n * Legacy state-machine state.\n */\nexport interface LegacyStateMachineState {\n  id: string;\n  name: string;\n  description: string;\n  elements: LegacyCriteria[];\n  isInitial: boolean;\n  transitions: LegacyTransition[];\n}\n\n/**\n * Legacy state-machine block.\n */\nexport interface LegacyStateMachine {\n  states: LegacyStateMachineState[];\n}\n\n/**\n * Legacy spec metadata block. The projection writes a deterministic subset;\n * downstream tooling may layer additional keys on hand-authored specs.\n */\nexport interface LegacyMetadata {\n  component: string;\n  tags?: string[];\n  [key: string]: unknown;\n}\n\n/**\n * Top-level legacy spec shape.\n */\nexport interface LegacySpec {\n  version: string;\n  description: string;\n  groups: LegacyGroup[];\n  stateMachine: LegacyStateMachine;\n  metadata: LegacyMetadata;\n}\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Recursively sort object keys lexicographically. Arrays preserve input order\n * (ordering is meaningful for groups / assertions / transitions).\n *\n * Used as the final stage of every projected output to guarantee byte-stable\n * JSON serialization downstream.\n */\nfunction sortKeys<T>(value: T): T {\n  if (Array.isArray(value)) {\n    return value.map(sortKeys) as unknown as T;\n  }\n  if (value !== null && typeof value === \"object\") {\n    const sorted: Record<string, unknown> = {};\n    const keys = Object.keys(value as Record<string, unknown>).sort();\n    for (const key of keys) {\n      sorted[key] = sortKeys((value as Record<string, unknown>)[key]);\n    }\n    return sorted as unknown as T;\n  }\n  return value;\n}\n\n/**\n * Convert IR element criteria to legacy criteria. Renames `text` ->\n * `textContent`, `attributes` -> `dataAttributes`. `accessibleName` (or\n * `ariaLabel` as a fallback) maps to legacy `accessibleName`. `tagName`,\n * `role`, `textContains`, `id` pass through unchanged.\n */\nfunction convertCriteria(criteria: IRElementCriteria): LegacyCriteria {\n  const out: LegacyCriteria = {};\n  if (criteria.role !== undefined) out.role = criteria.role;\n  if (criteria.tagName !== undefined) out.tagName = criteria.tagName;\n  if (criteria.text !== undefined) out.textContent = criteria.text;\n  if (criteria.textContains !== undefined) out.textContains = criteria.textContains;\n  // Prefer explicit `accessibleName` when present; fall back to `ariaLabel`\n  // for IR documents authored against the section-1 shape.\n  if (criteria.accessibleName !== undefined) {\n    out.accessibleName = criteria.accessibleName;\n  } else if (criteria.ariaLabel !== undefined) {\n    out.accessibleName = criteria.ariaLabel;\n  }\n  if (criteria.id !== undefined) out.id = criteria.id;\n  if (criteria.attributes !== undefined) out.dataAttributes = criteria.attributes;\n  return out;\n}\n\n/**\n * Build the legacy `groups[]` entry for one IR state. With IrState.assertions\n * carrying first-class assertion metadata (id/description/severity/category/\n * target), this is now a direct shape-conversion per assertion — no more\n * synthesizing IDs or defaulting severity.\n */\nfunction buildGroup(state: IRState): LegacyGroup {\n  const assertions: LegacyAssertion[] = state.assertions.map(synthesizedAssertionToLegacy);\n  return {\n    id: state.id,\n    name: state.name,\n    description: state.description ?? state.metadata?.description ?? \"\",\n    category: \"element-presence\",\n    assertions,\n    source: state.provenance?.source ?? \"ai-generated\",\n  };\n}\n\n/**\n * Convert an `IRAssertion` (IR-side, free-form criteria) into a `LegacyAssertion`.\n * The shapes are near-identical; the only meaningful difference is that the\n * IR-side `target.criteria` is `Record<string, unknown>` while the legacy\n * shape is `LegacyCriteria` (a typed but extensible record). We pass the\n * criteria object through verbatim — the open `[key: string]: unknown` index\n * signature on `LegacyCriteria` accepts any record shape.\n */\nfunction synthesizedAssertionToLegacy(assertion: IRAssertion): LegacyAssertion {\n  const target: LegacyAssertionTarget = {\n    type: \"search\",\n    criteria: assertion.target.criteria as LegacyCriteria,\n    label: assertion.target.label,\n  };\n  const out: LegacyAssertion = {\n    id: assertion.id,\n    description: assertion.description,\n    category: assertion.category,\n    severity: assertion.severity as LegacyAssertion[\"severity\"],\n    assertionType: assertion.assertionType,\n    target,\n    source: assertion.source,\n    reviewed: assertion.reviewed,\n    enabled: assertion.enabled,\n  };\n  if (assertion.precondition !== undefined) {\n    out.precondition = assertion.precondition;\n  }\n  return out;\n}\n\n/**\n * Convert a synthesized `IRGroup` into a `LegacyGroup`. Mirrors the legacy\n * shape one-to-one (modulo the free-form criteria pass-through described in\n * `synthesizedAssertionToLegacy`). The synthesized group always carries a\n * `source` (synthesis emits `\"ai-generated\"`); fall back to `\"ai-generated\"`\n * for hand-written IR documents that omit it.\n */\nfunction synthesizedGroupToLegacy(group: IRGroup): LegacyGroup {\n  return {\n    id: group.id,\n    name: group.name,\n    description: group.description,\n    category: group.category,\n    assertions: group.assertions.map(synthesizedAssertionToLegacy),\n    source: group.source ?? \"ai-generated\",\n  };\n}\n\n/**\n * Convert an IR transition action into the legacy `process[]` step shape.\n * Renames IR's `type` to legacy `action` (matches the runtime engine\n * convention — same as the IR -> WorkflowConfig adapter does for runtime).\n */\nfunction buildProcessStep(action: IRTransitionAction): LegacyProcessStep {\n  const out: LegacyProcessStep = {\n    action: action.type,\n    target: convertCriteria(action.target),\n  };\n  if (action.waitAfter !== undefined) out.waitAfter = action.waitAfter;\n  return out;\n}\n\n/**\n * Convert one IR transition into the legacy state-machine transition shape.\n * Each fromState gets its own copy in the projected output (legacy specs put\n * the transition under each originating state's `transitions[]`).\n */\nfunction buildTransition(transition: IRTransition): LegacyTransition {\n  const exitStates = transition.exitStates ?? [];\n  return {\n    id: transition.id,\n    name: transition.name,\n    activateStates: transition.activateStates,\n    deactivateStates: exitStates,\n    // Modal-style transitions (no exit states) stay visible behind the\n    // activated state. Otherwise the originating state(s) deactivate, so the\n    // page no longer shows them.\n    staysVisible: exitStates.length === 0,\n    process: transition.actions.map(buildProcessStep),\n  };\n}\n\n/**\n * Build the legacy `stateMachine.states[]` entry for one IR state. Includes\n * any transitions that originate from this state (i.e. where state.id is in\n * transition.fromStates).\n */\nfunction buildStateMachineState(\n  state: IRState,\n  transitions: IRTransition[],\n  doc: IRDocument,\n): LegacyStateMachineState {\n  const outgoing = transitions\n    .filter((t) => t.fromStates.includes(state.id))\n    .map(buildTransition);\n  const isInitial =\n    state.isInitial !== undefined ? state.isInitial : state.id === doc.initialState;\n  return {\n    id: state.id,\n    name: state.name,\n    description: state.description ?? \"\",\n    // Project legacy `elements[]` from each assertion's target.criteria.\n    elements: state.assertions.map((a) =>\n      convertCriteria(a.target.criteria as IRElementCriteria),\n    ),\n    isInitial,\n    transitions: outgoing,\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Public entry point\n// ---------------------------------------------------------------------------\n\n/**\n * Project an IR document into the legacy bundled-page spec shape.\n *\n * Pure / deterministic: same input always produces structurally identical\n * output (and byte-identical when JSON-serialized via the standard\n * `JSON.stringify` ordering). Arrays preserve input order; object keys are\n * sorted lexicographically.\n *\n * @param doc   The IR document to project.\n * @param notes Optional human-authored notes (carried in the page's\n *              `notes.md` companion file). Appended to `description` as a\n *              separate paragraph (separator: two newlines).\n */\nexport function projectIRToBundledPage(doc: IRDocument, notes?: string): LegacySpec {\n  const baseDescription = doc.description ?? doc.name;\n  const description =\n    notes !== undefined && notes.length > 0\n      ? `${baseDescription}\\n\\n${notes}`\n      : baseDescription;\n\n  const component = doc.metadata?.purpose ?? doc.id;\n  const metadata: LegacyMetadata = { component };\n  if (doc.metadata?.tags !== undefined) metadata.tags = doc.metadata.tags;\n\n  const groups: LegacyGroup[] = doc.states.map(buildGroup);\n  if (doc.synthesizedGroups !== undefined) {\n    // Append synthesis-produced groups AFTER state-derived ones, in declared\n    // order. Byte-stable output (see file header) requires this exact ordering\n    // — anything else breaks `check-spec-pairing` style hashes.\n    for (const g of doc.synthesizedGroups) {\n      groups.push(synthesizedGroupToLegacy(g));\n    }\n  }\n  const smStates: LegacyStateMachineState[] = doc.states.map((s) =>\n    buildStateMachineState(s, doc.transitions, doc),\n  );\n\n  const spec: LegacySpec = {\n    version: \"1.0.0\",\n    description,\n    groups,\n    stateMachine: { states: smStates },\n    metadata,\n  };\n\n  return sortKeys(spec);\n}\n\n// ---------------------------------------------------------------------------\n// Inverse projection — Legacy spec -> IR document\n// ---------------------------------------------------------------------------\n\n/**\n * Options for the inverse projection.\n *\n * - `docId`        — explicit IRDocument.id override. Falls back to\n *                    `legacy.metadata.component` (or `fallbackName` if absent).\n * - `fallbackName` — used when `legacy.metadata.component` is missing AND no\n *                    `docId` was supplied.\n */\nexport interface ProjectLegacyToIROptions {\n  docId?: string;\n  fallbackName?: string;\n}\n\n/**\n * Best-effort field-by-field invert of `LegacyCriteria` back into\n * `IRElementCriteria`.\n *\n * Rename map (the structural inverse of `convertCriteria`):\n *   textContent     -> text\n *   accessibleName  -> accessibleName  (passes through; the forward direction\n *                                       collapses ariaLabel into accessibleName,\n *                                       so we cannot reliably distinguish them\n *                                       on the inverse — pick accessibleName).\n *   dataAttributes  -> attributes\n *   role / tagName / textContains / id pass through unchanged.\n *\n * Unknown legacy keys are dropped (lossy, but documented). Document-level\n * unknown criteria are rare; if they show up we'll surface them in Phase A4.\n */\nfunction invertCriteria(criteria: LegacyCriteria | undefined): IRElementCriteria {\n  if (criteria === undefined || criteria === null) return {};\n  const out: IRElementCriteria = {};\n  if (criteria.role !== undefined) out.role = criteria.role;\n  if (criteria.tagName !== undefined) out.tagName = criteria.tagName;\n  if (criteria.textContent !== undefined) out.text = criteria.textContent;\n  if (criteria.textContains !== undefined) out.textContains = criteria.textContains;\n  if (criteria.accessibleName !== undefined) out.accessibleName = criteria.accessibleName;\n  if (criteria.id !== undefined) out.id = criteria.id;\n  if (criteria.dataAttributes !== undefined) out.attributes = criteria.dataAttributes;\n  return out;\n}\n\n/**\n * Pick the first non-empty `precondition` across a group's assertions. Legacy\n * groups carry preconditions on individual assertions; IR carries it on the\n * state. If multiple distinct preconditions exist we keep the first\n * (deterministic, mirrors input ordering) — Phase A4 review will surface\n * conflicts for hand-fix.\n */\nfunction firstPrecondition(group: LegacyGroup): string | undefined {\n  for (const a of group.assertions) {\n    if (a.precondition !== undefined && a.precondition.length > 0) {\n      return a.precondition;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Build an `IRState` from one legacy group + its corresponding state-machine\n * state (when present).\n *\n * IMPORTANT: `requiredElements` is sourced from the GROUP's assertion criteria\n * (one criteria per assertion, in input order), NOT from `smState.elements`.\n * This preserves the round-trip identity for the assertion-count check —\n * legacy specs sometimes carry an SM block whose `elements[]` is a coarse\n * page-state fingerprint (1-2 entries) while the group has many assertions.\n * Using `smState.elements` would silently collapse those into one\n * requiredElement per state, then the forward direction would emit only one\n * assertion per group.\n *\n * `smState` (when present and matched by id) contributes:\n *   - `name` override (legacy `smState.name` is human-readable; group.name is\n *     also human-readable but may differ — prefer smState's name since the\n *     forward direction's `buildStateMachineState` echoes `state.name` to\n *     `smState.name`).\n *   - `description` fallback (when group.description is empty).\n *   - `isInitial` (the only place this lives in legacy specs).\n */\nfunction buildIRState(\n  group: LegacyGroup,\n  smState: LegacyStateMachineState | undefined,\n): IRState {\n  // Map each LegacyAssertion to an IRAssertion, preserving id/description/\n  // severity/category. target.criteria is normalized via invertCriteria so\n  // the criteria shape matches what the IR side stores.\n  const assertions: IRAssertion[] = group.assertions.map((a) => {\n    const ir: IRAssertion = {\n      id: a.id,\n      description: a.description,\n      category: a.category,\n      severity: a.severity,\n      assertionType: a.assertionType,\n      target: {\n        type: \"search\",\n        criteria: invertCriteria(a.target?.criteria) as unknown as Record<string, unknown>,\n        label: a.target?.label ?? a.description,\n      },\n      source: a.source,\n      reviewed: a.reviewed,\n      enabled: a.enabled,\n    };\n    if (a.precondition !== undefined) {\n      ir.precondition = a.precondition;\n    }\n    return ir;\n  });\n\n  const description =\n    group.description !== undefined && group.description.length > 0\n      ? group.description\n      : smState?.description;\n  const precondition = firstPrecondition(group);\n\n  const state: IRState = {\n    id: group.id,\n    name: smState?.name ?? group.name,\n    assertions,\n  };\n  if (description !== undefined && description.length > 0) {\n    state.description = description;\n  }\n  if (smState?.isInitial === true) {\n    state.isInitial = true;\n  } else if (smState?.isInitial === false) {\n    state.isInitial = false;\n  }\n  if (precondition !== undefined) {\n    state.precondition = precondition;\n  }\n  state.provenance = { source: \"migrated\" };\n  return state;\n}\n\n/**\n * Convert one legacy `process[]` step back into `IRTransitionAction`. Renames\n * `action` -> `type`. Legacy specs occasionally omit a target on no-op steps;\n * we coerce to an empty criteria object in that case.\n */\nfunction invertProcessStep(step: LegacyProcessStep): IRTransitionAction {\n  const out: IRTransitionAction = {\n    type: step.action,\n    target: invertCriteria(step.target),\n  };\n  if (step.waitAfter !== undefined) out.waitAfter = step.waitAfter;\n  return out;\n}\n\n/**\n * Collapse duplicate transitions across multiple originating states. The\n * forward projection emits the same transition under EACH `fromState`'s\n * `transitions[]` entry; the inverse must merge them back into ONE\n * `IRTransition` whose `fromStates` lists every originator.\n *\n * Same-id transitions are assumed to be byte-identical except for the\n * (implicit) originating state. If they differ in `process[]` /\n * `activateStates` / `deactivateStates`, we keep the first occurrence and\n * append the additional fromState. (Genuine divergence here is a defect to\n * surface in Phase A4 review.)\n */\nfunction buildIRTransitions(stateMachine: LegacyStateMachine | undefined): IRTransition[] {\n  if (stateMachine === undefined || !Array.isArray(stateMachine.states)) return [];\n  const byId = new Map<string, IRTransition>();\n  // Preserve insertion order — first state's transitions come first.\n  const order: string[] = [];\n\n  for (const smState of stateMachine.states) {\n    const transitions = Array.isArray(smState.transitions) ? smState.transitions : [];\n    for (const t of transitions) {\n      const existing = byId.get(t.id);\n      if (existing !== undefined) {\n        if (!existing.fromStates.includes(smState.id)) {\n          existing.fromStates.push(smState.id);\n        }\n        continue;\n      }\n      const ir: IRTransition = {\n        id: t.id,\n        name: t.name,\n        fromStates: [smState.id],\n        activateStates: Array.isArray(t.activateStates) ? [...t.activateStates] : [],\n        actions: Array.isArray(t.process) ? t.process.map(invertProcessStep) : [],\n      };\n      // The forward direction maps `exitStates` -> `deactivateStates`; preserve\n      // the field whenever it's present in legacy form (even if empty array)\n      // so modal-style transitions (staysVisible: true, deactivateStates: [])\n      // round-trip predictably.\n      if (Array.isArray(t.deactivateStates)) {\n        ir.exitStates = [...t.deactivateStates];\n      }\n      ir.provenance = { source: \"migrated\" };\n      byId.set(t.id, ir);\n      order.push(t.id);\n    }\n  }\n\n  return order.map((id) => byId.get(id)!);\n}\n\n/**\n * Project a legacy bundled-page spec back into IR.\n *\n * Pure / deterministic: same input always produces structurally identical\n * output. Collapses transition duplicates (forward emits one copy per\n * `fromState`), preserves group/assertion ordering, and tags every node with\n * `provenance.source = \"migrated\"` so downstream tooling can distinguish\n * migrated content from hand-authored.\n *\n * The mapping is the structural inverse of `projectIRToBundledPage`:\n *\n *   LegacySpec                                IRDocument\n *   ----------                                ----------\n *   metadata.component                  ->   id (or opts.docId override)\n *   metadata.tags                       ->   metadata.tags\n *   description                         ->   description (kept verbatim;\n *                                            authored notes appended via\n *                                            forward `notes` arg are not\n *                                            stripped — that round-trip is\n *                                            best-effort and Phase A4 will\n *                                            split them back out)\n *\n *   groups[]                            ->   states[] (one per group)\n *     group.id / name / description     ->   state.id / name / description\n *     assertion.target.criteria         ->   state.requiredElements[i] (or,\n *                                            preferred, smState.elements when\n *                                            the stateMachine block is present)\n *     first-found assertion.precondition ->  state.precondition\n *\n *   stateMachine.states[]               ->   contributes isInitial + elements\n *     smState.transitions[]             ->   transitions[] (deduped by id)\n *       transition.activateStates       ->   transition.activateStates\n *       transition.deactivateStates     ->   transition.exitStates\n *       transition.process[]            ->   transition.actions[]\n *         step.action                   ->   action.type\n *         step.target                   ->   action.target (criteria inverted)\n *         step.waitAfter                ->   action.waitAfter\n *\n * Documented losses (acceptable for Phase A2):\n *   - Legacy assertion ids (`{stateId}-elem-{i}`) are NOT preserved across the\n *     round-trip — the forward direction regenerates them from index, so any\n *     hand-edited ids are lost. See Phase A4.\n *   - Legacy `assertionType` / `severity` / `category` / `source` per\n *     assertion are reduced to defaults on round-trip.\n *   - Legacy `expected` / `assertionType: \"count\"` and `notExists` semantics\n *     are not modeled in IR — the assertion's criteria still survive (as a\n *     state requiredElement) but the assertion-flavor metadata is dropped.\n *   - Legacy `testing` block + extra metadata keys outside `component` /\n *     `tags` are ignored. Authors keep them via the legacy spec file directly\n *     during Phase A2 — they will move into IR companion files in Phase A4.\n *   - The forward `notes` argument's appended paragraph is currently kept\n *     in `description`; Phase A4 will split it back out into a dedicated\n *     companion file.\n *\n * @param legacy The legacy spec to invert.\n * @param opts   Optional doc-level overrides.\n */\nexport function projectLegacyToIR(\n  legacy: LegacySpec,\n  opts?: ProjectLegacyToIROptions,\n): IRDocument {\n  const component =\n    opts?.docId ??\n    legacy.metadata?.component ??\n    opts?.fallbackName ??\n    \"legacy-spec\";\n  const name = legacy.metadata?.component ?? opts?.fallbackName ?? component;\n\n  // Index state-machine states by id for quick lookup when building IR states\n  // out of groups. Older specs may not have a stateMachine block.\n  const smByGroupId = new Map<string, LegacyStateMachineState>();\n  if (legacy.stateMachine !== undefined && Array.isArray(legacy.stateMachine.states)) {\n    for (const s of legacy.stateMachine.states) {\n      smByGroupId.set(s.id, s);\n    }\n  }\n\n  const groups = Array.isArray(legacy.groups) ? legacy.groups : [];\n  const states: IRState[] = groups.map((group) =>\n    buildIRState(group, smByGroupId.get(group.id)),\n  );\n\n  // NOTE: Some legacy specs declare `stateMachine.states[]` whose ids do NOT\n  // correspond to any `groups[]` entry (e.g., page-level states like\n  // `wrappers-installed-tab` vs assertion-category groups like\n  // `page-structure`). The IR's group-state mapping is 1:1 with groups by\n  // construction (the forward projection emits one group per IR state), so\n  // these orphan SM states cannot survive the round-trip cleanly. They are\n  // dropped here as a documented loss — Phase A4 will revisit by either\n  // (a) introducing a separate IR concept for \"page state\" vs\n  // \"assertion group\", or (b) hand-merging the legacy specs so groups and\n  // SM states share ids.\n  // Transitions originating from orphan SM states are likewise omitted from\n  // IR (their fromStates would dangle). We filter them below.\n  const groupIds = new Set(groups.map((g) => g.id));\n\n  // Build transitions only from SM states whose ids appear in groups[]. Any\n  // transition with a fromState that isn't a known group is dropped — the\n  // forward direction would have nowhere to emit it.\n  let filteredStateMachine: LegacyStateMachine | undefined = legacy.stateMachine;\n  if (\n    legacy.stateMachine !== undefined &&\n    Array.isArray(legacy.stateMachine.states) &&\n    legacy.stateMachine.states.some((s) => !groupIds.has(s.id))\n  ) {\n    filteredStateMachine = {\n      states: legacy.stateMachine.states.filter((s) => groupIds.has(s.id)),\n    };\n  }\n  const transitions = buildIRTransitions(filteredStateMachine);\n\n  // Initial state: first state with isInitial:true wins (mirrors how the\n  // forward direction picks the document's `initialState`). Only consider\n  // SM states that correspond to a group (so initialState references a real\n  // IR state).\n  let initialState: string | undefined;\n  if (legacy.stateMachine !== undefined && Array.isArray(legacy.stateMachine.states)) {\n    const initial = legacy.stateMachine.states.find(\n      (s) => s.isInitial === true && groupIds.has(s.id),\n    );\n    if (initial !== undefined) initialState = initial.id;\n  }\n\n  const doc: IRDocument = {\n    version: \"1.0\",\n    id: component,\n    name,\n    states,\n    transitions,\n    provenance: { source: \"migrated\" },\n  };\n  if (legacy.description !== undefined && legacy.description.length > 0) {\n    doc.description = legacy.description;\n  }\n  if (legacy.metadata !== undefined && legacy.metadata.tags !== undefined) {\n    doc.metadata = { tags: legacy.metadata.tags };\n  }\n  if (initialState !== undefined) {\n    doc.initialState = initialState;\n  }\n  return doc;\n}\n"],"mappings":"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","names":[]}