@bpmn-ld/bpmn-ld 0.0.0-stage → 0.2.0

package/dist/layout/layout.js

@@ -0,0 +1,299 @@
+import { compileSchema, validateWithSchema } from "../schema-validate.js";
+import { layoutCollaboration } from "./collaboration.js";
+import { buildDiagram, containerElement, diagramProperties, edgeElement, shapeElement } from "./di.js";
+import { extractProcess } from "./extract.js";
+import { extractLanes, flattenLanes } from "./lanes.js";
+import { allFlows, allNodes } from "./model.js";
+import { placeStandalone } from "./standalone.js";
+export class LayoutInputError extends Error {
+    errors;
+    constructor(errors) {
+        super(`invalid BPMN-LD document: ${errors[0]}`);
+        this.name = "LayoutInputError";
+        this.errors = errors;
+    }
+}
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+let compiled;
+const schema = () => (compiled ??= compileSchema());
+const collectIds = (value, found) => {
+    if (Array.isArray(value))
+        value.forEach((item) => collectIds(item, found));
+    else if (isObject(value)) {
+        if (typeof value.id === "string")
+            found.add(value.id);
+        Object.values(value).forEach((item) => collectIds(item, found));
+    }
+    return found;
+};
+const diagramsOf = (graph, processId) => graph.filter((node) => node.type === "BPMNDiagram" && isObject(node.plane) && node.plane.bpmnElement === processId);
+const isBox = (bounds) => isObject(bounds) && ["x", "y", "width", "height"].every((key) => Number.isFinite(bounds[key]));
+const elementsOf = (diagrams) => diagrams.flatMap((diagram) => (Array.isArray(diagram.plane.planeElements) ? diagram.plane.planeElements.filter(isObject) : []));
+const previousIds = (diagrams) => {
+    const previous = {
+        diagram: diagrams[0].id,
+        plane: diagrams[0].plane.id,
+        name: diagrams[0].name,
+        resolution: diagrams[0].resolution,
+        messageVisibleKinds: new Map(),
+        shapes: new Map(),
+        edges: new Map(),
+    };
+    for (const element of elementsOf(diagrams)) {
+        if (typeof element.id !== "string" || typeof element.bpmnElement !== "string")
+            continue;
+        const table = element.type === "BPMNShape" ? previous.shapes : element.type === "BPMNEdge" ? previous.edges : undefined;
+        if (table && !table.has(element.bpmnElement)) {
+            table.set(element.bpmnElement, element.id);
+            if (element.type === "BPMNEdge" && element.messageVisibleKind !== undefined)
+                previous.messageVisibleKinds.set(element.bpmnElement, element.messageVisibleKind);
+        }
+    }
+    return previous;
+};
+const collapsedShapes = (diagrams) => new Set(elementsOf(diagrams)
+    .filter((element) => element.type === "BPMNShape" && element.isExpanded === false && typeof element.bpmnElement === "string")
+    .map((element) => element.bpmnElement));
+const nestedLaneIds = (model) => model.nodes.flatMap((node) => (node.content ? [...(node.content.lanes?.ids ?? []), ...nestedLaneIds(node.content)] : []));
+const ownersOf = (model, owners = new Map()) => {
+    for (const item of model.data)
+        owners.set(item.id, model.id);
+    for (const node of model.nodes) {
+        owners.set(node.id, model.id);
+        if (node.content)
+            ownersOf(node.content, owners);
+    }
+    return owners;
+};
+export const layoutDocument = (document, options = {}) => {
+    if (!isObject(document))
+        throw new LayoutInputError(["document must be a JSON object"]);
+    const errors = [...new Set(validateWithSchema(document, schema()))];
+    if (errors.length > 0)
+        throw new LayoutInputError(errors);
+    const output = structuredClone(document);
+    const graph = Array.isArray(output["@graph"]) ? output["@graph"] : [];
+    if (!Array.isArray(output["@graph"])) {
+        const { "@context": context, ...root } = output;
+        output["@graph"] = graph;
+        for (const key of Object.keys(root))
+            delete output[key];
+        graph.push(root);
+        output["@context"] = context;
+    }
+    const used = collectIds(graph, new Set());
+    const unique = (preferred) => {
+        let id = preferred;
+        for (let n = 2; used.has(id); n++)
+            id = `${preferred}_${n}`;
+        used.add(id);
+        return id;
+    };
+    const processes = new Map();
+    for (const node of graph)
+        if (node.type === "Process" && typeof node.id === "string")
+            processes.set(node.id, node);
+    const claimed = new Set();
+    const participantsOf = (collaboration) => (Array.isArray(collaboration.participants) ? collaboration.participants : []).filter((item) => isObject(item) && typeof item.id === "string");
+    for (const root of graph)
+        if (root.type === "Collaboration")
+            for (const participant of participantsOf(root))
+                if (typeof participant.processRef === "string" && processes.has(participant.processRef))
+                    claimed.add(participant.processRef);
+    const tied = new Map();
+    for (const root of graph) {
+        if (root.type !== "Collaboration" || participantsOf(root).length === 0)
+            continue;
+        const endpoints = new Set();
+        for (const flow of Array.isArray(root.messageFlows) ? root.messageFlows : [])
+            if (isObject(flow))
+                for (const key of ["sourceRef", "targetRef"])
+                    if (typeof flow[key] === "string")
+                        endpoints.add(flow[key]);
+        const drawn = new Set(elementsOf(diagramsOf(graph, root.id)).map((element) => element.bpmnElement));
+        const related = [];
+        for (const [id, process] of processes) {
+            if (claimed.has(id))
+                continue;
+            const model = extractProcess(process);
+            const elements = [...allNodes(model), ...allFlows(model)];
+            if (!elements.some((element) => endpoints.has(element.id) || drawn.has(element.id)) || model.nodes.length === 0)
+                continue;
+            claimed.add(id);
+            related.push(process);
+        }
+        tied.set(root.id, related);
+    }
+    const layoutCollaborationRoot = (root) => {
+        const participantInputs = participantsOf(root);
+        if (participantInputs.length === 0)
+            return;
+        const diagrams = diagramsOf(graph, root.id);
+        const collapsed = collapsedShapes(diagrams);
+        const seen = new Set();
+        const participants = participantInputs.map((participant) => {
+            const process = typeof participant.processRef === "string" && !seen.has(participant.processRef) ? processes.get(participant.processRef) : undefined;
+            if (!process)
+                return { id: participant.id };
+            seen.add(process.id);
+            return { id: participant.id, model: extractProcess(process, collapsed), lanes: extractLanes(process) };
+        });
+        for (const process of tied.get(root.id) ?? [])
+            participants.push({ id: process.id, model: extractProcess(process, collapsed), lanes: extractLanes(process), unframed: true });
+        const messageFlows = (Array.isArray(root.messageFlows) ? root.messageFlows : [])
+            .filter((flow) => isObject(flow) && typeof flow.id === "string" && typeof flow.sourceRef === "string" && typeof flow.targetRef === "string")
+            .map((flow) => ({ id: flow.id, source: flow.sourceRef, target: flow.targetRef }));
+        const build = (layout, shapeIds, shapeId, edgeId, skipShape, skipEdge) => {
+            const added = [];
+            for (const shape of layout.shapes) {
+                if (skipShape(shape.element))
+                    continue;
+                const id = shapeId(shape.element);
+                shapeIds.set(shape.element, id);
+                added.push(shape.kind === "node" ? shapeElement(id, shape.node, shape.box) : containerElement(id, shape.element, shape.box));
+            }
+            for (const edge of layout.edges)
+                if (!skipEdge(edge.element))
+                    added.push(edgeElement(edgeId(edge.element), edge.element, edge.source && shapeIds.get(edge.source), edge.target && shapeIds.get(edge.target), edge.route));
+            return added;
+        };
+        if (diagrams.length === 0 || options.force) {
+            const previous = diagrams.length > 0 ? previousIds(diagrams) : undefined;
+            if (previous)
+                collectIds(diagrams, new Set()).forEach((id) => used.delete(id));
+            const layout = layoutCollaboration(participants, messageFlows, { fixed: new Map(), obstacles: new Map() });
+            const shapeIds = new Map();
+            const planeElements = build(layout, shapeIds, (element) => unique(previous?.shapes.get(element) ?? `Shape_${element}`), (element) => unique(previous?.edges.get(element) ?? `Edge_${element}`), () => false, () => false);
+            for (const element of planeElements) {
+                const kind = element.type === "BPMNEdge" ? previous?.messageVisibleKinds.get(element.bpmnElement) : undefined;
+                if (kind !== undefined)
+                    element.messageVisibleKind = kind;
+            }
+            const replacement = {
+                id: unique(previous?.diagram ?? `Diagram_${root.id}`),
+                type: "BPMNDiagram",
+                ...diagramProperties(previous),
+                plane: { id: unique(previous?.plane ?? `Plane_${root.id}`), type: "BPMNPlane", bpmnElement: root.id, planeElements },
+            };
+            if (diagrams.length === 0)
+                graph.push(replacement);
+            else {
+                const position = graph.indexOf(diagrams[0]);
+                for (const diagram of diagrams.slice(1))
+                    graph.splice(graph.indexOf(diagram), 1);
+                graph.splice(position, 1, replacement);
+            }
+            return;
+        }
+        const elements = elementsOf(diagrams);
+        const shapeIds = new Map();
+        const fixed = new Map();
+        const drawnEdges = new Set();
+        for (const element of elements) {
+            if (typeof element.bpmnElement !== "string")
+                continue;
+            if (element.type === "BPMNShape" && isBox(element.bounds) && !shapeIds.has(element.bpmnElement)) {
+                shapeIds.set(element.bpmnElement, element.id);
+                fixed.set(element.bpmnElement, element.bounds);
+            }
+            else if (element.type === "BPMNEdge")
+                drawnEdges.add(element.bpmnElement);
+        }
+        const models = participants.flatMap((participant) => (participant.model ? [participant.model] : []));
+        const missingFlows = new Set(models.flatMap((model) => allFlows(model)).filter((flow) => !drawnEdges.has(flow.id)).map((flow) => flow.id));
+        const owners = new Map();
+        for (const model of models)
+            ownersOf(model, owners);
+        const obstacles = new Map();
+        for (const element of elements) {
+            if (element.type !== "BPMNShape" || !isBox(element.bounds) || !owners.has(element.bpmnElement))
+                continue;
+            const owner = owners.get(element.bpmnElement);
+            obstacles.set(owner, [...(obstacles.get(owner) ?? []), element.bounds]);
+        }
+        const layout = layoutCollaboration(participants, messageFlows, { fixed, obstacles, missingFlows });
+        const skipShape = (element) => fixed.has(element);
+        const skipEdge = (element) => drawnEdges.has(element);
+        if (layout.shapes.every((shape) => skipShape(shape.element)) && layout.edges.every((edge) => skipEdge(edge.element)))
+            return;
+        const added = build(layout, shapeIds, (element) => unique(`Shape_${element}`), (element) => unique(`Edge_${element}`), skipShape, skipEdge);
+        const plane = diagrams[0].plane;
+        plane.planeElements = [...(Array.isArray(plane.planeElements) ? plane.planeElements : []), ...added];
+    };
+    for (const root of [...graph]) {
+        if (root.type === "Collaboration" && typeof root.id === "string") {
+            layoutCollaborationRoot(root);
+            continue;
+        }
+        if (root.type !== "Process" || claimed.has(root.id) || typeof root.id !== "string")
+            continue;
+        const diagrams = diagramsOf(graph, root.id);
+        const model = extractProcess(root, collapsedShapes(diagrams));
+        if (model.nodes.length === 0)
+            continue;
+        const laneNodes = extractLanes(root);
+        if (diagrams.length === 0) {
+            graph.push(buildDiagram(model, placeStandalone(model, laneNodes), unique));
+            continue;
+        }
+        if (options.force) {
+            const previous = previousIds(diagrams);
+            collectIds(diagrams, new Set()).forEach((id) => used.delete(id));
+            const position = graph.indexOf(diagrams[0]);
+            const replacement = buildDiagram(model, placeStandalone(model, laneNodes), unique, previous);
+            for (const diagram of diagrams.slice(1))
+                graph.splice(graph.indexOf(diagram), 1);
+            graph.splice(position, 1, replacement);
+            continue;
+        }
+        const elements = elementsOf(diagrams);
+        const shapeIds = new Map();
+        const fixed = new Map();
+        const drawnFlows = new Set();
+        for (const element of elements) {
+            if (typeof element.bpmnElement !== "string")
+                continue;
+            if (element.type === "BPMNShape" && isBox(element.bounds) && !shapeIds.has(element.bpmnElement)) {
+                shapeIds.set(element.bpmnElement, element.id);
+                fixed.set(element.bpmnElement, element.bounds);
+            }
+            else if (element.type === "BPMNEdge")
+                drawnFlows.add(element.bpmnElement);
+        }
+        const nodes = allNodes(model);
+        const missingNodes = nodes.filter((node) => !fixed.has(node.id));
+        const missingFlows = allFlows(model).filter((flow) => !drawnFlows.has(flow.id));
+        const laneIds = new Set([...flattenLanes(laneNodes ?? []).map((lane) => lane.id), ...nestedLaneIds(model)]);
+        const missingLanes = [...laneIds].filter((id) => !fixed.has(id));
+        if (missingNodes.length === 0 && missingFlows.length === 0 && missingLanes.length === 0)
+            continue;
+        const owners = ownersOf(model);
+        const obstacles = new Map();
+        for (const element of elements) {
+            if (element.type !== "BPMNShape" || !isBox(element.bounds) || laneIds.has(element.bpmnElement))
+                continue;
+            const owner = owners.get(element.bpmnElement) ?? model.id;
+            obstacles.set(owner, [...(obstacles.get(owner) ?? []), element.bounds]);
+        }
+        const placed = placeStandalone(model, laneNodes, { fixed, obstacles, missingFlows: new Set(missingFlows.map((flow) => flow.id)) });
+        const added = [];
+        for (const lane of missingLanes) {
+            const id = unique(`Shape_${lane}`);
+            shapeIds.set(lane, id);
+            added.push(containerElement(id, lane, placed.lanes.get(lane)));
+        }
+        for (const node of missingNodes) {
+            const id = unique(`Shape_${node.id}`);
+            shapeIds.set(node.id, id);
+            added.push(shapeElement(id, node, placed.boxes.get(node.id)));
+        }
+        for (const flow of missingFlows) {
+            const route = placed.routes.get(flow.id);
+            if (route)
+                added.push(edgeElement(unique(`Edge_${flow.id}`), flow.id, flow.source && shapeIds.get(flow.source), flow.target && shapeIds.get(flow.target), route));
+        }
+        const plane = diagrams[0].plane;
+        plane.planeElements = [...(Array.isArray(plane.planeElements) ? plane.planeElements : []), ...added];
+    }
+    return { document: output };
+};

