@bpmnkit/core 0.0.26 → 0.1.0

package/dist/layout/types.d.ts

@@ -5,13 +5,13 @@ export declare const ELEMENT_SIZES: Record<string, {
     height: number;
 }>;
 /** Virtual grid cell dimensions for element placement. */
-export declare const GRID_CELL_WIDTH = 130;
+export declare const GRID_CELL_WIDTH = 150;
 export declare const GRID_CELL_HEIGHT = 140;
 /** Minimum spacing between elements (derived from grid). */
 export declare const HORIZONTAL_SPACING: number;
 export declare const VERTICAL_SPACING: number;
 /** Padding inside sub-process containers. */
-export declare const SUBPROCESS_PADDING = 20;
+export declare const SUBPROCESS_PADDING = 50;
 /** Edge-label sizing constants (used for placement & collision detection). */
 export declare const LABEL_CHAR_WIDTH = 7;
 export declare const LABEL_MIN_WIDTH = 40;

package/dist/layout/types.js

@@ -12,23 +12,27 @@ export const ELEMENT_SIZES = {
     receiveTask: { width: 100, height: 80 },
     businessRuleTask: { width: 100, height: 80 },
     callActivity: { width: 100, height: 80 },
+    task: { width: 100, height: 80 },
+    manualTask: { width: 100, height: 80 },
     exclusiveGateway: { width: 50, height: 50 },
     parallelGateway: { width: 50, height: 50 },
     inclusiveGateway: { width: 50, height: 50 },
     eventBasedGateway: { width: 50, height: 50 },
+    complexGateway: { width: 50, height: 50 },
     // Sub-processes are sized dynamically
     subProcess: { width: 100, height: 80 },
     adHocSubProcess: { width: 100, height: 80 },
     eventSubProcess: { width: 100, height: 80 },
+    transaction: { width: 100, height: 80 },
 };
 /** Virtual grid cell dimensions for element placement. */
-export const GRID_CELL_WIDTH = 130;
+export const GRID_CELL_WIDTH = 150;
 export const GRID_CELL_HEIGHT = 140;
 /** Minimum spacing between elements (derived from grid). */
 export const HORIZONTAL_SPACING = GRID_CELL_WIDTH - 100; // 100 = max element width
 export const VERTICAL_SPACING = GRID_CELL_HEIGHT - 80; // 80 = max element height
 /** Padding inside sub-process containers. */
-export const SUBPROCESS_PADDING = 20;
+export const SUBPROCESS_PADDING = 50;
 /** Edge-label sizing constants (used for placement & collision detection). */
 export const LABEL_CHAR_WIDTH = 7;
 export const LABEL_MIN_WIDTH = 40;

package/dist/xml/xml-parser.js

