@transitrix/cli 1.0.0

package/dist/cli.js

@@ -0,0 +1,3184 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire__ } from 'node:module'; const require = __createRequire__(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../src/package-version.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function cervinPackageVersion() {
+  try {
+    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const j = JSON.parse(readFileSync(pkgPath, "utf8"));
+    return typeof j.version === "string" ? j.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var init_package_version = __esm({
+  "../../src/package-version.ts"() {
+    "use strict";
+  }
+});
+
+// ../../src/emitter.ts
+import { create } from "xmlbuilder2";
+function collaborationId(processId) {
+  return `Collaboration_${processId}`;
+}
+function participantBpmnId(poolId) {
+  return `Participant_${poolId}`;
+}
+function appendFlowNode(parent, el, defaultFlowMap) {
+  const attrs = { id: el.id };
+  if (el.name) attrs.name = el.name;
+  if (defaultFlowMap?.has(el.id)) {
+    attrs.defaultFlowRef = defaultFlowMap.get(el.id);
+  }
+  parent.ele(el.type, attrs);
+}
+function emitBpmnXml(layout) {
+  const { process: process3 } = layout;
+  const collabId = collaborationId(process3.id);
+  const definitions = create({ version: "1.0", encoding: "UTF-8" }).ele("definitions", {
+    xmlns: BPMN_MODEL,
+    "xmlns:bpmndi": BPMN_DI,
+    "xmlns:dc": DC,
+    "xmlns:di": DI,
+    "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+    id: "Definitions_1",
+    targetNamespace: "http://bpmn.io/schema/bpmn",
+    exporter: "cervin",
+    exporterVersion: cervinPackageVersion()
+  });
+  const collaboration = definitions.ele("collaboration", { id: collabId });
+  collaboration.ele("participant", {
+    id: participantBpmnId(process3.poolId),
+    name: process3.poolName,
+    processRef: process3.id
+  });
+  const proc = definitions.ele("process", {
+    id: process3.id,
+    name: process3.name,
+    isExecutable: "false"
+  });
+  const laneSet = proc.ele("laneSet", { id: `LaneSet_${process3.id}` });
+  for (const lane of process3.lanes) {
+    const laneEl = laneSet.ele("lane", { id: lane.id, name: lane.name });
+    for (const el of lane.elements) {
+      laneEl.ele("flowNodeRef").txt(el.id);
+    }
+  }
+  const defaultFlowMap = /* @__PURE__ */ new Map();
+  for (const f of layout.flows) {
+    if (f.default) {
+      defaultFlowMap.set(f.from, f.id);
+    }
+  }
+  const sortedElements = [...process3.lanes.flatMap((l) => l.elements)].sort(
+    (a, b) => a.id.localeCompare(b.id)
+  );
+  for (const el of sortedElements) {
+    appendFlowNode(proc, el, defaultFlowMap);
+  }
+  const sortedFlows = [...layout.flows].sort((a, b) => a.id.localeCompare(b.id));
+  for (const f of sortedFlows) {
+    const attrs = { id: f.id, sourceRef: f.from, targetRef: f.to };
+    if (f.name) attrs.name = f.name;
+    const seq = proc.ele("sequenceFlow", attrs);
+    if (f.condition) {
+      seq.ele("conditionExpression", {
+        "xsi:type": "tFormalExpression"
+      }).txt(f.condition);
+    }
+  }
+  const diagram = definitions.ele("bpmndi:BPMNDiagram", { id: "BPMNDiagram_1" });
+  const plane = diagram.ele("bpmndi:BPMNPlane", {
+    id: "BPMNPlane_1",
+    bpmnElement: collabId
+  });
+  const pb = layout.poolBounds;
+  plane.ele("bpmndi:BPMNShape", {
+    id: `Shape_${participantBpmnId(process3.poolId)}`,
+    bpmnElement: participantBpmnId(process3.poolId),
+    isHorizontal: "true"
+  }).ele("dc:Bounds", {
+    x: String(pb.x),
+    y: String(pb.y),
+    width: String(pb.width),
+    height: String(pb.height)
+  });
+  for (const lane of process3.lanes) {
+    const lb = layout.laneBounds.get(lane.id);
+    if (!lb) throw new Error(`Missing layout bounds for lane ${lane.id}`);
+    plane.ele("bpmndi:BPMNShape", {
+      id: `Shape_Lane_${lane.id}`,
+      bpmnElement: lane.id,
+      isHorizontal: "true"
+    }).ele("dc:Bounds", {
+      x: String(lb.x),
+      y: String(lb.y),
+      width: String(lb.width),
+      height: String(lb.height)
+    });
+  }
+  for (const el of sortedElements) {
+    const b = layout.elements.get(el.id);
+    if (!b) throw new Error(`Missing layout bounds for flow node ${el.id}`);
+    const shapeAttrs = {
+      id: `Shape_${el.id}`,
+      bpmnElement: el.id
+    };
+    if (el.type === "exclusiveGateway" || el.type === "parallelGateway") {
+      shapeAttrs.isMarkerVisible = "true";
+    }
+    const shape = plane.ele("bpmndi:BPMNShape", shapeAttrs);
+    shape.ele("dc:Bounds", {
+      x: String(b.x),
+      y: String(b.y),
+      width: String(b.width),
+      height: String(b.height)
+    });
+  }
+  for (const f of sortedFlows) {
+    const edge = plane.ele("bpmndi:BPMNEdge", {
+      id: `Edge_${f.id}`,
+      bpmnElement: f.id
+    });
+    const wps = f.waypoints.length >= 2 ? f.waypoints : defaultWaypoints(layout, f.from, f.to);
+    for (const p of wps) {
+      edge.ele("di:waypoint", { x: String(Math.round(p.x)), y: String(Math.round(p.y)) });
+    }
+  }
+  return definitions.end({ prettyPrint: true });
+}
+function defaultWaypoints(layout, from, to) {
+  const a = layout.elements.get(from);
+  const b = layout.elements.get(to);
+  if (!a || !b) {
+    throw new Error(
+      `Layout invariant violated: missing bounds for flow "${from}" \u2192 "${to}" (${!a ? from : to} not found)`
+    );
+  }
+  return [
+    { x: a.x + a.width / 2, y: a.y + a.height / 2 },
+    { x: b.x + b.width / 2, y: b.y + b.height / 2 }
+  ];
+}
+var BPMN_MODEL, BPMN_DI, DC, DI;
+var init_emitter = __esm({
+  "../../src/emitter.ts"() {
+    "use strict";
+    init_package_version();
+    BPMN_MODEL = "http://www.omg.org/spec/BPMN/20100524/MODEL";
+    BPMN_DI = "http://www.omg.org/spec/BPMN/20100524/DI";
+    DC = "http://www.omg.org/spec/DD/20100524/DC";
+    DI = "http://www.omg.org/spec/DD/20100524/DI";
+  }
+});
+
+// ../../src/ir.ts
+var GATEWAY_TYPES;
+var init_ir = __esm({
+  "../../src/ir.ts"() {
+    "use strict";
+    GATEWAY_TYPES = /* @__PURE__ */ new Set(["exclusiveGateway", "parallelGateway"]);
+  }
+});
+
+// ../../src/layout-options.ts
+function clamp(n) {
+  return Math.min(BOUNDS.max, Math.max(BOUNDS.min, n));
+}
+function mergeLayoutDiagramOptions(partial) {
+  const d = DEFAULT_LAYOUT_DIAGRAM_OPTIONS;
+  if (!partial) return { ...d };
+  const pick = (k) => {
+    const v = partial[k];
+    if (v === void 0) return d[k];
+    if (typeof v !== "number" || !Number.isFinite(v)) return d[k];
+    return clamp(v);
+  };
+  return {
+    poolPad: pick("poolPad"),
+    poolOriginX: pick("poolOriginX"),
+    poolOriginY: pick("poolOriginY"),
+    participantLabelBand: pick("participantLabelBand"),
+    laneLabelWidth: pick("laneLabelWidth"),
+    laneVerticalGap: pick("laneVerticalGap"),
+    laneContentRightPad: pick("laneContentRightPad"),
+    elkNodeSpacing: pick("elkNodeSpacing"),
+    elkLayerSpacing: pick("elkLayerSpacing"),
+    elkDiagramPadding: pick("elkDiagramPadding")
+  };
+}
+function asFiniteNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() !== "") {
+    const n = Number(value);
+    if (Number.isFinite(n)) return n;
+  }
+  return void 0;
+}
+function parseLayoutDiagramOptionsFromJson(value) {
+  if (!value || typeof value !== "object") return {};
+  const o = value;
+  const out = {};
+  for (const k of LAYOUT_KEYS) {
+    const n = asFiniteNumber(o[k]);
+    if (n !== void 0) out[k] = n;
+  }
+  return out;
+}
+var DEFAULT_LAYOUT_DIAGRAM_OPTIONS, BOUNDS, LAYOUT_KEYS;
+var init_layout_options = __esm({
+  "../../src/layout-options.ts"() {
+    "use strict";
+    DEFAULT_LAYOUT_DIAGRAM_OPTIONS = {
+      poolPad: 40,
+      poolOriginX: 12,
+      poolOriginY: 12,
+      participantLabelBand: 48,
+      laneLabelWidth: 72,
+      laneVerticalGap: 40,
+      laneContentRightPad: 40,
+      elkNodeSpacing: 52,
+      elkLayerSpacing: 88,
+      elkDiagramPadding: 44
+    };
+    BOUNDS = { min: 0, max: 800 };
+    LAYOUT_KEYS = [
+      "poolPad",
+      "poolOriginX",
+      "poolOriginY",
+      "participantLabelBand",
+      "laneLabelWidth",
+      "laneVerticalGap",
+      "laneContentRightPad",
+      "elkNodeSpacing",
+      "elkLayerSpacing",
+      "elkDiagramPadding"
+    ];
+  }
+});
+
+// ../../src/schema-path.ts
+import { dirname as dirname2, join as join2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function dslSchemaPath(fromImportMetaUrl) {
+  const here = dirname2(fileURLToPath2(fromImportMetaUrl));
+  return join2(here, "..", "schemas", "bpmn-dsl.schema.json");
+}
+var init_schema_path = __esm({
+  "../../src/schema-path.ts"() {
+    "use strict";
+  }
+});
+
+// ../../src/parser.ts
+import { createRequire } from "node:module";
+import { readFileSync as readFileSync2 } from "node:fs";
+import yaml from "js-yaml";
+function formatAjvErrors() {
+  const e = validateRaw.errors;
+  if (!e?.length) return [];
+  return e.map(
+    (err) => `${err.instancePath || "/"} ${err.message ?? err.keyword}`.trim()
+  );
+}
+function validateDocument(data) {
+  if (!validateRaw(data)) {
+    const err = new Error("DSL validation failed");
+    err.errors = formatAjvErrors();
+    throw err;
+  }
+}
+function collectElements(doc) {
+  const p = doc.process;
+  if (p.pools.length !== 1) {
+    throw new Error(
+      p.pools.length === 0 ? "At least one pool is required." : `Multiple pools are not supported (found ${p.pools.length}). Use a single pool per process.`
+    );
+  }
+  const pool = p.pools[0];
+  const seen = /* @__PURE__ */ new Set();
+  const lanes = pool.lanes.map((lane) => ({
+    id: lane.id,
+    name: lane.name,
+    elements: lane.elements.map((el) => {
+      if (seen.has(el.id)) {
+        throw new Error(`Duplicate element id: ${el.id}`);
+      }
+      seen.add(el.id);
+      return {
+        id: el.id,
+        type: el.type,
+        name: el.name,
+        poolId: pool.id,
+        laneId: lane.id
+      };
+    })
+  }));
+  if (seen.has(pool.id)) {
+    throw new Error(`Pool id must differ from element ids: ${pool.id}`);
+  }
+  for (const lane of pool.lanes) {
+    if (seen.has(lane.id)) {
+      throw new Error(`Lane id must differ from element ids: ${lane.id}`);
+    }
+  }
+  const explicitFlowIds = new Set(p.flows.filter((f) => f.id != null).map((f) => f.id));
+  let autoIdx = 1;
+  const flows = p.flows.map((f) => {
+    let id;
+    if (f.id != null) {
+      id = f.id;
+    } else {
+      while (explicitFlowIds.has(`Flow_${autoIdx}`)) autoIdx++;
+      id = `Flow_${autoIdx++}`;
+    }
+    return { id, from: f.from, to: f.to, condition: f.condition, default: f.default, name: f.name };
+  });
+  const seenFlowIds = /* @__PURE__ */ new Set();
+  for (const f of flows) {
+    if (seenFlowIds.has(f.id)) {
+      throw new Error(`Duplicate flow id: ${f.id}`);
+    }
+    seenFlowIds.add(f.id);
+  }
+  for (const f of flows) {
+    if (f.from === f.to) {
+      throw new Error(`Self-loop flow is not supported: element "${f.from}" references itself`);
+    }
+    if (!seen.has(f.from)) {
+      throw new Error(`Flow references unknown element (from): ${f.from}`);
+    }
+    if (!seen.has(f.to)) {
+      throw new Error(`Flow references unknown element (to): ${f.to}`);
+    }
+  }
+  return {
+    id: p.id,
+    name: p.name,
+    poolId: pool.id,
+    poolName: pool.name,
+    lanes,
+    flows
+  };
+}
+function parseYamlToIr(yamlText) {
+  const data = yaml.load(yamlText);
+  validateDocument(data);
+  return collectElements(data);
+}
+function elkNodeSize(kind) {
+  switch (kind) {
+    case "startEvent":
+    case "endEvent":
+      return { x: 0, y: 0, width: 36, height: 36 };
+    case "exclusiveGateway":
+    case "parallelGateway":
+      return { x: 0, y: 0, width: 50, height: 50 };
+    default:
+      return { x: 0, y: 0, width: 100, height: 80 };
+  }
+}
+var SCHEMA, require2, Ajv, addFormats, ajv, validateRaw;
+var init_parser = __esm({
+  "../../src/parser.ts"() {
+    "use strict";
+    init_schema_path();
+    SCHEMA = JSON.parse(readFileSync2(dslSchemaPath(import.meta.url), "utf8"));
+    require2 = createRequire(import.meta.url);
+    Ajv = require2("ajv");
+    addFormats = require2("ajv-formats");
+    ajv = new Ajv({ allErrors: true, strict: false });
+    addFormats(ajv);
+    validateRaw = ajv.compile(SCHEMA);
+  }
+});
+
+// ../../src/layout.ts
+import { createRequire as createRequire2 } from "node:module";
+function portPoint(b, port) {
+  const cx = b.x + b.width / 2;
+  const cy = b.y + b.height / 2;
+  switch (port) {
+    case "left":
+      return { x: b.x, y: cy };
+    case "right":
+      return { x: b.x + b.width, y: cy };
+    case "top":
+      return { x: cx, y: b.y };
+    case "bottom":
+      return { x: cx, y: b.y + b.height };
+  }
+}
+function laneElkLayoutOptions(o) {
+  const p = o.elkDiagramPadding;
+  return {
+    "elk.algorithm": "layered",
+    "elk.direction": "RIGHT",
+    "elk.spacing.nodeNode": String(o.elkNodeSpacing),
+    "elk.layered.spacing.nodeNodeBetweenLayers": String(o.elkLayerSpacing),
+    "elk.padding": `[${p},${p},${p},${p}]`,
+    "elk.edgeRouting": "ORTHOGONAL"
+  };
+}
+function elementIdSet(ir) {
+  const s = /* @__PURE__ */ new Set();
+  for (const lane of ir.lanes) {
+    for (const el of lane.elements) s.add(el.id);
+  }
+  return s;
+}
+function collectElementLaneMap(ir) {
+  const m = /* @__PURE__ */ new Map();
+  for (const lane of ir.lanes) {
+    for (const el of lane.elements) m.set(el.id, lane.id);
+  }
+  return m;
+}
+function collectGraphicBounds(elkOut, ids) {
+  const out = /* @__PURE__ */ new Map();
+  function visit(n, ox, oy) {
+    const x = ox + (n.x ?? 0);
+    const y = oy + (n.y ?? 0);
+    const w = n.width ?? 0;
+    const h = n.height ?? 0;
+    const hasChildren = Boolean(n.children?.length);
+    if (ids.has(n.id) && w > 0 && h > 0 && !hasChildren) {
+      out.set(n.id, { x, y, width: w, height: h });
+    }
+    if (hasChildren) {
+      for (const c of n.children ?? []) visit(c, x, y);
+    }
+  }
+  visit(elkOut, 0, 0);
+  return out;
+}
+function boundsEnvelope(map) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const b of map.values()) {
+    minX = Math.min(minX, b.x);
+    minY = Math.min(minY, b.y);
+    maxX = Math.max(maxX, b.x + b.width);
+    maxY = Math.max(maxY, b.y + b.height);
+  }
+  if (!Number.isFinite(minX)) return { x: 0, y: 0, width: 0, height: 0 };
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function dedupePoints(pts) {
+  const res = [];
+  for (const p of pts) {
+    const last = res[res.length - 1];
+    if (last && last.x === p.x && last.y === p.y) continue;
+    res.push(p);
+  }
+  return res;
+}
+function diagonalFallbackRects(a, b) {
+  return [
+    { x: a.x + a.width / 2, y: a.y + a.height / 2 },
+    { x: b.x + b.width / 2, y: b.y + b.height / 2 }
+  ];
+}
+function routeSameLane(fromB, toB, exitYOffset = 0, exitPort = "right", isSourceGateway = false) {
+  const backward = toB.x + toB.width < fromB.x + CROSS_LANE_EDGE_OVERLAP_EPSILON_PX;
+  if (backward) {
+    const arcX = Math.min(fromB.x, toB.x) - BACKWARD_LOOP_CLEARANCE_PX;
+    return dedupePoints([
+      { x: fromB.x, y: fromB.y + fromB.height / 2 },
+      { x: arcX, y: fromB.y + fromB.height / 2 },
+      { x: arcX, y: toB.y + toB.height / 2 },
+      { x: toB.x, y: toB.y + toB.height / 2 }
+    ]);
+  }
+  if (exitPort !== "right") {
+    const ep = portPoint(fromB, exitPort);
+    const ip = portPoint(toB, "left");
+    if (exitPort === "top" || exitPort === "bottom") {
+      return dedupePoints([ep, { x: ep.x, y: ip.y }, ip]);
+    }
+    const midX2 = (ep.x + ip.x) / 2;
+    return dedupePoints([ep, { x: midX2, y: ep.y }, { x: midX2, y: ip.y }, ip]);
+  }
+  const ex = fromB.x + fromB.width;
+  const ey = fromB.y + fromB.height / 2 + exitYOffset;
+  const ix = toB.x;
+  const iy = toB.y + toB.height / 2;
+  if (exitYOffset === 0 && Math.abs(ey - iy) < 1) return [{ x: ex, y: ey }, { x: ix, y: iy }];
+  if (exitYOffset === 0 && Math.abs(ey - iy) < GATEWAY_BRANCH_CLEARANCE_PX) {
+    const approachX = ix - GATEWAY_BRANCH_CLEARANCE_PX;
+    return dedupePoints([{ x: ex, y: ey }, { x: approachX, y: ey }, { x: approachX, y: iy }, { x: ix, y: iy }]);
+  }
+  const midX = (ex + ix) / 2;
+  return dedupePoints([{ x: ex, y: ey }, { x: midX, y: ey }, { x: midX, y: iy }, { x: ix, y: iy }]);
+}
+function routeCrossLane(fromB, toB, fromLaneBound, toLaneBound, exitPort = "right", laneVerticalGap = 40) {
+  const targetBelow = toB.y >= fromB.y + fromB.height - CROSS_LANE_EDGE_OVERLAP_EPSILON_PX;
+  const targetAbove = toB.y + toB.height <= fromB.y + CROSS_LANE_EDGE_OVERLAP_EPSILON_PX;
+  const targetClearlyLeft = toB.x + toB.width / 2 < fromB.x - fromB.width / 2;
+  if ((targetBelow || targetAbove) && !targetClearlyLeft) {
+    const ep = portPoint(fromB, exitPort === "bottom" || exitPort === "top" ? exitPort : "right");
+    const ix2 = toB.x;
+    const iy2 = toB.y + toB.height / 2;
+    if (exitPort === "bottom" || exitPort === "top") {
+      if (!fromLaneBound) return diagonalFallbackRects(fromB, toB);
+      const chanY = targetBelow ? fromLaneBound.y + fromLaneBound.height + laneVerticalGap / 2 : fromLaneBound.y - laneVerticalGap / 2;
+      const approachX2 = ix2 - GATEWAY_BRANCH_CLEARANCE_PX;
+      return dedupePoints([
+        ep,
+        { x: ep.x, y: chanY },
+        // vertical to inter-lane gap
+        { x: approachX2, y: chanY },
+        // horizontal along gap to approach column
+        { x: approachX2, y: iy2 },
+        // vertical to target centre Y
+        { x: ix2, y: iy2 }
+        // horizontal into target left vertex
+      ]);
+    }
+    const approachX = ix2 - GATEWAY_BRANCH_CLEARANCE_PX;
+    return dedupePoints([
+      ep,
+      { x: approachX, y: ep.y },
+      { x: approachX, y: iy2 },
+      { x: ix2, y: iy2 }
+    ]);
+  }
+  if (targetBelow || targetAbove) {
+    const arcX = Math.min(fromB.x, toB.x) - BACKWARD_LOOP_CLEARANCE_PX;
+    return dedupePoints([
+      { x: fromB.x, y: fromB.y + fromB.height / 2 },
+      { x: arcX, y: fromB.y + fromB.height / 2 },
+      { x: arcX, y: toB.y + toB.height / 2 },
+      { x: toB.x, y: toB.y + toB.height / 2 }
+    ]);
+  }
+  const ex = fromB.x + fromB.width;
+  const ey = fromB.y + fromB.height / 2;
+  const ix = toB.x;
+  const iy = toB.y + toB.height / 2;
+  const midX = (ex + ix) / 2;
+  return dedupePoints([{ x: ex, y: ey }, { x: midX, y: ey }, { x: midX, y: iy }, { x: ix, y: iy }]);
+}
+function buildGlobalGraph(ir, elkOpts) {
+  return {
+    id: "__global",
+    layoutOptions: elkOpts,
+    children: ir.lanes.flatMap(
+      (lane) => lane.elements.map((el) => {
+        const { width, height } = elkNodeSize(el.type);
+        return { id: el.id, width, height };
+      })
+    ),
+    edges: ir.flows.map((f) => ({ id: f.id, sources: [f.from], targets: [f.to] }))
+  };
+}
+function buildLaneGraph(laneId, els, internal, elkOpts) {
+  return {
+    id: `laneRoot_${laneId}`,
+    layoutOptions: elkOpts,
+    children: els.map((el) => {
+      const { width, height } = elkNodeSize(el.type);
+      return { id: el.id, width, height };
+    }),
+    edges: internal.map((f) => ({ id: f.id, sources: [f.from], targets: [f.to] }))
+  };
+}
+async function layoutProcess(ir, layoutOpts) {
+  const o = mergeLayoutDiagramOptions(layoutOpts ?? {});
+  const elkOpts = laneElkLayoutOptions(o);
+  const ids = elementIdSet(ir);
+  const elementLane = collectElementLaneMap(ir);
+  const globalElkOut = await elk.layout(buildGlobalGraph(ir, elkOpts));
+  const globalBounds = collectGraphicBounds(globalElkOut, ids);
+  const globalMinX = Math.min(...[...globalBounds.values()].map((b) => b.x));
+  const contentW = Math.max(
+    ...[...globalBounds.values()].map((b) => b.x - globalMinX + b.width),
+    100
+  );
+  const laneData = await Promise.all(
+    ir.lanes.map(async (lane) => {
+      const internalFlows = ir.flows.filter(
+        (f) => elementLane.get(f.from) === lane.id && elementLane.get(f.to) === lane.id
+      );
+      const graph = buildLaneGraph(lane.id, lane.elements, internalFlows, elkOpts);
+      const elkOut = await elk.layout(graph);
+      const graphic = collectGraphicBounds(elkOut, ids);
+      const env = boundsEnvelope(graphic);
+      const localY = new Map(
+        [...graphic.entries()].map(([id, b]) => [id, b.y - env.y])
+      );
+      return { laneId: lane.id, height: elkOut.height ?? env.height, localY, envY: env.y };
+    })
+  );
+  const laneOriginX = o.poolPad + o.participantLabelBand;
+  const laneLocalItems = /* @__PURE__ */ new Map();
+  for (const ld of laneData) {
+    const laneDef = ir.lanes.find((l) => l.id === ld.laneId);
+    if (!laneDef) throw new Error(`Layout invariant violated: lane "${ld.laneId}" not found in IR`);
+    const items = [];
+    for (const el of laneDef.elements) {
+      const gb = globalBounds.get(el.id);
+      if (!gb) continue;
+      items.push({
+        id: el.id,
+        x: laneOriginX + o.laneLabelWidth + (gb.x - globalMinX),
+        // Ensure at least elkDiagramPadding of top margin so backward arc clearance
+        // (BACKWARD_LOOP_CLEARANCE_PX = 32) always stays inside the lane boundary.
+        localY: Math.max((ld.localY.get(el.id) ?? 0) + ld.envY, o.elkDiagramPadding),
+        width: gb.width,
+        height: gb.height
+      });
+    }
+    laneLocalItems.set(ld.laneId, items);
+  }
+  for (const items of laneLocalItems.values()) {
+    const byColumn = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      const col = Math.round(item.x);
+      const arr = byColumn.get(col) ?? [];
+      arr.push(item);
+      byColumn.set(col, arr);
+    }
+    for (const col of byColumn.values()) {
+      if (col.length <= 1) continue;
+      col.sort((a, b) => a.localY - b.localY);
+      for (let i = 1; i < col.length; i++) {
+        const prev = col[i - 1];
+        const curr = col[i];
+        const minY = prev.localY + prev.height + o.elkNodeSpacing;
+        if (curr.localY < minY) curr.localY = minY;
+      }
+    }
+  }
+  let yCursor = o.poolPad;
+  const elements = /* @__PURE__ */ new Map();
+  const laneBounds = /* @__PURE__ */ new Map();
+  for (const ld of laneData) {
+    const items = laneLocalItems.get(ld.laneId) ?? [];
+    for (const item of items) {
+      elements.set(item.id, {
+        x: item.x,
+        y: yCursor + item.localY,
+        width: item.width,
+        height: item.height
+      });
+    }
+    const contentBottom = items.length > 0 ? Math.max(...items.map((item) => item.localY + item.height)) : 0;
+    const laneHeight = Math.max(ld.height, contentBottom + ld.envY);
+    laneBounds.set(ld.laneId, {
+      x: laneOriginX,
+      y: yCursor,
+      width: o.laneLabelWidth + contentW + o.laneContentRightPad,
+      height: laneHeight
+    });
+    yCursor += laneHeight + o.laneVerticalGap;
+  }
+  const innerBottom = yCursor - o.laneVerticalGap;
+  const participantW = o.poolPad * 2 + o.participantLabelBand + o.laneLabelWidth + contentW + o.laneContentRightPad;
+  const participantH = innerBottom + o.poolPad;
+  const poolBounds = {
+    x: o.poolOriginX,
+    y: o.poolOriginY,
+    width: participantW,
+    height: participantH
+  };
+  for (const lb of laneBounds.values()) {
+    lb.width = participantW - 2 * o.poolPad;
+  }
+  for (const [laneId, items] of laneLocalItems) {
+    const lb = laneBounds.get(laneId);
+    if (!lb) continue;
+    const axisY = lb.y + lb.height / 2;
+    const byColumn = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      const col = Math.round(item.x);
+      const arr = byColumn.get(col) ?? [];
+      arr.push(item);
+      byColumn.set(col, arr);
+    }
+    for (const col of byColumn.values()) {
+      if (col.length !== 1) continue;
+      const item = col[0];
+      const el = elements.get(item.id);
+      if (!el) continue;
+      let snapMinY = lb.y + BACKWARD_LOOP_CLEARANCE_PX;
+      let snapMaxY = lb.y + lb.height - item.height - BACKWARD_LOOP_CLEARANCE_PX;
+      if (snapMinY > snapMaxY) {
+        snapMinY = lb.y + 4;
+        snapMaxY = lb.y + lb.height - item.height - 4;
+      }
+      const snappedY = Math.max(snapMinY, Math.min(snapMaxY, axisY - item.height / 2));
+      elements.set(item.id, { ...el, y: snappedY });
+    }
+  }
+  const elementTypeMap = /* @__PURE__ */ new Map();
+  for (const lane of ir.lanes) {
+    for (const el of lane.elements) elementTypeMap.set(el.id, el.type);
+  }
+  const flowExitPort = /* @__PURE__ */ new Map();
+  const fwdSameLaneBySource = /* @__PURE__ */ new Map();
+  for (const f of ir.flows) {
+    const fb = elements.get(f.from);
+    const tb = elements.get(f.to);
+    if (!fb || !tb) continue;
+    if (elementLane.get(f.from) !== elementLane.get(f.to)) continue;
+    if (!GATEWAY_TYPES.has(elementTypeMap.get(f.from) ?? "")) continue;
+    const backward = tb.x + tb.width < fb.x + CROSS_LANE_EDGE_OVERLAP_EPSILON_PX;
+    if (backward) continue;
+    const arr = fwdSameLaneBySource.get(f.from) ?? [];
+    arr.push({ id: f.id, toB: tb });
+    fwdSameLaneBySource.set(f.from, arr);
+  }
+  for (const f of ir.flows) {
+    const fb = elements.get(f.from);
+    const tb = elements.get(f.to);
+    if (!fb || !tb) continue;
+    if (elementLane.get(f.from) === elementLane.get(f.to)) continue;
+    if (!GATEWAY_TYPES.has(elementTypeMap.get(f.from) ?? "")) continue;
+    const targetClearlyLeft = tb.x + tb.width / 2 < fb.x - fb.width / 2;
+    if (targetClearlyLeft) continue;
+    const targetBelow = tb.y >= fb.y + fb.height - CROSS_LANE_EDGE_OVERLAP_EPSILON_PX;
+    const targetAbove = tb.y + tb.height <= fb.y + CROSS_LANE_EDGE_OVERLAP_EPSILON_PX;
+    if (targetBelow) flowExitPort.set(f.id, "bottom");
+    else if (targetAbove) flowExitPort.set(f.id, "top");
+  }
+  const flowExitYOffset = /* @__PURE__ */ new Map();
+  const sameLaneFwdByNonGwSource = /* @__PURE__ */ new Map();
+  for (const f of ir.flows) {
+    const fb = elements.get(f.from);
+    const tb = elements.get(f.to);
+    if (!fb || !tb) continue;
+    if (elementLane.get(f.from) !== elementLane.get(f.to)) continue;
+    if (GATEWAY_TYPES.has(elementTypeMap.get(f.from) ?? "")) continue;
+    const backward = tb.x + tb.width < fb.x + CROSS_LANE_EDGE_OVERLAP_EPSILON_PX;
+    if (backward) continue;
+    const arr = sameLaneFwdByNonGwSource.get(f.from) ?? [];
+    arr.push({ id: f.id, targetX: tb.x });
+    sameLaneFwdByNonGwSource.set(f.from, arr);
+  }
+  for (const flows2 of sameLaneFwdByNonGwSource.values()) {
+    if (flows2.length <= 1) continue;
+    flows2.sort((a, b) => a.targetX - b.targetX);
+    const totalSpread = (flows2.length - 1) * MULTI_EXIT_OFFSET_STEP_PX;
+    flows2.forEach((f, i) => {
+      flowExitYOffset.set(f.id, -totalSpread / 2 + i * MULTI_EXIT_OFFSET_STEP_PX);
+    });
+  }
+  const GATEWAY_VERTEX_THRESHOLD_PX = 10;
+  for (const [sourceId, flows2] of fwdSameLaneBySource) {
+    if (flows2.length <= 1) continue;
+    const gwB = elements.get(sourceId);
+    const gwCY = gwB.y + gwB.height / 2;
+    const above = flows2.filter((f) => f.toB.y + f.toB.height / 2 < gwCY - GATEWAY_VERTEX_THRESHOLD_PX).sort((a, b) => a.toB.y + a.toB.height / 2 - (b.toB.y + b.toB.height / 2));
+    const below = flows2.filter((f) => f.toB.y + f.toB.height / 2 > gwCY + GATEWAY_VERTEX_THRESHOLD_PX).sort((a, b) => b.toB.y + b.toB.height / 2 - (a.toB.y + a.toB.height / 2));
+    if (above.length > 0) flowExitPort.set(above[0].id, "top");
+    if (below.length > 0) flowExitPort.set(below[0].id, "bottom");
+    const rightFlows = [
+      ...above.slice(1),
+      ...flows2.filter(
+        (f) => Math.abs(f.toB.y + f.toB.height / 2 - gwCY) <= GATEWAY_VERTEX_THRESHOLD_PX
+      ),
+      ...below.slice(1)
+    ].sort((a, b) => a.toB.y - b.toB.y);
+    if (rightFlows.length > 1) {
+      const total = (rightFlows.length - 1) * MULTI_EXIT_OFFSET_STEP_PX;
+      rightFlows.forEach((f, i) => {
+        flowExitYOffset.set(f.id, -total / 2 + i * MULTI_EXIT_OFFSET_STEP_PX);
+      });
+    }
+  }
+  const flows = ir.flows.map((f) => {
+    const fb = elements.get(f.from);
+    const tb = elements.get(f.to);
+    let wps = [];
+    if (fb && tb) {
+      const fromL = elementLane.get(f.from);
+      const toL = elementLane.get(f.to);
+      const exitOffset = flowExitYOffset.get(f.id) ?? 0;
+      const exitPort = flowExitPort.get(f.id) ?? "right";
+      const fromLaneBound = fromL ? laneBounds.get(fromL) : void 0;
+      const toLaneBound = toL ? laneBounds.get(toL) : void 0;
+      const isSourceGateway = GATEWAY_TYPES.has(elementTypeMap.get(f.from) ?? "");
+      wps = fromL === toL ? routeSameLane(fb, tb, exitOffset, exitPort, isSourceGateway) : routeCrossLane(fb, tb, fromLaneBound, toLaneBound, exitPort, o.laneVerticalGap);
+      if (wps.length < 2) wps = diagonalFallbackRects(fb, tb);
+    }
+    return { ...f, waypoints: wps };
+  });
+  flows.sort((a, b) => a.id.localeCompare(b.id));
+  return { process: ir, elements, laneBounds, poolBounds, flows };
+}
+var require3, ELKCtor, elk, CROSS_LANE_EDGE_OVERLAP_EPSILON_PX, BACKWARD_LOOP_CLEARANCE_PX, MULTI_EXIT_OFFSET_STEP_PX, GATEWAY_BRANCH_CLEARANCE_PX;
+var init_layout = __esm({
+  "../../src/layout.ts"() {
+    "use strict";
+    init_ir();
+    init_layout_options();
+    init_parser();
+    require3 = createRequire2(import.meta.url);
+    ELKCtor = require3("elkjs/lib/elk.bundled.js");
+    elk = new ELKCtor();
+    CROSS_LANE_EDGE_OVERLAP_EPSILON_PX = 4;
+    BACKWARD_LOOP_CLEARANCE_PX = 32;
+    MULTI_EXIT_OFFSET_STEP_PX = 8;
+    GATEWAY_BRANCH_CLEARANCE_PX = 20;
+  }
+});
+
+// ../../src/validator.ts
+function validateProcess(ir, config) {
+  return validator.validate(ir, config);
+}
+var ValidatorRegistry, validator, rule_SE_001_StartEventExists, rule_SE_003_NoIncomingToStart, rule_SE_004_OneOutgoingFromStart, rule_EE_001_EndEventExists, rule_EE_003_NoOutgoingFromEnd, rule_EE_004_IncomingToEnd, rule_ACT_001_TaskConnectivity, rule_CONN_001_ElementReachability, rule_CONN_002_GraphConnectivity, rule_SF_005_ConditionSourceRestriction, rule_SF_006_DefaultFlowSourceRestriction, rule_SF_007_DefaultAndConditionExclusive, rule_GW_XOR_001_SingleInSingleOutForbidden, rule_GW_XOR_002_SplitConstraints, rule_GW_AND_004_NoConditionsOnParallelSplit, rule_AP_FloatingElements, rule_AP_MissingDefaultOnConditionalXor, rule_AP_ImplicitJoin, IMPERATIVE_VERBS, rule_AP_GatewayAsTask, rule_SF_DUP_NoDuplicateFlows, rule_SF_01_ValidFlowEndpoints;
+var init_validator = __esm({
+  "../../src/validator.ts"() {
+    "use strict";
+    ValidatorRegistry = class {
+      rules = /* @__PURE__ */ new Map();
+      /**
+       * Register a new validation rule.
+       * @param rule The validation rule to register.
+       */
+      register(rule) {
+        this.rules.set(rule.ruleId, rule);
+      }
+      /**
+       * Deregister a validation rule by ID.
+       * @param ruleId ID of the rule to remove.
+       */
+      deregister(ruleId) {
+        this.rules.delete(ruleId);
+      }
+      /**
+       * Get all registered rule IDs.
+       */
+      getRuleIds() {
+        return Array.from(this.rules.keys());
+      }
+      /**
+       * Get the rules map (for config validation and introspection).
+       * Used by RD-097 config loader to enforce severity constraints.
+       */
+      getRules() {
+        return this.rules;
+      }
+      /**
+       * Validate a ProcessIr against all registered rules.
+       * @param ir The ProcessIr to validate.
+       * @param config Optional validator configuration (e.g., filter rules).
+       * @returns ValidationReport with findings and summary.
+       */
+      validate(ir, config) {
+        const findings = [];
+        let rulesToRun = Array.from(this.rules.values());
+        if (config?.enabledRules) {
+          rulesToRun = rulesToRun.filter(
+            (rule) => config.enabledRules.has(rule.ruleId)
+          );
+        }
+        for (const rule of rulesToRun) {
+          findings.push(...rule.validate(ir));
+        }
+        const severityOrder = {
+          error: 0,
+          warning: 1,
+          info: 2
+        };
+        findings.sort(
+          (a, b) => severityOrder[a.severity] - severityOrder[b.severity]
+        );
+        return {
+          isValid: !findings.some((f) => f.severity === "error"),
+          findings,
+          summary: {
+            errorCount: findings.filter((f) => f.severity === "error").length,
+            warningCount: findings.filter((f) => f.severity === "warning").length,
+            infoCount: findings.filter((f) => f.severity === "info").length
+          }
+        };
+      }
+    };
+    validator = new ValidatorRegistry();
+    rule_SE_001_StartEventExists = {
+      ruleId: "SE-001",
+      severity: "error",
+      description: "Process must have at least one start event",
+      validate(ir) {
+        const startEvents = ir.lanes.flatMap((lane) => lane.elements).filter((el) => el.type === "startEvent");
+        if (startEvents.length === 0) {
+          return [
+            {
+              ruleId: "SE-001",
+              severity: "error",
+              message: "Process must have at least one start event",
+              hint: "Add a start event to begin process flow",
+              docUrl: "docs/validation.md#se-001"
+            }
+          ];
+        }
+        return [];
+      }
+    };
+    rule_SE_003_NoIncomingToStart = {
+      ruleId: "SE-003",
+      severity: "error",
+      description: "Start events must not have incoming flows",
+      validate(ir) {
+        const startEvents = ir.lanes.flatMap((lane) => lane.elements).filter((el) => el.type === "startEvent");
+        const findings = [];
+        for (const start of startEvents) {
+          const hasIncoming = ir.flows.some((flow) => flow.to === start.id);
+          if (hasIncoming) {
+            findings.push({
+              ruleId: "SE-003",
+              severity: "error",
+              elementId: start.id,
+              message: `Start event "${start.name || start.id}" must not have incoming flows`,
+              hint: "Remove flows targeting this start event; it is an entry point only",
+              docUrl: "docs/validation.md#se-003"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    rule_SE_004_OneOutgoingFromStart = {
+      ruleId: "SE-004",
+      severity: "error",
+      description: "Start events must have exactly one outgoing flow",
+      validate(ir) {
+        const startEvents = ir.lanes.flatMap((lane) => lane.elements).filter((el) => el.type === "startEvent");
+        const findings = [];
+        for (const start of startEvents) {
+          const outgoingCount = ir.flows.filter((flow) => flow.from === start.id).length;
+          if (outgoingCount !== 1) {
+            const message = outgoingCount === 0 ? `Start event "${start.name || start.id}" must have an outgoing flow` : `Start event "${start.name || start.id}" must have exactly one outgoing flow (found ${outgoingCount})`;
+            const hint = outgoingCount === 0 ? "Add a flow from this start event to the first process activity" : `Remove ${outgoingCount - 1} extra flow(s) from this start event; use a gateway if multiple paths are needed`;
+            findings.push({
+              ruleId: "SE-004",
+              severity: "error",
+              elementId: start.id,
+              message,
+              hint,
+              docUrl: "docs/validation.md#se-004"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    validator.register(rule_SE_001_StartEventExists);
+    validator.register(rule_SE_003_NoIncomingToStart);
+    validator.register(rule_SE_004_OneOutgoingFromStart);
+    rule_EE_001_EndEventExists = {
+      ruleId: "EE-001",
+      severity: "error",
+      description: "Process must have at least one end event",
+      validate(ir) {
+        const endEvents = ir.lanes.flatMap((lane) => lane.elements).filter((el) => el.type === "endEvent");
+        if (endEvents.length === 0) {
+          return [
+            {
+              ruleId: "EE-001",
+              severity: "error",
+              message: "Process must have at least one end event",
+              hint: "Add an end event to define process termination",
+              docUrl: "docs/validation.md#ee-001"
+            }
+          ];
+        }
+        return [];
+      }
+    };
+    rule_EE_003_NoOutgoingFromEnd = {
+      ruleId: "EE-003",
+      severity: "error",
+      description: "End events must not have outgoing flows",
+      validate(ir) {
+        const endEvents = ir.lanes.flatMap((lane) => lane.elements).filter((el) => el.type === "endEvent");
+        const findings = [];
+        for (const end of endEvents) {
+          const hasOutgoing = ir.flows.some((flow) => flow.from === end.id);
+          if (hasOutgoing) {
+            findings.push({
+              ruleId: "EE-003",
+              severity: "error",
+              elementId: end.id,
+              message: `End event "${end.name || end.id}" must not have outgoing flows`,
+              hint: "Remove flows originating from this end event",
+              docUrl: "docs/validation.md#ee-003"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    rule_EE_004_IncomingToEnd = {
+      ruleId: "EE-004",
+      severity: "error",
+      description: "End events must have at least one incoming flow",
+      validate(ir) {
+        const endEvents = ir.lanes.flatMap((lane) => lane.elements).filter((el) => el.type === "endEvent");
+        const findings = [];
+        for (const end of endEvents) {
+          const incomingCount = ir.flows.filter((flow) => flow.to === end.id).length;
+          if (incomingCount === 0) {
+            findings.push({
+              ruleId: "EE-004",
+              severity: "error",
+              elementId: end.id,
+              message: `End event "${end.name || end.id}" must have at least one incoming flow`,
+              hint: "Connect this end event to the final process activity",
+              docUrl: "docs/validation.md#ee-004"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    validator.register(rule_EE_001_EndEventExists);
+    validator.register(rule_EE_003_NoOutgoingFromEnd);
+    validator.register(rule_EE_004_IncomingToEnd);
+    rule_ACT_001_TaskConnectivity = {
+      ruleId: "ACT-001",
+      severity: "error",
+      description: "Tasks must have at least one incoming and one outgoing flow",
+      validate(ir) {
+        const tasks = ir.lanes.flatMap((lane) => lane.elements).filter((el) => el.type === "task");
+        const totalElements = ir.lanes.reduce((sum, lane) => sum + lane.elements.length, 0);
+        const isSoleElement = totalElements === 1;
+        const findings = [];
+        for (const task of tasks) {
+          if (isSoleElement) {
+            continue;
+          }
+          const incoming = ir.flows.filter((flow) => flow.to === task.id).length;
+          const outgoing = ir.flows.filter((flow) => flow.from === task.id).length;
+          if (incoming === 0 || outgoing === 0) {
+            const issues = [];
+            if (incoming === 0) issues.push("no incoming");
+            if (outgoing === 0) issues.push("no outgoing");
+            findings.push({
+              ruleId: "ACT-001",
+              severity: "error",
+              elementId: task.id,
+              message: `Task "${task.name || task.id}" must have incoming and outgoing flows (${issues.join(", ")})`,
+              hint: incoming === 0 && outgoing === 0 ? "Connect this task to both a predecessor and successor activity" : incoming === 0 ? "Connect a flow from the previous activity to this task" : "Connect a flow from this task to the next activity",
+              docUrl: "docs/validation.md#act-001"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    validator.register(rule_ACT_001_TaskConnectivity);
+    rule_CONN_001_ElementReachability = {
+      ruleId: "CONN-001",
+      severity: "error",
+      description: "All elements must be reachable from a start event and reach an end event",
+      validate(ir) {
+        const allElements = ir.lanes.flatMap((lane) => lane.elements);
+        const startEvents = allElements.filter((el) => el.type === "startEvent");
+        const endEvents = allElements.filter((el) => el.type === "endEvent");
+        if (startEvents.length === 0 || endEvents.length === 0) {
+          return [];
+        }
+        const forward = /* @__PURE__ */ new Map();
+        const backward = /* @__PURE__ */ new Map();
+        for (const el of allElements) {
+          forward.set(el.id, []);
+          backward.set(el.id, []);
+        }
+        for (const flow of ir.flows) {
+          const outgoing = forward.get(flow.from) ?? [];
+          outgoing.push(flow.to);
+          forward.set(flow.from, outgoing);
+          const incoming = backward.get(flow.to) ?? [];
+          incoming.push(flow.from);
+          backward.set(flow.to, incoming);
+        }
+        const reachableFromStart = /* @__PURE__ */ new Set();
+        for (const start of startEvents) {
+          const stack = [start.id];
+          const visited = /* @__PURE__ */ new Set();
+          while (stack.length > 0) {
+            const node = stack.pop();
+            if (visited.has(node)) continue;
+            visited.add(node);
+            reachableFromStart.add(node);
+            const outgoing = forward.get(node) ?? [];
+            for (const next of outgoing) {
+              if (!visited.has(next)) {
+                stack.push(next);
+              }
+            }
+          }
+        }
+        const reachesEnd = /* @__PURE__ */ new Set();
+        for (const end of endEvents) {
+          const stack = [end.id];
+          const visited = /* @__PURE__ */ new Set();
+          while (stack.length > 0) {
+            const node = stack.pop();
+            if (visited.has(node)) continue;
+            visited.add(node);
+            reachesEnd.add(node);
+            const incoming = backward.get(node) ?? [];
+            for (const prev of incoming) {
+              if (!visited.has(prev)) {
+                stack.push(prev);
+              }
+            }
+          }
+        }
+        const findings = [];
+        for (const el of allElements) {
+          if (el.type === "startEvent" || el.type === "endEvent") {
+            continue;
+          }
+          const fromStart = reachableFromStart.has(el.id);
+          const toEnd = reachesEnd.has(el.id);
+          if (!fromStart || !toEnd) {
+            const issues = [];
+            if (!fromStart) issues.push("not reachable from start");
+            if (!toEnd) issues.push("does not reach end");
+            findings.push({
+              ruleId: "CONN-001",
+              severity: "error",
+              elementId: el.id,
+              message: `Element "${el.name || el.id}" must be reachable from start and reach end (${issues.join(", ")})`,
+              hint: !fromStart && !toEnd ? "Connect this element to the main process flow" : !fromStart ? "Add a flow from a preceding element to this element" : "Add a flow from this element to a succeeding element",
+              docUrl: "docs/validation.md#conn-001"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    rule_CONN_002_GraphConnectivity = {
+      ruleId: "CONN-002",
+      severity: "error",
+      description: "Process graph must be weakly connected (no isolated subgraphs)",
+      validate(ir) {
+        const allElements = ir.lanes.flatMap((lane) => lane.elements);
+        if (allElements.length <= 1) return [];
+        const neighbors = /* @__PURE__ */ new Map();
+        for (const el of allElements) {
+          neighbors.set(el.id, /* @__PURE__ */ new Set());
+        }
+        for (const flow of ir.flows) {
+          neighbors.get(flow.from)?.add(flow.to);
+          neighbors.get(flow.to)?.add(flow.from);
+        }
+        const visited = /* @__PURE__ */ new Set();
+        const stack = [allElements[0].id];
+        while (stack.length > 0) {
+          const node = stack.pop();
+          if (visited.has(node)) continue;
+          visited.add(node);
+          const adjacent = neighbors.get(node) ?? /* @__PURE__ */ new Set();
+          for (const next of adjacent) {
+            if (!visited.has(next)) {
+              stack.push(next);
+            }
+          }
+        }
+        if (visited.size === allElements.length) {
+          return [];
+        }
+        const isolated = allElements.filter((el) => !visited.has(el.id));
+        return isolated.map((el) => ({
+          ruleId: "CONN-002",
+          severity: "error",
+          elementId: el.id,
+          message: `Element "${el.name || el.id}" is in an isolated subgraph`,
+          hint: "Connect this element to the main process flow",
+          docUrl: "docs/validation.md#conn-002"
+        }));
+      }
+    };
+    validator.register(rule_CONN_001_ElementReachability);
+    validator.register(rule_CONN_002_GraphConnectivity);
+    rule_SF_005_ConditionSourceRestriction = {
+      ruleId: "SF-005",
+      severity: "error",
+      description: "Condition expressions only allowed on flows from Activity or XOR gateway",
+      validate(ir) {
+        const findings = [];
+        const allElements = ir.lanes.flatMap((lane) => lane.elements);
+        const elementMap = new Map(allElements.map((el) => [el.id, el]));
+        for (const flow of ir.flows) {
+          if (flow.condition) {
+            const sourceEl = elementMap.get(flow.from);
+            if (sourceEl && !["task", "userTask", "serviceTask", "exclusiveGateway"].includes(sourceEl.type)) {
+              findings.push({
+                ruleId: "SF-005",
+                severity: "error",
+                elementId: flow.id,
+                message: `Flow "${flow.id}" with condition cannot originate from "${sourceEl.type}"`,
+                hint: "Condition expressions are only allowed on flows from Activities (task, userTask, serviceTask) or XOR gateways",
+                docUrl: "docs/validation.md#sf-005"
+              });
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    rule_SF_006_DefaultFlowSourceRestriction = {
+      ruleId: "SF-006",
+      severity: "error",
+      description: "Default flow marker only allowed on flows from Activity or XOR gateway",
+      validate(ir) {
+        const findings = [];
+        const allElements = ir.lanes.flatMap((lane) => lane.elements);
+        const elementMap = new Map(allElements.map((el) => [el.id, el]));
+        for (const flow of ir.flows) {
+          if (flow.default) {
+            const sourceEl = elementMap.get(flow.from);
+            if (sourceEl && !["task", "userTask", "serviceTask", "exclusiveGateway"].includes(sourceEl.type)) {
+              findings.push({
+                ruleId: "SF-006",
+                severity: "error",
+                elementId: flow.id,
+                message: `Flow "${flow.id}" marked as default cannot originate from "${sourceEl.type}"`,
+                hint: "Default flow marker is only allowed on flows from Activities (task, userTask, serviceTask) or XOR gateways",
+                docUrl: "docs/validation.md#sf-006"
+              });
+            }
+          }
+        }
+        return findings;
+      }
+    };
+    rule_SF_007_DefaultAndConditionExclusive = {
+      ruleId: "SF-007",
+      severity: "error",
+      description: "Flow cannot have both default marker and condition expression",
+      validate(ir) {
+        const findings = [];
+        for (const flow of ir.flows) {
+          if (flow.default && flow.condition) {
+            findings.push({
+              ruleId: "SF-007",
+              severity: "error",
+              elementId: flow.id,
+              message: `Flow "${flow.id}" cannot have both default marker and condition expression`,
+              hint: "A flow must be either the default route (default: true) or have a condition, not both",
+              docUrl: "docs/validation.md#sf-007"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    validator.register(rule_SF_005_ConditionSourceRestriction);
+    validator.register(rule_SF_006_DefaultFlowSourceRestriction);
+    validator.register(rule_SF_007_DefaultAndConditionExclusive);
+    rule_GW_XOR_001_SingleInSingleOutForbidden = {
+      ruleId: "GW-XOR-01",
+      severity: "error",
+      description: "XOR gateway cannot have single incoming and single outgoing flow",
+      validate(ir) {
+        const findings = [];
+        const xorGateways = ir.lanes.flatMap((lane) => lane.elements).filter((el) => el.type === "exclusiveGateway");
+        for (const gateway of xorGateways) {
+          const incoming = ir.flows.filter((f) => f.to === gateway.id).length;
+          const outgoing = ir.flows.filter((f) => f.from === gateway.id).length;
+          if (incoming === 1 && outgoing === 1) {
+            findings.push({
+              ruleId: "GW-XOR-01",
+              severity: "error",
+              elementId: gateway.id,
+              message: `XOR gateway "${gateway.name || gateway.id}" has single incoming and single outgoing flow`,
+              hint: "Use a direct flow instead of a single-in single-out gateway; XOR is for routing decisions",
+              docUrl: "docs/validation.md#gw-xor-01"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    rule_GW_XOR_002_SplitConstraints = {
+      ruleId: "GW-XOR-02",
+      severity: "error",
+      description: "XOR split: at most one default flow; all others must have condition",
+      validate(ir) {
+        const findings = [];
+        const xorGateways = ir.lanes.flatMap((lane) => lane.elements).filter((el) => el.type === "exclusiveGateway");
+        for (const gateway of xorGateways) {
+          const outgoing = ir.flows.filter((f) => f.from === gateway.id);
+          if (outgoing.length <= 1) continue;
+          const defaultFlows = outgoing.filter((f) => f.default);
+          const conditional = outgoing.filter((f) => f.condition);
+          if (defaultFlows.length > 1) {
+            findings.push({
+              ruleId: "GW-XOR-02",
+              severity: "error",
+              elementId: gateway.id,
+              message: `XOR split "${gateway.name || gateway.id}" has ${defaultFlows.length} default flows (max 1)`,
+              hint: "Mark at most one outgoing flow as default; others must have explicit conditions",
+              docUrl: "docs/validation.md#gw-xor-02"
+            });
+          }
+          const unconditional = outgoing.filter((f) => !f.default && !f.condition);
+          if (unconditional.length > 0) {
+            findings.push({
+              ruleId: "GW-XOR-02",
+              severity: "error",
+              elementId: gateway.id,
+              message: `XOR split "${gateway.name || gateway.id}" has ${unconditional.length} flow(s) without condition or default`,
+              hint: "All outgoing flows must either have a condition or be marked as default (but max 1 default)",
+              docUrl: "docs/validation.md#gw-xor-02"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    rule_GW_AND_004_NoConditionsOnParallelSplit = {
+      ruleId: "GW-AND-04",
+      severity: "error",
+      description: "Parallel gateway split outgoing flows must not have conditions",
+      validate(ir) {
+        const findings = [];
+        const andGateways = ir.lanes.flatMap((lane) => lane.elements).filter((el) => el.type === "parallelGateway");
+        for (const gateway of andGateways) {
+          const outgoing = ir.flows.filter((f) => f.from === gateway.id);
+          const withCondition = outgoing.filter((f) => f.condition);
+          if (withCondition.length > 0) {
+            findings.push({
+              ruleId: "GW-AND-04",
+              severity: "error",
+              elementId: gateway.id,
+              message: `Parallel gateway "${gateway.name || gateway.id}" has ${withCondition.length} outgoing flow(s) with condition`,
+              hint: "Parallel gateways route all tokens to all branches; conditions are not evaluated",
+              docUrl: "docs/validation.md#gw-and-04"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    validator.register(rule_GW_XOR_001_SingleInSingleOutForbidden);
+    validator.register(rule_GW_XOR_002_SplitConstraints);
+    validator.register(rule_GW_AND_004_NoConditionsOnParallelSplit);
+    rule_AP_FloatingElements = {
+      ruleId: "AP-FLOAT",
+      severity: "warning",
+      description: "Element has no incoming or outgoing flows (floating)",
+      validate(ir) {
+        const findings = [];
+        const allElements = ir.lanes.flatMap((lane) => lane.elements);
+        for (const el of allElements) {
+          const incoming = ir.flows.filter((f) => f.to === el.id).length;
+          const outgoing = ir.flows.filter((f) => f.from === el.id).length;
+          if (incoming === 0 && outgoing === 0) {
+            findings.push({
+              ruleId: "AP-FLOAT",
+              severity: "warning",
+              elementId: el.id,
+              message: `Element "${el.name || el.id}" has no incoming or outgoing flows`,
+              hint: "Connect this element to the process flow, or remove it if it is unused",
+              docUrl: "docs/validation.md#ap-float"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    rule_AP_MissingDefaultOnConditionalXor = {
+      ruleId: "AP-NO-DEFAULT",
+      severity: "warning",
+      description: "XOR split has all conditional flows but no default (risk of deadlock)",
+      validate(ir) {
+        const findings = [];
+        const xorGateways = ir.lanes.flatMap((lane) => lane.elements).filter((el) => el.type === "exclusiveGateway");
+        for (const gateway of xorGateways) {
+          const outgoing = ir.flows.filter((f) => f.from === gateway.id);
+          if (outgoing.length <= 1) continue;
+          const defaultFlows = outgoing.filter((f) => f.default);
+          const allConditional = outgoing.every((f) => f.condition);
+          if (defaultFlows.length === 0 && allConditional) {
+            findings.push({
+              ruleId: "AP-NO-DEFAULT",
+              severity: "warning",
+              elementId: gateway.id,
+              message: `XOR split "${gateway.name || gateway.id}" has all conditional flows but no default`,
+              hint: "If all conditions are false, the token will be trapped; mark one flow as default or add a catch-all condition",
+              docUrl: "docs/validation.md#ap-no-default"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    rule_AP_ImplicitJoin = {
+      ruleId: "AP-IMPLICIT-JOIN",
+      severity: "warning",
+      description: "Task has multiple incoming flows without a joining gateway",
+      validate(ir) {
+        const findings = [];
+        const allElements = ir.lanes.flatMap((lane) => lane.elements);
+        const tasks = allElements.filter((el) => ["task", "userTask", "serviceTask"].includes(el.type));
+        for (const task of tasks) {
+          const incoming = ir.flows.filter((f) => f.to === task.id);
+          if (incoming.length > 1) {
+            findings.push({
+              ruleId: "AP-IMPLICIT-JOIN",
+              severity: "warning",
+              elementId: task.id,
+              message: `Task "${task.name || task.id}" has ${incoming.length} incoming flows (implicit join)`,
+              hint: "Each incoming token independently activates the task; use an AND join gateway if synchronization is intended",
+              docUrl: "docs/validation.md#ap-implicit-join"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    IMPERATIVE_VERBS = [
+      "accept",
+      "approve",
+      "assign",
+      "authorize",
+      "calculate",
+      "cancel",
+      "check",
+      "classify",
+      "confirm",
+      "convert",
+      "create",
+      "decline",
+      "delete",
+      "derive",
+      "determine",
+      "distribute",
+      "document",
+      "evaluate",
+      "execute",
+      "extract",
+      "generate",
+      "identify",
+      "implement",
+      "invoice",
+      "judge",
+      "log",
+      "manage",
+      "notify",
+      "organize",
+      "pay",
+      "perform",
+      "prepare",
+      "process",
+      "produce",
+      "propose",
+      "publish",
+      "read",
+      "receive",
+      "reconcile",
+      "record",
+      "reduce",
+      "register",
+      "reject",
+      "release",
+      "remove",
+      "report",
+      "request",
+      "resolve",
+      "review",
+      "revise",
+      "schedule",
+      "send",
+      "sign",
+      "store",
+      "submit",
+      "summarize",
+      "test",
+      "track",
+      "transfer",
+      "transform",
+      "validate",
+      "verify",
+      "write"
+    ];
+    rule_AP_GatewayAsTask = {
+      ruleId: "AP-GW-AS-TASK",
+      severity: "warning",
+      description: "Gateway name suggests it might be a task (heuristic: starts with imperative verb)",
+      offByDefault: true,
+      validate(ir) {
+        const findings = [];
+        const allElements = ir.lanes.flatMap((lane) => lane.elements);
+        const gateways = allElements.filter(
+          (el) => ["exclusiveGateway", "parallelGateway", "inclusiveGateway", "eventBasedGateway"].includes(el.type)
+        );
+        for (const gateway of gateways) {
+          if (!gateway.name) continue;
+          const lowerName = gateway.name.toLowerCase();
+          const startsWithVerb = IMPERATIVE_VERBS.some((verb) => lowerName.startsWith(verb));
+          if (startsWithVerb) {
+            findings.push({
+              ruleId: "AP-GW-AS-TASK",
+              severity: "warning",
+              elementId: gateway.id,
+              message: `Gateway "${gateway.name}" has a name starting with an imperative verb; ensure this is a routing construct, not a task`,
+              hint: "Gateways are for routing logic only. If this element performs work, use a task instead.",
+              docUrl: "docs/validation.md#ap-gw-as-task"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    validator.register(rule_AP_FloatingElements);
+    validator.register(rule_AP_MissingDefaultOnConditionalXor);
+    validator.register(rule_AP_ImplicitJoin);
+    validator.register(rule_AP_GatewayAsTask);
+    rule_SF_DUP_NoDuplicateFlows = {
+      ruleId: "SF-DUP",
+      severity: "error",
+      description: "No duplicate sequence flows between same source and target",
+      validate(ir) {
+        const seen = /* @__PURE__ */ new Map();
+        const findings = [];
+        for (const flow of ir.flows) {
+          const key = `${flow.from}\u2192${flow.to}`;
+          if (seen.has(key)) {
+            findings.push({
+              ruleId: "SF-DUP",
+              severity: "error",
+              elementId: flow.id,
+              message: `Duplicate flow from "${flow.from}" to "${flow.to}" (first: ${seen.get(key)})`,
+              hint: "Remove one of the duplicate flows; only one flow can connect the same source-target pair",
+              docUrl: "docs/validation.md#sf-dup"
+            });
+          } else {
+            seen.set(key, flow.id);
+          }
+        }
+        return findings;
+      }
+    };
+    rule_SF_01_ValidFlowEndpoints = {
+      ruleId: "SF-001",
+      severity: "error",
+      description: "Flow endpoints must reference existing elements",
+      validate(ir) {
+        const elementIds = new Set(ir.lanes.flatMap((l) => l.elements.map((e) => e.id)));
+        const findings = [];
+        for (const flow of ir.flows) {
+          if (!elementIds.has(flow.from)) {
+            findings.push({
+              ruleId: "SF-001",
+              severity: "error",
+              elementId: flow.id,
+              message: `Flow source element "${flow.from}" does not exist`,
+              hint: "Verify the source element ID is correct and exists in the process",
+              docUrl: "docs/validation.md#sf-01"
+            });
+          }
+          if (!elementIds.has(flow.to)) {
+            findings.push({
+              ruleId: "SF-001",
+              severity: "error",
+              elementId: flow.id,
+              message: `Flow target element "${flow.to}" does not exist`,
+              hint: "Verify the target element ID is correct and exists in the process",
+              docUrl: "docs/validation.md#sf-01"
+            });
+          }
+        }
+        return findings;
+      }
+    };
+    validator.register(rule_SF_DUP_NoDuplicateFlows);
+    validator.register(rule_SF_01_ValidFlowEndpoints);
+  }
+});
+
+// ../../src/cervinrc.ts
+import { existsSync, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+import { createRequire as createRequire3 } from "node:module";
+function formatAjvErrors2() {
+  const e = validateConfig.errors;
+  if (!e?.length) return [];
+  return e.map(
+    (err) => `${err.instancePath || "/"} ${err.message ?? err.keyword}`.trim()
+  );
+}
+function validateCervinrcDocument(data) {
+  if (!validateConfig(data)) {
+    const err = new Error("Config validation failed");
+    err.errors = formatAjvErrors2();
+    throw err;
+  }
+}
+function noteCervinrcDeprecation() {
+  if (cervinrcNoticeShown) return;
+  cervinrcNoticeShown = true;
+  console.warn(CERVINRC_DEPRECATION_NOTICE);
+}
+function loadRcFile(rcPath, fileLabel) {
+  try {
+    const content = readFileSync3(rcPath, "utf8");
+    const parsed = JSON.parse(content);
+    validateCervinrcDocument(parsed);
+    return parsed;
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      const err2 = new Error(`Invalid JSON in ${fileLabel}: ${e.message}`);
+      throw err2;
+    }
+    if (e.errors) {
+      throw e;
+    }
+    const err = e;
+    throw new Error(`Failed to load ${fileLabel}: ${err.message}`);
+  }
+}
+function loadTransitrixrc(startPath = process.cwd()) {
+  const transitrixPath = join3(startPath, TRANSITRIXRC_FILE);
+  if (existsSync(transitrixPath)) {
+    return loadRcFile(transitrixPath, TRANSITRIXRC_FILE);
+  }
+  const cervinPath = join3(startPath, CERVINRC_FILE);
+  if (existsSync(cervinPath)) {
+    noteCervinrcDeprecation();
+    return loadRcFile(cervinPath, CERVINRC_FILE);
+  }
+  return {};
+}
+function assertNoCriticalRuleDowngrade(registeredRules, config) {
+  if (!config.rules) return;
+  for (const [ruleId, override] of Object.entries(config.rules)) {
+    const rule = registeredRules.get(ruleId);
+    if (rule && rule.severity === "error" && override === "off") {
+      const err = new Error(
+        `Config error: rule "${ruleId}" is an error-severity rule and cannot be downgraded to "${override}"`
+      );
+      err.errors = [
+        `Rule "${ruleId}" has severity "error" and is a BPMN conformance gate; it cannot be disabled or demoted.`,
+        "Only warning-severity rules can be overridden."
+      ];
+      throw err;
+    }
+  }
+}
+function mergeConfigWithDefaults(registeredRules, config) {
+  const enabledRules = /* @__PURE__ */ new Set();
+  for (const [ruleId, rule] of registeredRules.entries()) {
+    if (!rule.offByDefault) {
+      enabledRules.add(ruleId);
+    }
+  }
+  if (config.rules) {
+    for (const [ruleId, override] of Object.entries(config.rules)) {
+      if (override === "off") {
+        enabledRules.delete(ruleId);
+      } else if (override === "warn") {
+        enabledRules.add(ruleId);
+      }
+    }
+  }
+  return enabledRules;
+}
+var require4, Ajv2, addFormats2, CERVINRC_SCHEMA, ajv2, validateConfig, TRANSITRIXRC_FILE, CERVINRC_FILE, CERVINRC_DEPRECATION_NOTICE, cervinrcNoticeShown;
+var init_cervinrc = __esm({
+  "../../src/cervinrc.ts"() {
+    "use strict";
+    require4 = createRequire3(import.meta.url);
+    Ajv2 = require4("ajv");
+    addFormats2 = require4("ajv-formats");
+    CERVINRC_SCHEMA = {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      type: "object",
+      properties: {
+        rules: {
+          type: "object",
+          patternProperties: {
+            "^[A-Z]+-[0-9-]+$": {
+              type: "string",
+              enum: ["off", "warn"]
+            }
+          },
+          additionalProperties: false
+        }
+      },
+      additionalProperties: false,
+      required: []
+    };
+    ajv2 = new Ajv2({ allErrors: true, strict: false });
+    addFormats2(ajv2);
+    validateConfig = ajv2.compile(CERVINRC_SCHEMA);
+    TRANSITRIXRC_FILE = ".transitrixrc";
+    CERVINRC_FILE = ".cervinrc";
+    CERVINRC_DEPRECATION_NOTICE = ".cervinrc is deprecated and will be removed in 2.0.0 \u2014 rename it to .transitrixrc.";
+    cervinrcNoticeShown = false;
+  }
+});
+
+// ../../src/compiler.ts
+import { BpmnModdle } from "bpmn-moddle";
+async function compileTransitrixYamlWithLayout(yamlText, options) {
+  const ir = parseYamlToIr(yamlText);
+  const rcConfig = loadTransitrixrc();
+  assertNoCriticalRuleDowngrade(validator.getRules(), rcConfig);
+  const enabledRules = mergeConfigWithDefaults(validator.getRules(), rcConfig);
+  const validatorConfig = { enabledRules };
+  const validation = validateProcess(ir, validatorConfig);
+  const layout = await layoutProcess(ir, options?.layout);
+  const xml = emitBpmnXml(layout);
+  const moddle = new BpmnModdle();
+  const { warnings: bpmnWarnings } = await moddle.fromXML(xml, "bpmn:Definitions");
+  if (bpmnWarnings && bpmnWarnings.length > 0) {
+    const bpmnFindings = bpmnWarnings.map((warning) => ({
+      ruleId: "RD-111-BPMN-MODDLE",
+      severity: "error",
+      message: `BPMN 2.0 conformance: ${warning.message ?? String(warning)}`,
+      hint: "This is a Transitrix Studio compiler bug; please report it",
+      docUrl: "docs/validation.md#bpmn-moddle-validation"
+    }));
+    validation.findings.push(...bpmnFindings);
+    validation.summary.errorCount += bpmnFindings.length;
+    validation.isValid = false;
+  }
+  return { ir, layout, xml, validation };
+}
+var init_compiler = __esm({
+  "../../src/compiler.ts"() {
+    "use strict";
+    init_emitter();
+    init_layout();
+    init_parser();
+    init_validator();
+    init_cervinrc();
+    init_layout_options();
+  }
+});
+
+// ../../src/metrics.ts
+function computeLayoutMetrics(layout, scoreConfig) {
+  const crossings = countCrossings(layout);
+  const bends = countBends(layout);
+  const edgeLength = computeEdgeLength(layout);
+  const waypointDensity = computeWaypointDensity(layout);
+  const spineDeviation = computeSpineDeviation(layout);
+  const emptyArea = computeEmptyArea(layout);
+  const portViolations = countPortViolations(layout);
+  const portUniqueness = computePortUniqueness(layout);
+  const laneAxisAlignment = computeLaneAxisAlignment(layout);
+  const layoutScore = scoreConfig ? computeLayoutScore({
+    crossings,
+    spineDeviation,
+    portViolations,
+    emptyArea,
+    laneAxisAlignment,
+    ...scoreConfig
+  }) : 0;
+  return {
+    crossings,
+    bends,
+    edgeLength,
+    waypointDensity,
+    spineDeviation,
+    emptyArea,
+    portViolations,
+    portUniqueness,
+    laneAxisAlignment,
+    layoutScore
+  };
+}
+function countCrossings(layout) {
+  const flows = layout.flows;
+  if (!flows || flows.length < 2) return 0;
+  let count = 0;
+  for (let i = 0; i < flows.length; i++) {
+    for (let j = i + 1; j < flows.length; j++) {
+      if (pathsIntersect(flows[i].waypoints, flows[j].waypoints)) {
+        count++;
+      }
+    }
+  }
+  return count;
+}
+function pathsIntersect(path1, path2) {
+  if (!path1 || !path2 || path1.length < 2 || path2.length < 2) return false;
+  for (let i = 0; i < path1.length - 1; i++) {
+    for (let j = 0; j < path2.length - 1; j++) {
+      const seg1 = [path1[i], path1[i + 1]];
+      const seg2 = [path2[j], path2[j + 1]];
+      if (orthogonalSegmentsIntersect(seg1, seg2)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function orthogonalSegmentsIntersect(seg1, seg2) {
+  const [p1, p2] = seg1;
+  const [p3, p4] = seg2;
+  const seg1Vertical = Math.abs(p1.x - p2.x) < 0.01;
+  const seg1Horizontal = Math.abs(p1.y - p2.y) < 0.01;
+  const seg2Vertical = Math.abs(p3.x - p4.x) < 0.01;
+  const seg2Horizontal = Math.abs(p3.y - p4.y) < 0.01;
+  if (seg1Vertical && seg2Horizontal) {
+    const x = p1.x;
+    const y = p3.y;
+    const xInRange = x > Math.min(p3.x, p4.x) && x < Math.max(p3.x, p4.x);
+    const yInRange = y > Math.min(p1.y, p2.y) && y < Math.max(p1.y, p2.y);
+    return xInRange && yInRange;
+  }
+  if (seg1Horizontal && seg2Vertical) {
+    const x = p3.x;
+    const y = p1.y;
+    const xInRange = x > Math.min(p1.x, p2.x) && x < Math.max(p1.x, p2.x);
+    const yInRange = y > Math.min(p3.y, p4.y) && y < Math.max(p3.y, p4.y);
+    return xInRange && yInRange;
+  }
+  return false;
+}
+function countBends(layout) {
+  const flows = layout.flows;
+  if (!flows) return 0;
+  let totalBends = 0;
+  for (const flow of flows) {
+    totalBends += computeFlowBends(flow.waypoints);
+  }
+  return totalBends;
+}
+function computeFlowBends(waypoints) {
+  if (!waypoints || waypoints.length < 3) return 0;
+  let bends = 0;
+  for (let i = 1; i < waypoints.length - 1; i++) {
+    const prev = waypoints[i - 1];
+    const curr = waypoints[i];
+    const next = waypoints[i + 1];
+    const prevDir = { x: curr.x - prev.x, y: curr.y - prev.y };
+    const nextDir = { x: next.x - curr.x, y: next.y - curr.y };
+    const prevHorizontal = Math.abs(prevDir.y) < 0.01;
+    const nextVertical = Math.abs(nextDir.x) < 0.01;
+    const prevVertical = Math.abs(prevDir.x) < 0.01;
+    const nextHorizontal = Math.abs(nextDir.y) < 0.01;
+    if (prevHorizontal && nextVertical || prevVertical && nextHorizontal) {
+      bends++;
+    }
+  }
+  return bends;
+}
+function computeEdgeLength(layout) {
+  const flows = layout.flows;
+  if (!flows) return 0;
+  let totalLength = 0;
+  for (const flow of flows) {
+    totalLength += computeFlowLength(flow.waypoints);
+  }
+  return totalLength;
+}
+function computeFlowLength(waypoints) {
+  if (!waypoints || waypoints.length < 2) return 0;
+  let length = 0;
+  for (let i = 0; i < waypoints.length - 1; i++) {
+    const p1 = waypoints[i];
+    const p2 = waypoints[i + 1];
+    length += Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
+  }
+  return length;
+}
+function computeWaypointDensity(layout) {
+  const flows = layout.flows;
+  if (!flows || flows.length === 0) return 0;
+  const totalWaypoints = flows.reduce((sum, f) => sum + (f.waypoints?.length || 0), 0);
+  return totalWaypoints / flows.length;
+}
+function computeSpineDeviation(layout) {
+  const lanes = layout.process?.lanes || [];
+  if (lanes.length === 0) return 0;
+  const laneDeviations = [];
+  for (const lane of lanes) {
+    const laneBounds = layout.laneBounds.get(lane.id);
+    if (!laneBounds) continue;
+    const axisY = laneBounds.y + laneBounds.height / 2;
+    const elements = lane.elements || [];
+    if (elements.length === 0) continue;
+    const maxDev = Math.max(
+      ...elements.map((el) => {
+        const elBounds = layout.elements.get(el.id);
+        if (!elBounds) return 0;
+        return Math.abs(elBounds.y + elBounds.height / 2 - axisY);
+      })
+    );
+    laneDeviations.push(maxDev);
+  }
+  return laneDeviations.length > 0 ? median(laneDeviations) : 0;
+}
+function computeEmptyArea(layout) {
+  const lanes = layout.process?.lanes || [];
+  if (lanes.length === 0) return 0;
+  const ratios = [];
+  for (const lane of lanes) {
+    const elements = lane.elements || [];
+    if (elements.length <= 1) continue;
+    const laneBounds = layout.laneBounds.get(lane.id);
+    if (!laneBounds) continue;
+    let minX = Infinity, maxX = -Infinity;
+    let minY = Infinity, maxY = -Infinity;
+    for (const el of elements) {
+      const elBounds = layout.elements.get(el.id);
+      if (!elBounds) continue;
+      minX = Math.min(minX, elBounds.x);
+      maxX = Math.max(maxX, elBounds.x + elBounds.width);
+      minY = Math.min(minY, elBounds.y);
+      maxY = Math.max(maxY, elBounds.y + elBounds.height);
+    }
+    if (minX === Infinity) continue;
+    const laneBoxArea = (maxX - minX) * (maxY - minY);
+    const occupiedArea = elements.reduce((sum, el) => {
+      const elBounds = layout.elements.get(el.id);
+      return sum + (elBounds ? elBounds.width * elBounds.height : 0);
+    }, 0);
+    const emptyArea = laneBoxArea - occupiedArea;
+    const ratio = emptyArea / laneBoxArea;
+    ratios.push(ratio);
+  }
+  return ratios.length > 0 ? median(ratios) : 0;
+}
+function countPortViolations(layout) {
+  const flows = layout.flows;
+  if (!flows) return 0;
+  const elementMap = /* @__PURE__ */ new Map();
+  for (const lane of layout.process?.lanes ?? []) {
+    for (const el of lane.elements) {
+      elementMap.set(el.id, el);
+    }
+  }
+  let violations = 0;
+  for (const flow of flows) {
+    const fromEl = elementMap.get(flow.from);
+    const toEl = elementMap.get(flow.to);
+    if (!fromEl || !toEl) continue;
+    const isSameLane = fromEl.laneId === toEl.laneId;
+    const fromBounds = layout.elements.get(fromEl.id);
+    const toBounds = layout.elements.get(toEl.id);
+    if (!fromBounds || !toBounds) continue;
+    const exitPort = determinePort(flow.waypoints, fromBounds, "exit");
+    const entryPort = determinePort(flow.waypoints, toBounds, "entry");
+    if (isSameLane) {
+      const isSourceGateway = GATEWAY_TYPES.has(fromEl.type);
+      const validExit = isSourceGateway ? ["LEFT", "RIGHT", "TOP", "BOTTOM"].includes(exitPort) : ["LEFT", "RIGHT"].includes(exitPort);
+      if (!validExit || !["LEFT", "RIGHT"].includes(entryPort)) {
+        violations++;
+      }
+    } else {
+      const sourceLaneIdx = layout.process?.lanes.findIndex((l) => l.id === fromEl.laneId);
+      const targetLaneIdx = layout.process?.lanes.findIndex((l) => l.id === toEl.laneId);
+      if (sourceLaneIdx === void 0 || targetLaneIdx === void 0) continue;
+      if (sourceLaneIdx < targetLaneIdx) {
+        if (!["RIGHT", "BOTTOM"].includes(exitPort) || !["RIGHT", "BOTTOM"].includes(entryPort)) {
+          violations++;
+        }
+      } else if (sourceLaneIdx > targetLaneIdx) {
+        if (!["RIGHT", "TOP"].includes(exitPort) || !["RIGHT", "TOP"].includes(entryPort)) {
+          violations++;
+        }
+      }
+    }
+  }
+  return violations;
+}
+function determinePort(waypoints, elementBounds, type) {
+  if (!waypoints || waypoints.length < 2) return "CENTER";
+  const centerX = elementBounds.x + elementBounds.width / 2;
+  const centerY = elementBounds.y + elementBounds.height / 2;
+  if (type === "exit") {
+    const p1 = waypoints[0];
+    const p2 = waypoints[1];
+    if (Math.abs(p1.x - p2.x) < 0.01) {
+      return p2.y > p1.y ? "BOTTOM" : "TOP";
+    }
+    if (Math.abs(p1.y - p2.y) < 0.01) return p2.x > p1.x ? "RIGHT" : "LEFT";
+  } else {
+    const pn = waypoints[waypoints.length - 1];
+    const pn1 = waypoints[waypoints.length - 2];
+    if (Math.abs(pn.x - pn1.x) < 0.01) {
+      return pn.y > pn1.y ? "BOTTOM" : "TOP";
+    }
+    if (Math.abs(pn.y - pn1.y) < 0.01) return pn.x > pn1.x ? "RIGHT" : "LEFT";
+  }
+  return "CENTER";
+}
+function computePortUniqueness(layout) {
+  const gateways = layout.process?.lanes.flatMap((l) => l.elements).filter((el) => GATEWAY_TYPES.has(el.type)) ?? [];
+  if (gateways.length === 0) return 1;
+  let sumUniqueness = 0;
+  let countGateways = 0;
+  for (const gw of gateways) {
+    const outflows = layout.flows.filter((f) => f.from === gw.id);
+    if (outflows.length < 2) continue;
+    const portsUsed = /* @__PURE__ */ new Set();
+    const gwBounds = layout.elements.get(gw.id);
+    if (!gwBounds) continue;
+    for (const flow of outflows) {
+      const port = determinePort(flow.waypoints, gwBounds, "exit");
+      portsUsed.add(port);
+    }
+    const uniqueness = portsUsed.size / outflows.length;
+    sumUniqueness += uniqueness;
+    countGateways++;
+  }
+  return countGateways > 0 ? sumUniqueness / countGateways : 1;
+}
+function computeLaneAxisAlignment(layout) {
+  const lanes = layout.process?.lanes || [];
+  if (lanes.length === 0) return 1;
+  let totalOnAxis = 0;
+  let totalSingleColumn = 0;
+  for (const lane of lanes) {
+    const elements = lane.elements || [];
+    if (elements.length === 0) continue;
+    const laneBounds = layout.laneBounds.get(lane.id);
+    if (!laneBounds) continue;
+    const columnGroups = /* @__PURE__ */ new Map();
+    for (const el of elements) {
+      const elBounds = layout.elements.get(el.id);
+      if (!elBounds) continue;
+      const roundedX = Math.round((elBounds.x + elBounds.width / 2) / 10) * 10;
+      if (!columnGroups.has(roundedX)) {
+        columnGroups.set(roundedX, []);
+      }
+      columnGroups.get(roundedX).push(el);
+    }
+    const axisY = laneBounds.y + laneBounds.height / 2;
+    for (const [, group] of columnGroups) {
+      if (group.length === 1) {
+        totalSingleColumn++;
+        const el = group[0];
+        const elBounds = layout.elements.get(el.id);
+        if (elBounds && Math.abs(elBounds.y + elBounds.height / 2 - axisY) <= 4) {
+          totalOnAxis++;
+        }
+      }
+    }
+  }
+  return totalSingleColumn > 0 ? totalOnAxis / totalSingleColumn : 1;
+}
+function computeLayoutScore(input) {
+  const crossingsNorm = Math.min(input.crossings / Math.max(input.crossingsBaseline, 1), 1);
+  const spineDevNorm = Math.min(input.spineDeviation / Math.max(input.spineDeviationBaseline, 0.1), 1);
+  const portViolNorm = Math.min(input.portViolations / Math.max(input.portViolationsBaseline, 1), 1);
+  const emptyAreaNorm = input.emptyArea;
+  return 1e3 * (1 - crossingsNorm) * (1 - spineDevNorm) * (1 - portViolNorm) * (1 - emptyAreaNorm) * input.laneAxisAlignment;
+}
+function median(values) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+var init_metrics = __esm({
+  "../../src/metrics.ts"() {
+    "use strict";
+    init_ir();
+  }
+});
+
+// ../../src/http-body-limit.ts
+function readHttpBodyLimited(req, maxBytes = MAX_COMPILE_BODY_BYTES) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    let total = 0;
+    let settled = false;
+    const bail = (err) => {
+      if (settled) return;
+      settled = true;
+      if (typeof req.destroy === "function") {
+        try {
+          req.destroy(err);
+        } catch {
+        }
+      }
+      reject(err);
+    };
+    req.on("data", (c) => {
+      if (settled) return;
+      const buf = typeof c === "string" ? Buffer.from(c, "utf8") : c;
+      total += buf.length;
+      if (total > maxBytes) {
+        bail(new PayloadTooLargeError(maxBytes));
+        return;
+      }
+      chunks.push(buf);
+    });
+    req.on("end", () => {
+      if (settled) return;
+      settled = true;
+      resolve2(Buffer.concat(chunks));
+    });
+    req.on("error", (e) => bail(e instanceof Error ? e : new Error(String(e))));
+  });
+}
+var MAX_COMPILE_BODY_BYTES, PayloadTooLargeError;
+var init_http_body_limit = __esm({
+  "../../src/http-body-limit.ts"() {
+    "use strict";
+    MAX_COMPILE_BODY_BYTES = 1048576;
+    PayloadTooLargeError = class extends Error {
+      constructor(maxBytes = MAX_COMPILE_BODY_BYTES) {
+        super(`Request body exceeds limit (${maxBytes} bytes)`);
+        this.name = "PayloadTooLargeError";
+      }
+    };
+  }
+});
+
+// ../../src/serve-ui.ts
+var serve_ui_exports = {};
+__export(serve_ui_exports, {
+  cliServeArgv: () => cliServeArgv,
+  handleCompile: () => handleCompile,
+  isInsideRoot: () => isInsideRoot,
+  runUiServer: () => runUiServer
+});
+import { createReadStream, existsSync as existsSync3 } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+import { createServer } from "node:http";
+import process2 from "node:process";
+import { basename, dirname as dirname3, extname, resolve as pathResolve, sep as pathSep } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+function mimeType(file) {
+  switch (extname(file).toLowerCase()) {
+    case ".html":
+      return "text/html; charset=utf-8";
+    case ".js":
+      return "text/javascript; charset=utf-8";
+    case ".css":
+      return "text/css; charset=utf-8";
+    case ".svg":
+      return "image/svg+xml";
+    case ".woff":
+      return "font/woff";
+    case ".woff2":
+      return "font/woff2";
+    case ".ttf":
+      return "font/ttf";
+    case ".json":
+      return "application/json";
+    default:
+      return "application/octet-stream";
+  }
+}
+function resolveUiDist() {
+  const dir = pathResolve(__dirname, "..", "ui", "dist");
+  if (existsSync3(pathResolve(dir, "index.html"))) {
+    return dir;
+  }
+  throw new Error(
+    `UI build not found (${pathResolve(dir, "index.html")}). Run: npm run ui:build`
+  );
+}
+function isInsideRoot(staticRoot, candidateAbs) {
+  const root = pathResolve(staticRoot);
+  const candidate = pathResolve(candidateAbs);
+  return candidate === root || candidate.startsWith(root + pathSep);
+}
+async function serveFile(res, filePath) {
+  const st = await stat(filePath);
+  res.writeHead(200, {
+    "Content-Type": mimeType(filePath),
+    "Content-Length": String(st.size),
+    "Cache-Control": "no-cache"
+  });
+  const stream = createReadStream(filePath);
+  stream.on("error", (err) => {
+    console.error("serveFile: read stream error", err);
+    res.destroy(err);
+  });
+  stream.pipe(res);
+}
+async function handleCompile(req, res) {
+  if (req.method !== "POST") {
+    res.writeHead(405, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("405 Method Not Allowed");
+    return;
+  }
+  try {
+    const raw = await readHttpBodyLimited(req);
+    const ctype = (req.headers["content-type"] ?? "").toLowerCase();
+    let yaml2;
+    let layout;
+    if (ctype.includes("application/json")) {
+      let body;
+      try {
+        body = JSON.parse(raw.toString("utf8"));
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify({ message: "Invalid JSON request body", details: [] }));
+        return;
+      }
+      const rec = body;
+      if (typeof rec.yaml !== "string") {
+        res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
+        res.end(
+          JSON.stringify({
+            message: 'Expected JSON body shaped like { "yaml": "<source>" [, "layout": { ... }] }',
+            details: []
+          })
+        );
+        return;
+      }
+      yaml2 = rec.yaml;
+      const parsedLayout = parseLayoutDiagramOptionsFromJson(rec.layout);
+      if (Object.keys(parsedLayout).length > 0) {
+        layout = parsedLayout;
+      }
+    } else {
+      yaml2 = raw.toString("utf8");
+    }
+    const result = await compileTransitrixYamlWithLayout(yaml2, layout ? { layout } : void 0);
+    const metrics = computeLayoutMetrics(result.layout);
+    res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(
+      JSON.stringify({ xml: result.xml, metrics, validation: result.validation }, null, 2)
+    );
+  } catch (e) {
+    if (e instanceof PayloadTooLargeError) {
+      res.writeHead(413, { "Content-Type": "application/json; charset=utf-8" });
+      res.end(JSON.stringify({ message: e.message, details: [] }));
+      return;
+    }
+    const err = e;
+    res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(
+      JSON.stringify({
+        message: err.message ?? "Compilation failed",
+        details: err.errors ?? []
+      })
+    );
+  }
+}
+async function runUiServer(opts) {
+  const staticRoot = resolveUiDist();
+  const server = createServer(async (req, res) => {
+    try {
+      let pathOnly;
+      try {
+        pathOnly = decodeURIComponent(req.url?.split("?")[0] ?? "/");
+      } catch {
+        res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end("400 Bad Request");
+        return;
+      }
+      if (pathOnly === "/api/compile") {
+        await handleCompile(req, res);
+        return;
+      }
+      const relReq = pathOnly === "/" ? "index.html" : pathOnly.replace(/^\/+/, "");
+      const filePath = pathResolve(staticRoot, relReq);
+      if (!isInsideRoot(staticRoot, filePath)) {
+        res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end("403 Forbidden");
+        return;
+      }
+      try {
+        const st = await stat(filePath);
+        if (st.isFile()) {
+          await serveFile(res, filePath);
+          return;
+        }
+      } catch {
+      }
+      const indexHtml = pathResolve(staticRoot, "index.html");
+      if (existsSync3(indexHtml)) {
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-cache" });
+        res.end(await readFile(indexHtml, "utf8"));
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("404 Not Found");
+    } catch (e) {
+      console.error("transitrix serve: unhandled error", e);
+      res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("Internal server error");
+    }
+  });
+  await new Promise((resolve2, reject) => {
+    server.listen(opts.port, opts.host ?? "127.0.0.1", () => resolve2());
+    server.on("error", reject);
+  });
+  const host = opts.host ?? "127.0.0.1";
+  const url = `http://${host}:${opts.port}/`;
+  const rootName = basename(staticRoot);
+  console.error(`Transitrix Studio UI \u2192 ${url}  (static root: "${rootName}")`);
+}
+async function cliServeArgv(argv) {
+  let port = 8765;
+  let host = "127.0.0.1";
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--port" || a === "-p") {
+      const v = argv[++i];
+      if (v) {
+        const parsed = Number.parseInt(v, 10);
+        if (!Number.isFinite(parsed)) {
+          console.error(`transitrix serve: --port requires a numeric value, got: ${v}`);
+          process2.exitCode = 1;
+          process2.exit(1);
+        }
+        port = parsed;
+      }
+      continue;
+    }
+    if (a.startsWith("--port=")) {
+      const v = a.slice("--port=".length);
+      const parsed = Number.parseInt(v, 10);
+      if (!Number.isFinite(parsed)) {
+        console.error(`transitrix serve: --port requires a numeric value, got: ${v}`);
+        process2.exitCode = 1;
+        process2.exit(1);
+      }
+      port = parsed;
+      continue;
+    }
+    if (a === "--host" || a === "-H") {
+      const v = argv[++i];
+      if (v) host = v;
+      continue;
+    }
+    if (a === "--help" || a === "-h") {
+      console.error(`usage: transitrix serve [--port 8765] [--host 127.0.0.1]
+
+Local web UI: YAML on the left, BPMN preview on the right.
+Compiles through the server (same pipeline as the CLI / VS Code extension for BPMN).
+
+Before first run:
+  npm run build && npm run ui:build
+`);
+      process2.exitCode = 0;
+      process2.exit(0);
+    }
+  }
+  if (!Number.isFinite(port) || port < 1 || port > 65535) {
+    console.error("transitrix serve: invalid --port");
+    process2.exitCode = 1;
+    process2.exit(1);
+  }
+  await runUiServer({ port, host });
+}
+var __dirname, thisScript;
+var init_serve_ui = __esm({
+  "../../src/serve-ui.ts"() {
+    "use strict";
+    init_compiler();
+    init_metrics();
+    init_http_body_limit();
+    init_layout_options();
+    __dirname = dirname3(fileURLToPath3(import.meta.url));
+    thisScript = pathResolve(fileURLToPath3(import.meta.url));
+    if (process2.argv[1] && pathResolve(process2.argv[1]) === thisScript) {
+      void cliServeArgv(process2.argv.slice(2)).catch((e) => {
+        console.error(String(e.message ?? e));
+        process2.exit(1);
+      });
+    }
+  }
+});
+
+// ../../src/cli.ts
+import { writeFileSync as writeFileSync2 } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
+
+// ../../src/cli-parse.ts
+var DEFAULT_CERVIN_FILE_EXTENSIONS = [".cervin.yaml", ".bpmn.transitrix.yaml"];
+function normalizeExt(s) {
+  const t = s.trim();
+  if (!t) return t;
+  return t.startsWith(".") ? t : `.${t}`;
+}
+function parseCliFileArgv(argv) {
+  const positional = [];
+  const extList = [];
+  let wantsHelp = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--help" || a === "-h") {
+      wantsHelp = true;
+      continue;
+    }
+    if (a === "--ext") {
+      const raw = argv[++i];
+      if (!raw) {
+        return { ok: false, error: "--ext_requires_value" };
+      }
+      raw.split(",").map((x) => normalizeExt(x)).filter(Boolean).forEach((x) => extList.push(x));
+      continue;
+    }
+    if (a.startsWith("--ext=")) {
+      const raw = a.slice("--ext=".length);
+      raw.split(",").map((x) => normalizeExt(x)).filter(Boolean).forEach((x) => extList.push(x));
+      continue;
+    }
+    positional.push(a);
+  }
+  return { ok: true, positional, extList, wantsHelp };
+}
+function parseValidateArgv(argv) {
+  let scope = "file";
+  let root;
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--scope") {
+      const v = argv[++i];
+      if (v === void 0) return { ok: false, error: "--scope_requires_value" };
+      if (v !== "file" && v !== "repo") return { ok: false, error: "bad_scope" };
+      scope = v;
+      continue;
+    }
+    if (a.startsWith("--scope=")) {
+      const v = a.slice("--scope=".length);
+      if (v !== "file" && v !== "repo") return { ok: false, error: "bad_scope" };
+      scope = v;
+      continue;
+    }
+    if (a === "--root") {
+      const v = argv[++i];
+      if (v === void 0) return { ok: false, error: "--root_requires_value" };
+      root = v;
+      continue;
+    }
+    if (a.startsWith("--root=")) {
+      root = a.slice("--root=".length);
+      continue;
+    }
+    rest.push(a);
+  }
+  const parsed = parseCliFileArgv(rest);
+  if (!parsed.ok) return { ok: false, error: "--ext_requires_value", scope };
+  return {
+    ok: true,
+    scope,
+    root,
+    positional: parsed.positional,
+    extList: parsed.extList,
+    wantsHelp: parsed.wantsHelp
+  };
+}
+function inputMatchesExtension(filePath, exts) {
+  const lowered = filePath.replace(/\\/g, "/").toLowerCase();
+  return exts.some((e) => lowered.endsWith(e.toLowerCase()));
+}
+var CERVIN_DEPRECATION_NOTICE = "cervin: the `cervin` command is deprecated and will be removed in 2.0.0 \u2014 use `transitrix` instead.";
+function invokedAsCervin(argv1) {
+  if (!argv1) return false;
+  const base = argv1.replace(/\\/g, "/").split("/").pop() ?? "";
+  const stem = base.replace(/\.[^.]+$/, "").toLowerCase();
+  return stem === "cervin";
+}
+
+// ../../src/cli.ts
+init_compiler();
+
+// ../../src/migrate.ts
+import { spawnSync } from "node:child_process";
+import { cpSync, existsSync as existsSync2, mkdtempSync, readdirSync, readFileSync as readFileSync4, rmSync, statSync, writeFileSync } from "node:fs";
+import { join as join4, relative, resolve } from "node:path";
+import { tmpdir } from "node:os";
+function parseMigrateArgv(argv) {
+  let from;
+  let to;
+  let dryRun = false;
+  let recipesDir = "../methodology/migrations";
+  let targetDir = process.cwd();
+  let wantsHelp = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--help" || a === "-h") {
+      wantsHelp = true;
+      continue;
+    }
+    if (a === "--dry-run") {
+      dryRun = true;
+      continue;
+    }
+    if (a === "--from") {
+      from = argv[++i];
+      continue;
+    }
+    if (a.startsWith("--from=")) {
+      from = a.slice("--from=".length);
+      continue;
+    }
+    if (a === "--to") {
+      to = argv[++i];
+      continue;
+    }
+    if (a.startsWith("--to=")) {
+      to = a.slice("--to=".length);
+      continue;
+    }
+    if (a === "--recipes") {
+      recipesDir = argv[++i];
+      continue;
+    }
+    if (a.startsWith("--recipes=")) {
+      recipesDir = a.slice("--recipes=".length);
+      continue;
+    }
+    if (!a.startsWith("-")) {
+      targetDir = a;
+      continue;
+    }
+  }
+  return { from, to, dryRun, recipesDir, targetDir, wantsHelp };
+}
+function scanRecipes(recipesDir) {
+  const absDir = resolve(recipesDir);
+  if (!existsSync2(absDir)) return [];
+  const versionPat = /^\d+\.\d+$/;
+  return readdirSync(absDir).filter((ent) => {
+    const parts = ent.split("-to-");
+    return parts.length === 2 && versionPat.test(parts[0]) && versionPat.test(parts[1]);
+  }).map((ent) => {
+    const [from, to] = ent.split("-to-");
+    return { from, to, dir: join4(absDir, ent) };
+  }).filter((r) => existsSync2(join4(r.dir, "codemod.mjs")));
+}
+function resolveChain(from, to, recipes) {
+  if (from === to) return [];
+  const graph = /* @__PURE__ */ new Map();
+  for (const r of recipes) {
+    if (!graph.has(r.from)) graph.set(r.from, []);
+    graph.get(r.from).push(r);
+  }
+  const queue = [{ node: from, path: [] }];
+  const visited = /* @__PURE__ */ new Set([from]);
+  while (queue.length) {
+    const item = queue.shift();
+    for (const step of graph.get(item.node) ?? []) {
+      const newPath = [...item.path, step];
+      if (step.to === to) return newPath;
+      if (!visited.has(step.to)) {
+        visited.add(step.to);
+        queue.push({ node: step.to, path: newPath });
+      }
+    }
+  }
+  return null;
+}
+function findFurthestReachable(from, recipes) {
+  const forward = /* @__PURE__ */ new Map();
+  for (const r of recipes) forward.set(r.from, r.to);
+  let current = from;
+  const visited = /* @__PURE__ */ new Set([from]);
+  while (forward.has(current)) {
+    const next = forward.get(current);
+    if (visited.has(next)) break;
+    visited.add(next);
+    current = next;
+  }
+  return current === from ? void 0 : current;
+}
+function toMajorMinor(v) {
+  return v.split(".").slice(0, 2).join(".");
+}
+function toFullSemver(v) {
+  const parts = v.split(".");
+  while (parts.length < 3) parts.push("0");
+  return parts.slice(0, 3).join(".");
+}
+var TRANSITRIX_YAML = "transitrix.yaml";
+function readMethodologyVersion(dir) {
+  const yamlPath = join4(resolve(dir), TRANSITRIX_YAML);
+  if (!existsSync2(yamlPath)) return void 0;
+  const content = readFileSync4(yamlPath, "utf8");
+  const m = content.match(/^methodology_version\s*:\s*["']?([^\s"'\n]+)["']?/m);
+  return m ? m[1] : void 0;
+}
+function updateMethodologyVersion(dir, version) {
+  const yamlPath = join4(resolve(dir), TRANSITRIX_YAML);
+  if (!existsSync2(yamlPath)) {
+    writeFileSync(yamlPath, `methodology_version: ${version}
+`);
+    return;
+  }
+  const content = readFileSync4(yamlPath, "utf8");
+  if (/^methodology_version\s*:/m.test(content)) {
+    const updated = content.replace(
+      /^(methodology_version\s*:\s*)["']?[^\s"'\n]+["']?/m,
+      `$1${version}`
+    );
+    writeFileSync(yamlPath, updated);
+  } else {
+    writeFileSync(yamlPath, `${content.trimEnd()}
+methodology_version: ${version}
+`);
+  }
+}
+function walkFiles(dir, base = dir) {
+  const result = [];
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return result;
+  }
+  for (const ent of entries) {
+    const full = join4(dir, ent);
+    let st;
+    try {
+      st = statSync(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) result.push(...walkFiles(full, base));
+    else result.push(relative(base, full).replace(/\\/g, "/"));
+  }
+  return result;
+}
+function printDiff(relPath, before, after) {
+  if (before === after) return;
+  console.log(`--- a/${relPath}`);
+  console.log(`+++ b/${relPath}`);
+  const bLines = before ? before.split("\n") : [];
+  const aLines = after ? after.split("\n") : [];
+  const maxLen = Math.max(bLines.length, aLines.length);
+  let lastHunk = -1;
+  for (let i = 0; i < maxLen; i++) {
+    const bl = i < bLines.length ? bLines[i] : null;
+    const al = i < aLines.length ? aLines[i] : null;
+    if (bl !== al) {
+      if (lastHunk !== i - 1) console.log(`@@ -${i + 1},0 +${i + 1},0 @@`);
+      if (bl !== null) console.log(`-${bl}`);
+      if (al !== null) console.log(`+${al}`);
+      lastHunk = i;
+    }
+  }
+  console.log("");
+}
+function showTreeDiff(originalDir, modifiedDir) {
+  const origFiles = new Set(walkFiles(originalDir));
+  const modFiles = new Set(walkFiles(modifiedDir));
+  const allFiles = /* @__PURE__ */ new Set([...origFiles, ...modFiles]);
+  const changed = [];
+  for (const f of allFiles) {
+    const origContent = origFiles.has(f) ? readFileSync4(join4(originalDir, f), "utf8") : "";
+    const modContent = modFiles.has(f) ? readFileSync4(join4(modifiedDir, f), "utf8") : "";
+    if (origContent !== modContent) changed.push(f);
+  }
+  if (changed.length === 0) {
+    console.log("  No files would change.");
+    return false;
+  }
+  console.log(`  ${changed.length} file(s) would change:
+`);
+  for (const f of changed) {
+    const origContent = origFiles.has(f) ? readFileSync4(join4(originalDir, f), "utf8") : "";
+    const modContent = modFiles.has(f) ? readFileSync4(join4(modifiedDir, f), "utf8") : "";
+    printDiff(f, origContent, modContent);
+  }
+  return true;
+}
+function runScript(scriptPath, args) {
+  const r = spawnSync(process.execPath, [scriptPath, ...args], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return { exitCode: r.status ?? 1, output: (r.stdout ?? "") + (r.stderr ?? "") };
+}
+function runDryRun(chain, absTarget, toVersion) {
+  const tmpDir = mkdtempSync(join4(tmpdir(), "tx-migrate-"));
+  try {
+    cpSync(absTarget, tmpDir, { recursive: true });
+    let overallExit = 0;
+    for (let i = 0; i < chain.length; i++) {
+      const step = chain[i];
+      console.log(`Step ${i + 1}/${chain.length}: ${step.from} \u2192 ${step.to}`);
+      const { exitCode, output } = runScript(join4(step.dir, "codemod.mjs"), [tmpDir]);
+      process.stdout.write(output);
+      if (exitCode !== 0) {
+        console.error(`  codemod exited ${exitCode} \u2014 would require manual intervention`);
+        overallExit = exitCode;
+      }
+    }
+    console.log("\nFile changes:");
+    showTreeDiff(absTarget, tmpDir);
+    const currentVersion = readMethodologyVersion(absTarget);
+    console.log(`
+Would update methodology_version: ${currentVersion ?? "(none)"} \u2192 ${toFullSemver(toVersion)}`);
+    if (overallExit !== 0) {
+      console.error("\nDry-run: some steps would require manual intervention (see above).");
+      process.exit(overallExit);
+    }
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+function runApply(chain, absTarget, toVersion) {
+  for (let i = 0; i < chain.length; i++) {
+    const step = chain[i];
+    console.log(`Step ${i + 1}/${chain.length}: ${step.from} \u2192 ${step.to}`);
+    const codemodPath = join4(step.dir, "codemod.mjs");
+    const { exitCode: codemodExit, output: codemodOut } = runScript(codemodPath, [absTarget]);
+    process.stdout.write(codemodOut);
+    if (codemodExit !== 0) {
+      console.error(`
+transitrix migrate: codemod ${step.from}\u2192${step.to} exited ${codemodExit}.`);
+      console.error(`  Manual intervention required (see output above).`);
+      console.error(`  Fix the flagged files, then re-run from step ${i + 1}:`);
+      console.error(`  transitrix migrate --from ${step.from} --to ${toVersion} [target-dir]`);
+      process.exit(codemodExit);
+    }
+    const validatePath = join4(step.dir, "validate.mjs");
+    if (existsSync2(validatePath)) {
+      const { exitCode: valExit, output: valOut } = runScript(validatePath, [absTarget]);
+      process.stdout.write(valOut);
+      if (valExit !== 0) {
+        console.error(`
+transitrix migrate: post-step validation failed for ${step.from}\u2192${step.to}.`);
+        console.error(`  Fix the issues above, then re-run from step ${i + 1}:`);
+        console.error(`  transitrix migrate --from ${step.from} --to ${toVersion} [target-dir]`);
+        process.exit(valExit);
+      }
+    }
+    console.log(`  \u2713 step complete
+`);
+  }
+  const newVersion = toFullSemver(toVersion);
+  updateMethodologyVersion(absTarget, newVersion);
+  console.log(`\u2713 Migration complete: ${newVersion}`);
+  console.log(`  Updated methodology_version in ${join4(absTarget, TRANSITRIX_YAML)}`);
+  console.log(`  Review and commit when ready.`);
+}
+async function handleMigrateCommand(argv) {
+  const { from: rawFrom, to: rawTo, dryRun, recipesDir, targetDir, wantsHelp } = parseMigrateArgv(argv);
+  if (wantsHelp) {
+    console.error("usage: transitrix migrate [--from X.Y] [--to X.Y] [--dry-run] [--recipes <dir>] [target-dir]");
+    console.error("");
+    console.error("  Migrates an adopter repository from one methodology version to another");
+    console.error("  by running the ordered recipes from the methodology repo.");
+    console.error("");
+    console.error("  --from X.Y         Source version (default: methodology_version in transitrix.yaml)");
+    console.error("  --to X.Y           Target version (default: latest available recipe target)");
+    console.error("  --dry-run          Preview changes; no files written");
+    console.error("  --recipes <dir>    Path to recipes dir (default: ../methodology/migrations)");
+    console.error("  target-dir         Adopter repo root (default: current directory)");
+    process.exit(0);
+  }
+  const absTarget = resolve(targetDir);
+  if (!existsSync2(absTarget)) {
+    console.error(`transitrix migrate: target directory does not exist: ${absTarget}`);
+    process.exit(1);
+  }
+  const recipes = scanRecipes(recipesDir);
+  if (recipes.length === 0) {
+    console.error(`transitrix migrate: no recipes found in ${resolve(recipesDir)}`);
+    console.error(`  Expected subdirectories named X.Y-to-X.Y containing a codemod.mjs.`);
+    process.exit(1);
+  }
+  const fromVersion = rawFrom ? toMajorMinor(rawFrom) : (() => {
+    const v = readMethodologyVersion(absTarget);
+    if (!v) {
+      console.error(`transitrix migrate: cannot determine source version.`);
+      console.error(`  Add methodology_version: X.Y.Z to ${join4(absTarget, TRANSITRIX_YAML)}`);
+      console.error(`  or pass --from X.Y`);
+      process.exit(1);
+    }
+    return toMajorMinor(v);
+  })();
+  const toVersion = rawTo ? toMajorMinor(rawTo) : (() => {
+    const v = findFurthestReachable(fromVersion, recipes);
+    if (!v) {
+      console.error(`transitrix migrate: no recipes available from version ${fromVersion}`);
+      console.error(`  Available: ${recipes.map((r) => `${r.from}-to-${r.to}`).join(", ")}`);
+      process.exit(1);
+    }
+    return v;
+  })();
+  const chain = resolveChain(fromVersion, toVersion, recipes);
+  if (!chain) {
+    console.error(`transitrix migrate: no migration path from ${fromVersion} to ${toVersion}`);
+    console.error(`  Available: ${recipes.map((r) => `${r.from}-to-${r.to}`).join(", ")}`);
+    process.exit(1);
+  }
+  if (chain.length === 0) {
+    console.log(`transitrix migrate: already at ${toVersion} \u2014 nothing to do.`);
+    return;
+  }
+  console.log(`transitrix migrate: ${fromVersion} \u2192 ${toVersion} (${chain.length} step${chain.length === 1 ? "" : "s"})`);
+  if (dryRun) console.log(`  (dry-run \u2014 no files will be written)
+`);
+  else console.log("");
+  if (dryRun) {
+    runDryRun(chain, absTarget, toVersion);
+  } else {
+    runApply(chain, absTarget, toVersion);
+  }
+}
+
+// ../../src/cli.ts
+init_metrics();
+init_parser();
+init_validator();
+function printUsage() {
+  console.error(`Transitrix Studio CLI \u2014 usage:
+       transitrix serve [--port 8765] [--host 127.0.0.1]
+       transitrix <input.yaml> <output.bpmn> [--no-metrics] [--no-validate]
+       transitrix [--ext=.cervin.yaml,.bpmn.transitrix.yaml] <input.yaml> <output.bpmn> [--no-metrics] [--no-validate]
+       transitrix metrics <input.yaml> [--json]
+       transitrix metrics [--ext=.cervin.yaml,.bpmn.transitrix.yaml] <input.yaml> [--json]
+       transitrix validate <input.yaml> [--json]
+       transitrix validate [--ext=.cervin.yaml,.bpmn.transitrix.yaml] <input.yaml> [--json]
+       transitrix validate --scope=repo [--root <dir>] [--json]
+       transitrix export-compliance [--format md|pdf] [--scope law:<ID>|product:<ID>|gap] [--output <path>] [--root <dir>]
+       transitrix migrate [--from X.Y] [--to X.Y] [--dry-run] [--recipes <dir>] [target-dir]
+
+  ('cervin' is a deprecated alias of 'transitrix'; both run the same CLI.)
+
+  serve     \u2014 local web UI (run npm run ui:build once beforehand).
+  <compile> \u2014 YAML \u2192 BPMN 2.0 XML with layout metrics.
+  metrics   \u2014 layout quality metrics (with --json for CI).
+  validate  \u2014 validation only (no XML output; exit 1 on errors). Default scope
+              is a single file; --scope=repo runs whole-canon checks
+              (referential integrity, atomicity, id uniqueness, policy).
+  export-compliance \u2014 Markdown or PDF report of the compliance views (matrix by
+              default; law:/product:/gap scopes). Scans --root (default cwd) for
+              requirement/assertion/product/codex canon. PDF rendering requires
+              WeasyPrint on PATH (pipx install weasyprint).
+  migrate   \u2014 migrate an adopter repo to a newer methodology version by running
+              the ordered recipes from the methodology repo. Reads the current
+              version from transitrix.yaml (or --from X.Y); --dry-run previews
+              without writing; --recipes <dir> overrides the recipe source.
+
+  --no-metrics  suppress quality metrics report on compile.
+  --no-validate suppress validation warnings (errors always run).
+
+Examples:
+  npm run transitrix -- compile input.cervin.yaml output.bpmn
+  npm run transitrix -- serve
+  npm run transitrix -- metrics example.cervin.yaml --json
+  npm run transitrix -- validate example.cervin.yaml
+  npm run transitrix -- validate example.cervin.yaml --json
+  npm run transitrix -- migrate --dry-run
+  npm run transitrix -- migrate --from 0.5 --to 0.6 /path/to/adopter-repo
+`);
+}
+async function handleCompileCommand(argv) {
+  const parsed = parseCliFileArgv(argv);
+  if (!parsed.ok) {
+    console.error("transitrix: --ext requires a comma-separated list of suffixes.");
+    process.exit(1);
+  }
+  const { positional, extList, wantsHelp } = parsed;
+  const exts = extList.length > 0 ? extList : DEFAULT_CERVIN_FILE_EXTENSIONS;
+  if (wantsHelp) {
+    printUsage();
+    process.exit(0);
+  }
+  const [src, dst] = positional;
+  if (!src || !dst) {
+    console.error("transitrix compile: missing input or output file");
+    console.error(`usage: transitrix compile <input.yaml> <output.bpmn>`);
+    process.exit(1);
+  }
+  if (!inputMatchesExtension(src, exts)) {
+    console.error(
+      `transitrix: input file must end with one of: ${exts.join(", ")} (or pass --ext)`
+    );
+    process.exit(1);
+  }
+  const noMetrics = argv.includes("--no-metrics");
+  const noValidateWarnings = argv.includes("--no-validate");
+  try {
+    const yaml2 = await readFile2(src, "utf8");
+    const result = await compileTransitrixYamlWithLayout(yaml2);
+    writeFileSync2(dst, result.xml);
+    printValidationReport(src, result.validation, noValidateWarnings);
+    if (!noMetrics) {
+      const metrics = computeLayoutMetrics(result.layout);
+      printMetricsReport(src, dst, metrics);
+    }
+    if (!result.validation.isValid) {
+      process.exit(1);
+    }
+  } catch (e) {
+    const err = e;
+    console.error(err.message);
+    err.errors?.forEach((line) => console.error(`  \u2022 ${line}`));
+    process.exit(1);
+  }
+}
+function renderMetricsLines(metrics, showStatusIcons) {
+  const statusIcon = (value) => {
+    return value ? "\u2713" : "\u2717";
+  };
+  const port = showStatusIcons ? statusIcon(metrics.portViolations === 0) + " " : "";
+  const area = showStatusIcons ? statusIcon(metrics.emptyArea <= 0.3) + " " : "";
+  const spine = showStatusIcons ? statusIcon(metrics.spineDeviation <= 4) + " " : "";
+  console.log(`  Port violations    ${port}${metrics.portViolations}`);
+  console.log(`  Empty area         ${area}${(metrics.emptyArea * 100).toFixed(1)}%`);
+  console.log(`  Spine deviation    ${spine}${metrics.spineDeviation.toFixed(1)} px`);
+  console.log(`  Bends              ${metrics.bends}`);
+  console.log(`  Crossings          ${metrics.crossings}`);
+}
+function printMetricsReport(src, dst, metrics) {
+  console.log();
+  console.log(`\u2713 ${src} \u2192 ${dst}`);
+  console.log();
+  console.log("Layout Quality Metrics:");
+  renderMetricsLines(metrics, true);
+  console.log();
+}
+function printValidationReport(src, validation, suppressWarnings) {
+  const { findings, summary } = validation;
+  const visibleFindings = suppressWarnings ? findings.filter((f) => f.severity === "error") : findings;
+  if (visibleFindings.length === 0) {
+    return;
+  }
+  console.log();
+  console.log(`\u2713 ${src}`);
+  console.log();
+  console.log("Validation:");
+  for (const finding of visibleFindings) {
+    const icon = finding.severity === "error" ? "\u2717" : "\u26A0";
+    const prefix = finding.severity === "error" ? `\x1B[31m${icon} ${finding.ruleId}\x1B[0m` : `\x1B[33m${icon} ${finding.ruleId}\x1B[0m`;
+    console.log(`  ${prefix} ${finding.message}`);
+    if (finding.hint) {
+      console.log(`    \u2192 ${finding.hint}`);
+    }
+  }
+  const visible = {
+    errorCount: visibleFindings.filter((f) => f.severity === "error").length,
+    warningCount: visibleFindings.filter((f) => f.severity === "warning").length,
+    infoCount: visibleFindings.filter((f) => f.severity === "info").length
+  };
+  console.log();
+  const summaryParts = [];
+  if (visible.errorCount > 0) {
+    summaryParts.push(`\x1B[31m${visible.errorCount} error\x1B[0m${visible.errorCount === 1 ? "" : "s"}`);
+  }
+  if (visible.warningCount > 0 && !suppressWarnings) {
+    summaryParts.push(`\x1B[33m${visible.warningCount} warning\x1B[0m${visible.warningCount === 1 ? "" : "s"}`);
+  }
+  if (summaryParts.length > 0) {
+    console.log(`Validation: ${summaryParts.join(", ")}`);
+  }
+  console.log();
+}
+async function handleValidateCommand(argv) {
+  const parsed = parseValidateArgv(argv);
+  if (!parsed.ok) {
+    if (parsed.error === "bad_scope") {
+      console.error('transitrix validate: --scope must be "file" or "repo".');
+    } else if (parsed.error === "--scope_requires_value") {
+      console.error("transitrix validate: --scope requires a value (file|repo).");
+    } else if (parsed.error === "--root_requires_value") {
+      console.error("transitrix validate: --root requires a directory path.");
+    } else {
+      console.error("transitrix: --ext requires a comma-separated list of suffixes.");
+    }
+    process.exit(1);
+  }
+  const { scope, root, positional, extList, wantsHelp } = parsed;
+  const exts = extList.length > 0 ? extList : DEFAULT_CERVIN_FILE_EXTENSIONS;
+  const useJson = argv.includes("--json");
+  if (wantsHelp) {
+    console.error(`usage: transitrix validate <input.yaml> [--json]                 (file scope, default)`);
+    console.error(`       transitrix validate --scope=repo [--root <dir>] [--json]`);
+    console.error("");
+    console.error("file scope \u2014 single-file structural/semantic validation (default).");
+    console.error("repo scope \u2014 whole-canon checks (referential integrity, atomicity,");
+    console.error("             id uniqueness, policy) over <root> (default: cwd).");
+    console.error("Exits with code 1 if any findings.");
+    process.exit(0);
+  }
+  if (scope === "repo") {
+    const repoRoot = root ?? process.cwd();
+    const repoModule = "./repo-validate.js";
+    const { runRepoValidate, reportRepoFindings } = await import(repoModule);
+    const findings = runRepoValidate(repoRoot);
+    reportRepoFindings(repoRoot, findings, useJson);
+    if (findings.length > 0) {
+      process.exit(1);
+    }
+    return;
+  }
+  const [src] = positional;
+  if (!src) {
+    console.error("transitrix validate: missing input file");
+    console.error(`usage: transitrix validate <input.yaml> [--json]`);
+    process.exit(1);
+  }
+  if (!inputMatchesExtension(src, exts)) {
+    console.error(
+      `transitrix: input file must end with one of: ${exts.join(", ")} (or pass --ext)`
+    );
+    process.exit(1);
+  }
+  let yaml2;
+  try {
+    yaml2 = await readFile2(src, "utf8");
+  } catch (e) {
+    const err = e;
+    if (useJson) {
+      console.log(JSON.stringify({ valid: false, message: err.message }, null, 2));
+    } else {
+      console.error(`\u2717 ${src}`);
+      console.error();
+      console.error(`Read error: ${err.message}`);
+      console.error();
+    }
+    process.exit(1);
+  }
+  let ir;
+  try {
+    ir = parseYamlToIr(yaml2);
+  } catch (e) {
+    const err = e;
+    if (useJson) {
+      const output = {
+        valid: false,
+        message: err.message,
+        errors: err.errors ?? []
+      };
+      console.log(JSON.stringify(output, null, 2));
+    } else {
+      console.error(`\u2717 ${src}`);
+      console.error();
+      console.error(`Parse error: ${err.message}`);
+      if (err.errors && err.errors.length > 0) {
+        console.error();
+        console.error("Details:");
+        for (const detail of err.errors) {
+          console.error(`  - ${detail}`);
+        }
+      }
+      console.error();
+    }
+    process.exit(1);
+  }
+  const report = validateProcess(ir);
+  if (useJson) {
+    const output = {
+      valid: report.isValid,
+      findings: report.findings.map((f) => ({
+        ruleId: f.ruleId,
+        severity: f.severity,
+        message: f.message,
+        elementId: f.elementId || null,
+        hint: f.hint || null
+      })),
+      summary: report.summary
+    };
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    if (report.findings.length === 0) {
+      console.log(`\u2713 ${src} \u2014 valid`);
+      console.log();
+    } else {
+      printValidationReport(src, report, false);
+    }
+  }
+  if (!report.isValid) {
+    process.exit(1);
+  }
+}
+async function handleMetricsCommand(argv) {
+  const parsed = parseCliFileArgv(argv);
+  if (!parsed.ok) {
+    console.error("transitrix: --ext requires a comma-separated list of suffixes.");
+    process.exit(1);
+  }
+  const { positional, extList, wantsHelp } = parsed;
+  const exts = extList.length > 0 ? extList : DEFAULT_CERVIN_FILE_EXTENSIONS;
+  const useJson = argv.includes("--json");
+  if (wantsHelp) {
+    printUsage();
+    process.exit(0);
+  }
+  const [src] = positional;
+  if (!src) {
+    console.error("transitrix metrics: missing input file");
+    console.error(`usage: transitrix metrics <input.yaml> [--json]`);
+    process.exit(1);
+  }
+  if (!inputMatchesExtension(src, exts)) {
+    console.error(
+      `transitrix: input file must end with one of: ${exts.join(", ")} (or pass --ext)`
+    );
+    process.exit(1);
+  }
+  try {
+    const yaml2 = await readFile2(src, "utf8");
+    const result = await compileTransitrixYamlWithLayout(yaml2);
+    const metrics = computeLayoutMetrics(result.layout);
+    if (useJson) {
+      console.log(JSON.stringify(metrics, null, 2));
+    } else {
+      console.log();
+      console.log(`\u2713 ${src}`);
+      console.log();
+      console.log("Layout Quality Metrics:");
+      renderMetricsLines(metrics, true);
+      console.log();
+    }
+  } catch (e) {
+    const err = e;
+    console.error(err.message);
+    err.errors?.forEach((line) => console.error(`  \u2022 ${line}`));
+    process.exit(1);
+  }
+}
+if (invokedAsCervin(process.argv[1])) {
+  console.error(CERVIN_DEPRECATION_NOTICE);
+}
+var subcommand = process.argv[2];
+if (subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
+  printUsage();
+  process.exit(0);
+}
+try {
+  if (subcommand === "serve") {
+    const serveArgv = process.argv.slice(3);
+    try {
+      const { cliServeArgv: cliServeArgv2 } = await Promise.resolve().then(() => (init_serve_ui(), serve_ui_exports));
+      await cliServeArgv2(serveArgv);
+    } catch (e) {
+      const err = e;
+      console.error(err.message);
+      process.exit(1);
+    }
+  } else if (subcommand === "metrics") {
+    await handleMetricsCommand(process.argv.slice(3));
+  } else if (subcommand === "validate") {
+    await handleValidateCommand(process.argv.slice(3));
+  } else if (subcommand === "export-compliance") {
+    const handlerModule = "./export-compliance.js";
+    const { handleExportComplianceCommand } = await import(handlerModule);
+    await handleExportComplianceCommand(process.argv.slice(3));
+  } else if (subcommand === "migrate") {
+    await handleMigrateCommand(process.argv.slice(3));
+  } else if (!subcommand || subcommand === "compile") {
+    const compileArgv = subcommand === "compile" ? process.argv.slice(3) : process.argv.slice(2);
+    await handleCompileCommand(compileArgv);
+  } else {
+    console.error(`transitrix: unknown command '${subcommand}'`);
+    printUsage();
+    process.exit(1);
+  }
+} catch (e) {
+  const err = e;
+  console.error(`transitrix: unexpected error: ${err.message ?? String(e)}`);
+  process.exit(1);
+}