package/dist/layout/model.d.ts

@@ -0,0 +1,52 @@
+import type { Layering } from "./layering.ts";
+export type Json = Record<string, any>;
+export interface Size {
+    width: number;
+    height: number;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Box extends Point, Size {
+}
+export interface LaneHooks {
+    ids: string[];
+    indent: number;
+    arrange: (layering: Layering, layered: Map<string, Box>, origin: Point) => void;
+    boxes: (frame: Box, boxes: Map<string, Box>, anchored: boolean) => Map<string, Box>;
+}
+export interface FlowNode {
+    id: string;
+    type: string;
+    size: Size;
+    attachedTo?: string;
+    collapsed?: boolean;
+    content?: ProcessModel;
+}
+export interface Flow {
+    id: string;
+    source: string;
+    target: string;
+}
+export interface Edge {
+    id: string;
+    source?: string;
+    target?: string;
+}
+export interface ProcessModel {
+    id: string;
+    nodes: FlowNode[];
+    flows: Flow[];
+    data: FlowNode[];
+    stubs: Edge[];
+    associations: Flow[];
+    lanes?: LaneHooks;
+}
+export interface Placement {
+    boxes: Map<string, Box>;
+    routes: Map<string, Point[]>;
+    lanes?: Map<string, Box>;
+}
+export declare const allNodes: (model: ProcessModel) => FlowNode[];
+export declare const allFlows: (model: ProcessModel) => Edge[];

package/dist/layout/model.js

@@ -0,0 +1,10 @@
+export const allNodes = (model) => [
+    ...model.nodes.flatMap((node) => [node, ...(node.content ? allNodes(node.content) : [])]),
+    ...model.data,
+];
+export const allFlows = (model) => [
+    ...model.flows,
+    ...model.stubs,
+    ...model.associations,
+    ...model.nodes.flatMap((node) => (node.content ? allFlows(node.content) : [])),
+];

package/dist/layout/placement.d.ts

@@ -0,0 +1,25 @@
+import { type Layering } from "./layering.ts";
+import type { Box, Flow, FlowNode, Point, ProcessModel } from "./model.ts";
+export declare const ORIGIN: Point;
+export declare const ROW_GAP = 40;
+export declare const reserveBelow: (model: ProcessModel, hostId: string) => number;
+export declare const boundaryBox: (model: ProcessModel, node: FlowNode, host: Box) => Box;
+export declare const placeNodes: (model: ProcessModel, layering: Layering, origin?: Point) => Map<string, Box>;
+export declare const routeFlows: (model: ProcessModel, flows: Flow[], layering: Layering, boxes: Map<string, Box>) => Map<string, Point[]>;
+export declare const placeData: (model: ProcessModel, boxes: Map<string, Box>, routes: Map<string, Point[]>, fixed?: Map<string, Box>) => Map<string, Box>;
+export declare const routeExtras: (model: ProcessModel, boxes: Map<string, Box>, only?: Set<string>) => Map<string, Point[]>;
+export declare const measure: (model: ProcessModel) => void;
+export interface ScopeContext {
+    fixed: Map<string, Box>;
+    obstacles: Map<string, Box[]>;
+    missingFlows?: Set<string>;
+    boxes: Map<string, Box>;
+    routes: Map<string, Point[]>;
+    arrange?: (model: ProcessModel, layering: Layering, layered: Map<string, Box>, origin: Point) => void;
+    lanes?: Map<string, Box>;
+}
+export declare const placeScope: (model: ProcessModel, origin: Point, context: ScopeContext) => void;
+export declare const place: (model: ProcessModel) => {
+    boxes: Map<string, Box>;
+    routes: Map<string, Point[]>;
+};

package/dist/layout/placement.js

@@ -0,0 +1,256 @@
+import { assignLayers } from "./layering.js";
+export const ORIGIN = { x: 100, y: 100 };
+const LAYER_GAP = 60;
+export const ROW_GAP = 40;
+const LOOP_CLEARANCE = 30;
+const CONTAINER_MARGIN = 30;
+const BOUNDARY_SIZE = 36;
+const BOUNDARY_PITCH = 44;
+const ACTIVITY_SIZE = { width: 100, height: 80 };
+const DATA_GAP = 40;
+const DATA_SPACING = 20;
+const STUB_LENGTH = 40;
+const boundariesOf = (model, hostId) => model.nodes.filter((node) => node.attachedTo === hostId);
+export const reserveBelow = (model, hostId) => {
+    const count = boundariesOf(model, hostId).length;
+    return count === 0 ? 0 : BOUNDARY_SIZE / 2 + 10 + 8 * count;
+};
+export const boundaryBox = (model, node, host) => {
+    const siblings = boundariesOf(model, node.attachedTo);
+    const span = siblings.length * BOUNDARY_PITCH - (BOUNDARY_PITCH - BOUNDARY_SIZE);
+    return {
+        x: host.x + Math.round((host.width - span) / 2) + siblings.indexOf(node) * BOUNDARY_PITCH,
+        y: host.y + host.height - BOUNDARY_SIZE / 2,
+        width: BOUNDARY_SIZE,
+        height: BOUNDARY_SIZE,
+    };
+};
+export const placeNodes = (model, layering, origin = ORIGIN) => {
+    const sizes = new Map(model.nodes.map((node) => [node.id, node.size]));
+    const slot = (id) => sizes.get(id).height + reserveBelow(model, id);
+    const columnWidths = layering.layers.map((layer) => Math.max(0, ...layer.map((id) => sizes.get(id).width)));
+    const columnHeights = layering.layers.map((layer) => layer.reduce((sum, id) => sum + slot(id), 0) + ROW_GAP * Math.max(0, layer.length - 1));
+    const tallest = Math.max(0, ...columnHeights);
+    const boxes = new Map();
+    let x = origin.x;
+    layering.layers.forEach((layer, index) => {
+        let y = origin.y + (tallest - columnHeights[index]) / 2;
+        for (const id of layer) {
+            const { width, height } = sizes.get(id);
+            boxes.set(id, { x: x + (columnWidths[index] - width) / 2, y, width, height });
+            y += slot(id) + ROW_GAP;
+        }
+        x += columnWidths[index] + LAYER_GAP;
+    });
+    for (const node of model.nodes)
+        if (node.attachedTo)
+            boxes.set(node.id, boundaryBox(model, node, boxes.get(node.attachedTo)));
+    return boxes;
+};
+const centerY = (box) => box.y + box.height / 2;
+const centerX = (box) => box.x + box.width / 2;
+const dedupe = (points) => points.filter((point, index) => index === 0 || point.x !== points[index - 1].x || point.y !== points[index - 1].y);
+const routeForward = (source, target) => {
+    const start = { x: source.x + source.width, y: centerY(source) };
+    const end = { x: target.x, y: centerY(target) };
+    if (start.y === end.y)
+        return [start, end];
+    const middle = Math.round((start.x + end.x) / 2);
+    return [start, { x: middle, y: start.y }, { x: middle, y: end.y }, end];
+};
+const routeBack = (source, target, floor) => {
+    const lane = floor + LOOP_CLEARANCE;
+    const start = { x: centerX(source), y: source.y + source.height };
+    const end = { x: centerX(target), y: target.y + target.height };
+    return [start, { x: start.x, y: lane }, { x: end.x, y: lane }, end];
+};
+const routeBoundary = (model, event, source, host, target) => {
+    const siblings = boundariesOf(model, event.attachedTo);
+    const index = siblings.indexOf(event);
+    const start = { x: centerX(source), y: source.y + source.height };
+    const lane = start.y + 8 + 8 * (siblings.length - 1 - index);
+    const end = { x: target.x, y: centerY(target) };
+    const middle = Math.round((host.x + host.width + target.x) / 2) + 6 * index;
+    return dedupe([start, { x: start.x, y: lane }, { x: middle, y: lane }, { x: middle, y: end.y }, end]);
+};
+export const routeFlows = (model, flows, layering, boxes) => {
+    const floor = Math.max(0, ...[...boxes.values()].map((box) => box.y + box.height));
+    const routes = new Map();
+    const nodes = new Map(model.nodes.map((node) => [node.id, node]));
+    for (const flow of flows) {
+        const source = boxes.get(flow.source);
+        const target = boxes.get(flow.target);
+        const back = layering.backFlows.has(flow.id) || layering.layerOf.get(flow.target) <= layering.layerOf.get(flow.source);
+        const event = nodes.get(flow.source);
+        if (back)
+            routes.set(flow.id, routeBack(source, target, floor));
+        else if (event.attachedTo)
+            routes.set(flow.id, routeBoundary(model, event, source, boxes.get(event.attachedTo), target));
+        else
+            routes.set(flow.id, routeForward(source, target));
+    }
+    return routes;
+};
+export const placeData = (model, boxes, routes, fixed = new Map()) => {
+    const placed = new Map();
+    const open = model.data.filter((item) => !fixed.has(item.id));
+    if (open.length === 0)
+        return placed;
+    const scope = model.nodes.map((node) => boxes.get(node.id)).filter((box) => box !== undefined);
+    const left = Math.min(...scope.map((box) => box.x));
+    const top = Math.max(...scope.map((box) => box.y + box.height), ...[...routes.values()].flat().map((point) => point.y)) + DATA_GAP;
+    const wanted = open.map((item) => {
+        const link = model.associations.find((association) => association.source === item.id || association.target === item.id);
+        const other = link ? boxes.get(link.source === item.id ? link.target : link.source) : undefined;
+        return { item, x: other ? other.x + other.width / 2 - item.size.width / 2 : left };
+    });
+    wanted.sort((a, b) => a.x - b.x);
+    let cursor = -Infinity;
+    for (const { item, x } of wanted) {
+        const at = Math.max(x, cursor);
+        placed.set(item.id, { x: at, y: top, width: item.size.width, height: item.size.height });
+        cursor = at + item.size.width + DATA_SPACING;
+    }
+    return placed;
+};
+const routeAssociation = (node, data) => {
+    const nx = node.x + node.width / 2;
+    const dx = data.x + data.width / 2;
+    if (data.y >= node.y + node.height) {
+        const start = { x: nx, y: node.y + node.height };
+        const end = { x: dx, y: data.y };
+        if (nx === dx)
+            return [start, end];
+        const middle = Math.round((start.y + end.y) / 2);
+        return [start, { x: nx, y: middle }, { x: dx, y: middle }, end];
+    }
+    if (data.y + data.height <= node.y) {
+        const start = { x: nx, y: node.y };
+        const end = { x: dx, y: data.y + data.height };
+        if (nx === dx)
+            return [start, end];
+        const middle = Math.round((start.y + end.y) / 2);
+        return [start, { x: nx, y: middle }, { x: dx, y: middle }, end];
+    }
+    return [{ x: nx, y: node.y + node.height / 2 }, { x: dx, y: data.y + data.height / 2 }];
+};
+export const routeExtras = (model, boxes, only) => {
+    const routes = new Map();
+    const dataIds = new Set(model.data.map((item) => item.id));
+    for (const stub of model.stubs) {
+        if (only && !only.has(stub.id))
+            continue;
+        const source = stub.source ? boxes.get(stub.source) : undefined;
+        const target = stub.target ? boxes.get(stub.target) : undefined;
+        if (source) {
+            const y = centerY(source);
+            routes.set(stub.id, [{ x: source.x + source.width, y }, { x: source.x + source.width + STUB_LENGTH, y }]);
+        }
+        else if (target) {
+            const y = centerY(target);
+            routes.set(stub.id, [{ x: target.x - STUB_LENGTH, y }, { x: target.x, y }]);
+        }
+    }
+    for (const association of model.associations) {
+        if (only && !only.has(association.id))
+            continue;
+        const source = boxes.get(association.source);
+        const target = boxes.get(association.target);
+        if (!source || !target)
+            continue;
+        const route = dataIds.has(association.source) ? routeAssociation(target, source).reverse() : routeAssociation(source, target);
+        routes.set(association.id, route);
+    }
+    return routes;
+};
+export const measure = (model) => {
+    for (const node of model.nodes) {
+        if (node.content) {
+            measure(node.content);
+            const layering = assignLayers(node.content);
+            const origin = { x: node.content.lanes?.indent ?? 0, y: 0 };
+            const boxes = placeNodes(node.content, layering, origin);
+            node.content.lanes?.arrange(layering, boxes, origin);
+            const routes = routeFlows(node.content, node.content.flows, layering, boxes);
+            for (const [id, box] of placeData(node.content, boxes, routes))
+                boxes.set(id, box);
+            for (const [id, route] of routeExtras(node.content, boxes))
+                routes.set(id, route);
+            const points = [...routes.values()].flat();
+            const right = Math.max(0, ...[...boxes.values()].map((box) => box.x + box.width), ...points.map((point) => point.x));
+            const bottom = Math.max(0, ...[...boxes.values()].map((box) => box.y + box.height), ...points.map((point) => point.y));
+            node.size = {
+                width: Math.max(ACTIVITY_SIZE.width, right + 2 * CONTAINER_MARGIN),
+                height: Math.max(ACTIVITY_SIZE.height, bottom + 2 * CONTAINER_MARGIN),
+            };
+        }
+        node.size = { ...node.size, width: Math.max(node.size.width, boundariesOf(model, node.id).length * BOUNDARY_PITCH) };
+    }
+};
+const intersects = (a, b) => a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+export const placeScope = (model, origin, context) => {
+    const layering = assignLayers(model);
+    const layered = placeNodes(model, layering, origin);
+    context.arrange?.(model, layering, layered, origin);
+    model.lanes?.arrange(layering, layered, origin);
+    const anchor = model.nodes.find((node) => !node.attachedTo && context.fixed.has(node.id));
+    const dx = anchor ? context.fixed.get(anchor.id).x - layered.get(anchor.id).x : 0;
+    const dy = anchor ? context.fixed.get(anchor.id).y - layered.get(anchor.id).y : 0;
+    const taken = [...(context.obstacles.get(model.id) ?? [])];
+    const boxes = new Map();
+    for (const node of model.nodes) {
+        if (node.attachedTo)
+            continue;
+        const existing = context.fixed.get(node.id);
+        if (existing) {
+            boxes.set(node.id, existing);
+            continue;
+        }
+        const base = layered.get(node.id);
+        const box = { ...base, x: base.x + dx, y: base.y + dy };
+        for (let hit = taken.filter((other) => intersects(box, other)); hit.length > 0; hit = taken.filter((other) => intersects(box, other)))
+            box.y = Math.max(...hit.map((other) => other.y + other.height)) + ROW_GAP;
+        taken.push(box);
+        boxes.set(node.id, box);
+    }
+    for (const node of model.nodes)
+        if (node.attachedTo)
+            boxes.set(node.id, context.fixed.get(node.id) ?? boundaryBox(model, node, boxes.get(node.attachedTo)));
+    const flows = context.missingFlows ? model.flows.filter((flow) => context.missingFlows.has(flow.id)) : model.flows;
+    const routed = routeFlows(model, flows, layering, boxes);
+    for (const [id, route] of routed)
+        context.routes.set(id, route);
+    const scopeRoutes = new Map(routed);
+    for (const [id, box] of placeData(model, boxes, scopeRoutes, context.fixed)) {
+        const placed = { ...box };
+        for (let hit = taken.filter((other) => intersects(placed, other)); hit.length > 0; hit = taken.filter((other) => intersects(placed, other)))
+            placed.y = Math.max(...hit.map((other) => other.y + other.height)) + ROW_GAP;
+        taken.push(placed);
+        boxes.set(id, placed);
+    }
+    for (const item of model.data)
+        if (context.fixed.has(item.id))
+            boxes.set(item.id, context.fixed.get(item.id));
+    for (const [id, route] of routeExtras(model, boxes, context.missingFlows))
+        context.routes.set(id, route);
+    for (const [id, box] of boxes)
+        context.boxes.set(id, box);
+    for (const node of model.nodes) {
+        if (!node.content)
+            continue;
+        const frame = boxes.get(node.id);
+        placeScope(node.content, { x: frame.x + CONTAINER_MARGIN + (node.content.lanes?.indent ?? 0), y: frame.y + CONTAINER_MARGIN }, context);
+        if (node.content.lanes && context.lanes) {
+            const inner = { x: frame.x + CONTAINER_MARGIN, y: frame.y + CONTAINER_MARGIN, width: frame.width - 2 * CONTAINER_MARGIN, height: frame.height - 2 * CONTAINER_MARGIN };
+            const anchored = node.content.nodes.some((child) => context.fixed.has(child.id));
+            for (const [id, box] of node.content.lanes.boxes(inner, context.boxes, anchored))
+                context.lanes.set(id, box);
+        }
+    }
+};
+export const place = (model) => {
+    measure(model);
+    const context = { fixed: new Map(), obstacles: new Map(), boxes: new Map(), routes: new Map() };
+    placeScope(model, ORIGIN, context);
+    return context;
+};

package/dist/layout/standalone.d.ts

@@ -0,0 +1,8 @@
+import { type LaneNode } from "./lanes.ts";
+import { type Box, type Placement, type ProcessModel } from "./model.ts";
+export interface StandaloneExisting {
+    fixed: Map<string, Box>;
+    obstacles: Map<string, Box[]>;
+    missingFlows?: Set<string>;
+}
+export declare const placeStandalone: (model: ProcessModel, lanes: LaneNode[] | undefined, existing?: StandaloneExisting) => Required<Placement>;