@@ -238,6 +238,11 @@ function writeElement(parts, el, depth) {
     const indent = "  ".repeat(depth);
     parts.push(indent, "<", el.name);
     for (const [key, value] of Object.entries(el.attributes)) {
+        // el.attributes is typed Record<string, string>, but content built from
+        // generated/untyped code can leave a value undefined at runtime — skip
+        // rather than crash the whole serialization on one bad attribute.
+        if (typeof value !== "string")
+            continue;
         parts.push(" ", key, '="', escapeAttr(value), '"');
     }
     const hasChildren = el.children.length > 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmnkit/core",
-  "version": "0.0.26",
+  "version": "0.1.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/layout/astar.d.ts

@@ -1,15 +0,0 @@
-import type { Bounds, Waypoint } from "./types.js";
-/**
- * Route a single edge using A* on a 10px grid.
- * source/target are center points of source/target nodes.
- * obstacles are node bounding boxes to avoid (inflated by 6px margin).
- * Returns simplified orthogonal waypoints.
- */
-export declare function routeEdgeAstar(source: {
-    x: number;
-    y: number;
-}, target: {
-    x: number;
-    y: number;
-}, obstacles: Bounds[], canvasWidth: number, canvasHeight: number): Waypoint[];
-//# sourceMappingURL=astar.d.ts.map

package/dist/layout/astar.js

@@ -1,191 +0,0 @@
-const GRID_RES = 10;
-const OBSTACLE_MARGIN = 6;
-const TURN_PENALTY = 5;
-const CANVAS_EXTEND = 80;
-const DX = [1, 0, -1, 0];
-const DY = [0, 1, 0, -1];
-/** Minimal binary min-heap keyed by f-score. */
-class MinHeap {
-    data = [];
-    push(f, key) {
-        this.data.push({ f, key });
-        this.bubbleUp(this.data.length - 1);
-    }
-    pop() {
-        const top = this.data[0];
-        const last = this.data.pop();
-        if (this.data.length > 0 && last !== undefined) {
-            this.data[0] = last;
-            this.sinkDown(0);
-        }
-        return top;
-    }
-    get size() {
-        return this.data.length;
-    }
-    bubbleUp(startIdx) {
-        let i = startIdx;
-        while (i > 0) {
-            const parent = (i - 1) >> 1;
-            const d = this.data[i];
-            const p = this.data[parent];
-            if (!d || !p || p.f <= d.f)
-                break;
-            this.data[i] = p;
-            this.data[parent] = d;
-            i = parent;
-        }
-    }
-    sinkDown(startIdx) {
-        let i = startIdx;
-        for (;;) {
-            const left = 2 * i + 1;
-            const right = 2 * i + 2;
-            let smallest = i;
-            const d = this.data[smallest];
-            const l = this.data[left];
-            const r = this.data[right];
-            if (l && l.f < (d?.f ?? Number.POSITIVE_INFINITY))
-                smallest = left;
-            const s = this.data[smallest];
-            if (r && r.f < (s?.f ?? Number.POSITIVE_INFINITY))
-                smallest = right;
-            if (smallest === i)
-                break;
-            const tmp = this.data[i];
-            const sm = this.data[smallest];
-            if (!tmp || !sm)
-                break;
-            this.data[i] = sm;
-            this.data[smallest] = tmp;
-            i = smallest;
-        }
-    }
-}
-/**
- * Route a single edge using A* on a 10px grid.
- * source/target are center points of source/target nodes.
- * obstacles are node bounding boxes to avoid (inflated by 6px margin).
- * Returns simplified orthogonal waypoints.
- */
-export function routeEdgeAstar(source, target, obstacles, canvasWidth, canvasHeight) {
-    // Extend canvas to allow routing around edges
-    const minX = Math.max(0, Math.min(source.x, target.x) - CANVAS_EXTEND);
-    const minY = Math.max(0, Math.min(source.y, target.y) - CANVAS_EXTEND);
-    const maxX = Math.max(source.x, target.x) + CANVAS_EXTEND + canvasWidth;
-    const maxY = Math.max(source.y, target.y) + CANVAS_EXTEND + canvasHeight;
-    const cols = Math.ceil((maxX - minX) / GRID_RES) + 1;
-    const rows = Math.ceil((maxY - minY) / GRID_RES) + 1;
-    // Snap source and target to grid
-    const sx = Math.round((source.x - minX) / GRID_RES);
-    const sy = Math.round((source.y - minY) / GRID_RES);
-    const tx = Math.round((target.x - minX) / GRID_RES);
-    const ty = Math.round((target.y - minY) / GRID_RES);
-    // If they're at the same grid cell, return straight line
-    if (sx === tx && sy === ty) {
-        return [source, target];
-    }
-    // Build blocked grid
-    const blocked = new Uint8Array(cols * rows);
-    for (const ob of obstacles) {
-        const ox1 = Math.floor((ob.x - OBSTACLE_MARGIN - minX) / GRID_RES);
-        const oy1 = Math.floor((ob.y - OBSTACLE_MARGIN - minY) / GRID_RES);
-        const ox2 = Math.ceil((ob.x + ob.width + OBSTACLE_MARGIN - minX) / GRID_RES);
-        const oy2 = Math.ceil((ob.y + ob.height + OBSTACLE_MARGIN - minY) / GRID_RES);
-        for (let gy = Math.max(0, oy1); gy <= Math.min(rows - 1, oy2); gy++) {
-            for (let gx = Math.max(0, ox1); gx <= Math.min(cols - 1, ox2); gx++) {
-                blocked[gy * cols + gx] = 1;
-            }
-        }
-    }
-    // Unblock source and target cells (they're inside nodes)
-    blocked[sy * cols + sx] = 0;
-    blocked[ty * cols + tx] = 0;
-    // A* with direction-aware state: state = cell * 4 + dir
-    const INF = Number.MAX_SAFE_INTEGER;
-    // g-scores per (cell, dir)
-    const g = new Float32Array(cols * rows * 4).fill(INF);
-    const parent = new Int32Array(cols * rows * 4).fill(-1);
-    const parentDir = new Int8Array(cols * rows * 4).fill(-1);
-    const heap = new MinHeap();
-    // Initialize: try all 4 directions from source
-    for (let d = 0; d < 4; d++) {
-        const key = (sy * cols + sx) * 4 + d;
-        g[key] = 0;
-        const h = Math.abs(tx - sx) + Math.abs(ty - sy);
-        heap.push(h, key);
-    }
-    let found = false;
-    while (heap.size > 0) {
-        const item = heap.pop();
-        if (!item)
-            break;
-        const { key } = item;
-        const dir = key % 4;
-        const cell = (key - dir) / 4;
-        const cx = cell % cols;
-        const cy = (cell - cx) / cols;
-        if (cx === tx && cy === ty) {
-            found = true;
-            // Reconstruct path
-            const path = [];
-            let k = key;
-            while (k !== -1) {
-                const kDir = k % 4;
-                const kCell = (k - kDir) / 4;
-                const kx = kCell % cols;
-                const ky = (kCell - kx) / cols;
-                path.push({ x: kx * GRID_RES + minX, y: ky * GRID_RES + minY });
-                k = parent[k] ?? -1;
-            }
-            path.reverse();
-            // Simplify collinear points
-            return simplifyPath(path);
-        }
-        const gCur = g[key] ?? INF;
-        for (let nd = 0; nd < 4; nd++) {
-            const nx = cx + (DX[nd] ?? 0);
-            const ny = cy + (DY[nd] ?? 0);
-            if (nx < 0 || nx >= cols || ny < 0 || ny >= rows)
-                continue;
-            const ncell = ny * cols + nx;
-            if (blocked[ncell])
-                continue;
-            const nkey = ncell * 4 + nd;
-            const turnCost = nd !== dir ? TURN_PENALTY : 0;
-            const ng = gCur + 1 + turnCost;
-            const prevG = g[nkey] ?? INF;
-            if (ng < prevG) {
-                g[nkey] = ng;
-                parent[nkey] = key;
-                parentDir[nkey] = dir;
-                const h = Math.abs(tx - nx) + Math.abs(ty - ny);
-                heap.push(ng + h, nkey);
-            }
-        }
-    }
-    if (!found) {
-        // Fall back to straight line
-        return [source, target];
-    }
-    return [source, target];
-}
-/** Remove collinear intermediate waypoints. */
-function simplifyPath(path) {
-    if (path.length <= 2)
-        return path;
-    const result = [path[0]];
-    for (let i = 1; i < path.length - 1; i++) {
-        const prev = path[i - 1];
-        const curr = path[i];
-        const next = path[i + 1];
-        const isCollinear = (Math.abs(prev.x - curr.x) < 0.5 && Math.abs(curr.x - next.x) < 0.5) ||
-            (Math.abs(prev.y - curr.y) < 0.5 && Math.abs(curr.y - next.y) < 0.5);
-        if (!isCollinear) {
-            result.push(curr);
-        }
-    }
-    result.push(path[path.length - 1]);
-    return result;
-}
-//# sourceMappingURL=astar.js.map

package/dist/layout/block-builder.d.ts

@@ -1,37 +0,0 @@
-import type { BpmnElementType, BpmnFlowElement } from "../bpmn/bpmn-model.js";
-import type { DirectedGraph } from "./graph.js";
-export type FlowBlock = NodeBlock | GatewayBlock | SequenceBlock;
-export interface NodeBlock {
-    kind: "node";
-    id: string;
-    type: BpmnElementType;
-    label?: string;
-    width: number;
-    height: number;
-    x: number;
-    y: number;
-}
-export interface SequenceBlock {
-    kind: "sequence";
-    items: FlowBlock[];
-    width: number;
-    height: number;
-    x: number;
-    y: number;
-}
-export interface GatewayBlock {
-    kind: "gateway";
-    split: NodeBlock;
-    join: NodeBlock;
-    branches: SequenceBlock[];
-    branchColumnWidth: number;
-    width: number;
-    height: number;
-    x: number;
-    y: number;
-}
-/**
- * Attempt to build block tree. Returns null if process is unstructured.
- */
-export declare function buildBlockTree(dag: DirectedGraph, nodeIndex: Map<string, BpmnFlowElement>): SequenceBlock | null;
-//# sourceMappingURL=block-builder.d.ts.map

package/dist/layout/block-builder.js

@@ -1,154 +0,0 @@
-import { topologicalSort } from "./graph.js";
-import { ELEMENT_SIZES } from "./types.js";
-const GATEWAY_TYPES = new Set([
-    "exclusiveGateway",
-    "parallelGateway",
-    "inclusiveGateway",
-    "eventBasedGateway",
-    "complexGateway",
-]);
-/** Make a NodeBlock for the given element. */
-function makeNodeBlock(id, nodeIndex) {
-    const el = nodeIndex.get(id);
-    const type = el?.type ?? "serviceTask";
-    const size = ELEMENT_SIZES[type] ?? { width: 100, height: 80 };
-    return {
-        kind: "node",
-        id,
-        type,
-        label: el?.name,
-        width: size.width,
-        height: size.height,
-        x: 0,
-        y: 0,
-    };
-}
-/**
- * Find the matching join gateway for a split gateway.
- * Uses a depth counter across the topoOrder of provided node IDs:
- * +1 for each split (outDegree≥2), -1 for each join (inDegree≥2).
- * First time depth returns to 0 → that's the matching join.
- */
-function findMatchingJoin(splitId, orderedIds, splitPos, dag, nodeIndex) {
-    let depth = 1;
-    for (let j = splitPos + 1; j < orderedIds.length; j++) {
-        const id = orderedIds[j];
-        if (!id)
-            continue;
-        const el = nodeIndex.get(id);
-        if (!el || !GATEWAY_TYPES.has(el.type))
-            continue;
-        const outDegree = (dag.successors.get(id) ?? []).length;
-        const inDegree = (dag.predecessors.get(id) ?? []).length;
-        if (outDegree >= 2)
-            depth++;
-        if (inDegree >= 2) {
-            depth--;
-            if (depth === 0)
-                return id;
-        }
-    }
-    return undefined;
-}
-/**
- * Collect all node IDs reachable from startId before reaching stopId (exclusive).
- * Uses BFS over DAG successors. The stop node is not included.
- */
-function collectBranchNodes(startId, stopId, dag) {
-    const result = [];
-    const seen = new Set();
-    const queue = [startId];
-    while (queue.length > 0) {
-        const id = queue.shift();
-        if (!id || seen.has(id) || id === stopId)
-            continue;
-        seen.add(id);
-        result.push(id);
-        for (const succ of dag.successors.get(id) ?? []) {
-            if (!seen.has(succ) && succ !== stopId) {
-                queue.push(succ);
-            }
-        }
-    }
-    return result;
-}
-/**
- * Build a SequenceBlock for the given ordered list of node IDs.
- * Recursively handles nested gateways.
- * Throws if the structure is unstructured (no matching join found).
- */
-function buildSequenceFromIds(orderedIds, dag, nodeIndex, topoPos) {
-    const items = [];
-    let i = 0;
-    while (i < orderedIds.length) {
-        const id = orderedIds[i];
-        if (!id) {
-            i++;
-            continue;
-        }
-        const el = nodeIndex.get(id);
-        const outDegree = (dag.successors.get(id) ?? []).length;
-        const isSplit = outDegree >= 2 && el !== undefined && GATEWAY_TYPES.has(el.type);
-        if (isSplit) {
-            // This is a split gateway — find its matching join within orderedIds
-            const joinId = findMatchingJoin(id, orderedIds, i, dag, nodeIndex);
-            if (!joinId)
-                throw new Error(`No matching join for split gateway ${id}`);
-            const joinPos = orderedIds.indexOf(joinId);
-            if (joinPos < 0)
-                throw new Error(`Join ${joinId} not in current sequence`);
-            // For each successor of split, collect branch nodes (up to join)
-            const successors = dag.successors.get(id) ?? [];
-            const branches = [];
-            for (const succId of successors) {
-                // Collect nodes in this branch (BFS stopping at join)
-                const branchNodes = collectBranchNodes(succId, joinId, dag);
-                // Filter to only nodes that appear in orderedIds (safety)
-                const branchSet = new Set(branchNodes);
-                // Sort by topo position
-                const branchOrdered = orderedIds.filter((nid) => branchSet.has(nid));
-                branches.push(buildSequenceFromIds(branchOrdered, dag, nodeIndex, topoPos));
-            }
-            const splitBlock = makeNodeBlock(id, nodeIndex);
-            const joinBlock = makeNodeBlock(joinId, nodeIndex);
-            const gatewayBlock = {
-                kind: "gateway",
-                split: splitBlock,
-                join: joinBlock,
-                branches,
-                branchColumnWidth: 0,
-                width: 0,
-                height: 0,
-                x: 0,
-                y: 0,
-            };
-            items.push(gatewayBlock);
-            // Skip past the join gateway
-            i = joinPos + 1;
-        }
-        else {
-            items.push(makeNodeBlock(id, nodeIndex));
-            i++;
-        }
-    }
-    return { kind: "sequence", items, width: 0, height: 0, x: 0, y: 0 };
-}
-/**
- * Attempt to build block tree. Returns null if process is unstructured.
- */
-export function buildBlockTree(dag, nodeIndex) {
-    try {
-        const topoOrder = topologicalSort(dag);
-        const topoPos = new Map();
-        for (let i = 0; i < topoOrder.length; i++) {
-            const id = topoOrder[i];
-            if (id)
-                topoPos.set(id, i);
-        }
-        return buildSequenceFromIds(topoOrder, dag, nodeIndex, topoPos);
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=block-builder.js.map

package/dist/layout/block-layout.d.ts

@@ -1,9 +0,0 @@
-import type { BpmnFlowElement } from "../bpmn/bpmn-model.js";
-import type { SequenceBlock } from "./block-builder.js";
-import type { LayoutNode } from "./types.js";
-/**
- * Apply block-based layout: size (bottom-up) then position (top-down).
- * Returns LayoutNode[] with absolute positions.
- */
-export declare function applyBlockLayout(root: SequenceBlock, nodeIndex: Map<string, BpmnFlowElement>): LayoutNode[];
-//# sourceMappingURL=block-layout.d.ts.map

package/dist/layout/block-layout.js

@@ -1,163 +0,0 @@
-import { ELEMENT_SIZES } from "./types.js";
-import { GRID_CELL_WIDTH } from "./types.js";
-const H_GAP = 50;
-const V_GAP = 80;
-const OUTER_PADDING = 40;
-/** Compute label bounds for a laid-out block node (same logic as coordinates.ts). */
-function computeLabelBoundsForBlock(block, nodeIndex) {
-    const el = nodeIndex.get(block.id);
-    if (!el?.name)
-        return undefined;
-    const labelWidth = Math.min(Math.max(el.name.length * 7, 40), GRID_CELL_WIDTH);
-    const labelHeight = 14;
-    switch (block.type) {
-        case "startEvent":
-        case "endEvent":
-        case "intermediateThrowEvent":
-        case "intermediateCatchEvent":
-        case "exclusiveGateway":
-        case "parallelGateway":
-        case "inclusiveGateway":
-        case "eventBasedGateway":
-            return {
-                x: block.x + block.width / 2 - labelWidth / 2,
-                y: block.y + block.height + 4,
-                width: labelWidth,
-                height: labelHeight,
-            };
-        default:
-            return undefined;
-    }
-}
-function countBlockNodes(block) {
-    if (block.kind === "node")
-        return 1;
-    if (block.kind === "sequence")
-        return block.items.reduce((s, b) => s + countBlockNodes(b), 0);
-    return 2 + block.branches.reduce((s, b) => s + countBlockNodes(b), 0);
-}
-/** Size a block bottom-up: sets width/height on all blocks in the tree. */
-function sizeBlock(block) {
-    if (block.kind === "node") {
-        const size = ELEMENT_SIZES[block.type] ?? { width: 100, height: 80 };
-        block.width = size.width;
-        block.height = size.height;
-    }
-    else if (block.kind === "sequence") {
-        for (const item of block.items) {
-            sizeBlock(item);
-        }
-        const n = block.items.length;
-        block.width =
-            block.items.reduce((sum, item) => sum + item.width, 0) + Math.max(0, n - 1) * H_GAP;
-        block.height = block.items.reduce((max, item) => Math.max(max, item.height), 0);
-    }
-    else {
-        // GatewayBlock
-        sizeBlock(block.split);
-        sizeBlock(block.join);
-        for (const branch of block.branches) {
-            sizeBlock(branch);
-        }
-        block.branchColumnWidth =
-            block.branches.length > 0 ? block.branches.reduce((max, b) => Math.max(max, b.width), 0) : 0;
-        block.width = block.split.width + H_GAP + block.branchColumnWidth + H_GAP + block.join.width;
-        // Each branch gets at least V_GAP height (for empty bypass edges).
-        // Use effectiveH consistently in both sizing and positioning.
-        const totalBranchH = block.branches.reduce((sum, b) => sum + Math.max(b.height, V_GAP), 0) +
-            Math.max(0, block.branches.length - 1) * V_GAP;
-        block.height = Math.max(totalBranchH, block.split.height, block.join.height);
-    }
-}
-/** Position a block top-down given its absolute (x,y) top-left origin. */
-function positionBlock(block, x, y) {
-    block.x = x;
-    block.y = y;
-    if (block.kind === "node") {
-        // Nothing more to do — leaf
-    }
-    else if (block.kind === "sequence") {
-        let curX = x;
-        for (const item of block.items) {
-            // Center each item vertically within the sequence
-            const itemY = y + (block.height - item.height) / 2;
-            positionBlock(item, curX, itemY);
-            curX += item.width + H_GAP;
-        }
-    }
-    else {
-        // GatewayBlock: split at left, join at right, branches stacked in middle
-        const splitY = y + block.height / 2 - block.split.height / 2;
-        positionBlock(block.split, x, splitY);
-        const joinX = x + block.width - block.join.width;
-        const joinY = y + block.height / 2 - block.join.height / 2;
-        positionBlock(block.join, joinX, joinY);
-        // Reorder branches: heaviest (most nodes) at center, alternating above/below
-        const sortedBySize = [...block.branches].sort((a, b) => countBlockNodes(b) - countBlockNodes(a));
-        const bc = block.branches.length;
-        const orderedBranches = new Array(bc);
-        const bm = Math.floor((bc - 1) / 2);
-        // biome-ignore lint/style/noNonNullAssertion: sortedBySize is non-empty (bc >= 1)
-        orderedBranches[bm] = sortedBySize[0];
-        let ba = bm - 1;
-        let bb = bm + 1;
-        for (let si = 1; si < bc;) {
-            // biome-ignore lint/style/noNonNullAssertion: si < bc ensures element exists
-            if (bb < bc && si < bc)
-                orderedBranches[bb++] = sortedBySize[si++];
-            // biome-ignore lint/style/noNonNullAssertion: si < bc ensures element exists
-            if (ba >= 0 && si < bc)
-                orderedBranches[ba--] = sortedBySize[si++];
-        }
-        block.branches = orderedBranches;
-        // Branches stacked top-to-bottom, using effectiveH matching sizeBlock
-        const totalBranchH = block.branches.reduce((sum, b) => sum + Math.max(b.height, V_GAP), 0) +
-            Math.max(0, block.branches.length - 1) * V_GAP;
-        const branchX = x + block.split.width + H_GAP;
-        let branchY = y + (block.height - totalBranchH) / 2;
-        for (const branch of block.branches) {
-            const effectiveH = Math.max(branch.height, V_GAP);
-            positionBlock(branch, branchX, branchY + (effectiveH - branch.height) / 2);
-            branchY += effectiveH + V_GAP;
-        }
-    }
-}
-/** Flatten block tree into LayoutNode list. */
-function flattenBlock(block, nodeIndex, out) {
-    if (block.kind === "node") {
-        const layoutNode = {
-            id: block.id,
-            type: block.type,
-            bounds: { x: block.x, y: block.y, width: block.width, height: block.height },
-            layer: 0,
-            position: 0,
-            label: block.label,
-        };
-        layoutNode.labelBounds = computeLabelBoundsForBlock(block, nodeIndex);
-        out.push(layoutNode);
-    }
-    else if (block.kind === "sequence") {
-        for (const item of block.items) {
-            flattenBlock(item, nodeIndex, out);
-        }
-    }
-    else {
-        flattenBlock(block.split, nodeIndex, out);
-        flattenBlock(block.join, nodeIndex, out);
-        for (const branch of block.branches) {
-            flattenBlock(branch, nodeIndex, out);
-        }
-    }
-}
-/**
- * Apply block-based layout: size (bottom-up) then position (top-down).
- * Returns LayoutNode[] with absolute positions.
- */
-export function applyBlockLayout(root, nodeIndex) {
-    sizeBlock(root);
-    positionBlock(root, OUTER_PADDING, OUTER_PADDING);
-    const nodes = [];
-    flattenBlock(root, nodeIndex, nodes);
-    return nodes;
-}
-//# sourceMappingURL=block-layout.js.map