@likec4/diagram 1.59.4 → 1.61.0

package/dist/likec4diagram/state/machine.actions.mjs

@@ -0,0 +1,837 @@
+import { __name } from "../../_virtual/_rolldown/runtime.mjs";
+import { Base } from "../../base/Base.mjs";
+import { detailsSubject } from "../../overlays/element-details/subject.mjs";
+import { viewRouting } from "../../utils/view-routing.mjs";
+import { convertToXYFlow } from "../convert-to-xyflow.mjs";
+import { createLayoutConstraints } from "../useLayoutConstraints.mjs";
+import { getAligner, toNodeRect } from "./aligners.mjs";
+import { focusNodesEdges, mergeXYNodesEdges, resetEdgeControlPoints } from "./assign.mjs";
+import { assignViewportBefore, cancelFitDiagram, centerOnNodeOrEdge, fitDiagram, fitFocusedBounds, raiseFitDiagram, raiseSetViewport, raiseUpdateView, returnViewportBefore, setViewport, setViewportCenter } from "./machine.actions.layout.mjs";
+import { machine } from "./machine.setup.mjs";
+import { findDiagramEdge, findDiagramNode, typedSystem, viewBounds } from "./utils.mjs";
+import { hasAtLeast, isTruthy, mapToObj, omit } from "remeda";
+import { dynamicViewFlow, exact, invariant, isDynamicView, nonNullable, nonexhaustive } from "@likec4/core";
+import { nodeToRect } from "@xyflow/system";
+import { BBox as BBox$1 } from "@likec4/core/geometry";
+import { difference as difference$1, isString as isString$1 } from "@likec4/core/utils";
+import { getViewFolderPath } from "@likec4/core/model";
+import { assertEvent } from "xstate";
+import { produce } from "immer";
+
+// src/likec4diagram/state/machine.actions.ts
+const resetSelection = () => machine.raise({ type: "xyflow.resetSelection" });
+/**
+* Resolves the layout type requested by `emit.onLayoutTypeChange`,
+* or toggles the current one, if the action is triggered by another event.
+*/
+const resolveNextLayoutType = (context, event) => {
+	if (event.type === "emit.onLayoutTypeChange") return event.layoutType;
+	return context.view._layout === "auto" ? "manual" : "auto";
+};
+/**
+* Comparing layouts: before switching the layout type,
+* remembers the viewport of the current layout (to restore it when switching back)
+* and cancels pending editor changes when switching from manual to auto.
+*/
+const beforeLayoutTypeChangeWhileComparing = () => machine.enqueueActions(({ context, event, enqueue }) => {
+	const currentLayoutType = context.view._layout;
+	const nextLayoutType = resolveNextLayoutType(context, event);
+	if (!currentLayoutType || currentLayoutType === nextLayoutType) return;
+	if (currentLayoutType === "manual") {
+		enqueue.sendTo(typedSystem.editorActor, { type: "cancel" });
+		enqueue.assign({ viewportOnManualLayout: context.viewport });
+		return;
+	}
+	enqueue.assign({ viewportOnAutoLayout: context.viewport });
+});
+/**
+* Comparing layouts: on exit, switches back to manual layout (if auto is active)
+* and forgets the remembered viewports.
+*/
+const exitComparingLayouts = () => machine.enqueueActions(({ context, enqueue }) => {
+	if (context.view._layout === "auto") enqueue.emit({
+		type: "onLayoutTypeChange",
+		layoutType: "manual"
+	});
+	enqueue.assign({
+		viewportOnAutoLayout: null,
+		viewportOnManualLayout: null
+	});
+});
+const onEdgeDoubleClick = () => machine.assign(({ context, event }) => {
+	assertEvent(event, "xyflow.edgeDoubleClick");
+	if (!event.edge.data.controlPoints) return {};
+	const { nodeLookup } = context.xystore.getState();
+	return { xyedges: context.xyedges.map((e) => {
+		if (e.id !== event.edge.id) return e;
+		const controlPoints = resetEdgeControlPoints(nodeLookup, e);
+		const pt = controlPoints[0];
+		return {
+			...e,
+			data: {
+				...e.data,
+				controlPoints,
+				labelBBox: e.data.labelBBox ? {
+					...e.data.labelBBox,
+					...pt
+				} : null,
+				labelXY: null
+			}
+		};
+	}) };
+});
+const assignLastClickedNode = () => machine.assign(({ context, event }) => {
+	assertEvent(event, "xyflow.nodeClick");
+	const { lastClickedNode } = context;
+	if (!lastClickedNode || lastClickedNode.id !== event.node.id) return { lastClickedNode: {
+		id: event.node.id,
+		clicks: 1,
+		timestamp: Date.now()
+	} };
+	return { lastClickedNode: {
+		id: lastClickedNode.id,
+		clicks: lastClickedNode.clicks + 1,
+		timestamp: Date.now()
+	} };
+});
+const assignFocusedNode = () => machine.assign(({ event }) => {
+	let focusedNode;
+	let autoUnfocusTimer = false;
+	switch (event.type) {
+		case "xyflow.nodeClick":
+			focusedNode = event.node.data.id;
+			break;
+		case "focus.node":
+			focusedNode = event.nodeId;
+			autoUnfocusTimer = event.autoUnfocus === true;
+			break;
+		default: throw new Error(`Unexpected event type: ${event.type} in action 'assign: focusedNode'`);
+	}
+	return {
+		focusedNode,
+		autoUnfocusTimer
+	};
+});
+const resetLastClickedNode = () => machine.assign(() => ({ lastClickedNode: null }));
+const updateFeatures = () => machine.assign(({ context, event }) => {
+	assertEvent(event, "update.features");
+	return { features: {
+		...context.features,
+		...event.features
+	} };
+});
+const updateInputs = () => machine.assign(({ event }) => {
+	assertEvent(event, "update.inputs");
+	return exact({ ...event.inputs });
+});
+const assignXYDataFromView = (view) => machine.assign(({ context, event }) => {
+	let xydata;
+	if (view) xydata = convertToXYFlow({
+		currentViewId: context.view.id,
+		dynamicViewVariant: context.dynamicViewVariant,
+		elementViewVariant: context.elementViewVariant,
+		view,
+		where: context.where,
+		collapsedSequenceFlows: context.collapsedSequenceFlows
+	});
+	else {
+		assertEvent(event, "update.view");
+		xydata = "xynodes" in event ? event : convertToXYFlow({
+			currentViewId: context.view.id,
+			dynamicViewVariant: context.dynamicViewVariant,
+			elementViewVariant: context.elementViewVariant,
+			view: event.view,
+			where: context.where,
+			collapsedSequenceFlows: context.collapsedSequenceFlows
+		});
+	}
+	const update = mergeXYNodesEdges(context, xydata);
+	let { lastClickedNode, focusedNode, activeWalkthrough } = context;
+	if (lastClickedNode || focusedNode || activeWalkthrough) {
+		const nodeIds = new Set(update.xynodes.map((n) => n.id));
+		if (lastClickedNode && !nodeIds.has(lastClickedNode.id)) lastClickedNode = null;
+		if (focusedNode && !nodeIds.has(focusedNode)) focusedNode = null;
+		const stepId = activeWalkthrough?.stepId;
+		if (stepId && !update.xyedges.some((e) => e.id === stepId)) activeWalkthrough = null;
+		return {
+			...update,
+			lastClickedNode,
+			focusedNode,
+			activeWalkthrough
+		};
+	}
+	return update;
+});
+const focusOnNodesAndEdges = () => machine.enqueueActions(({ context, enqueue }) => {
+	const next = focusNodesEdges(context);
+	if (next) enqueue.assign(next);
+	else enqueue.raise({ type: "key.esc" });
+});
+const undimEverything = () => machine.assign(({ context }) => ({
+	xynodes: context.xynodes.map(Base.setDimmed(false)),
+	xyedges: context.xyedges.map(Base.setData({
+		dimmed: false,
+		active: false
+	}))
+}));
+const assignDynamicViewVariant = () => machine.assign(({ event }) => {
+	assertEvent(event, "switch.dynamicViewVariant");
+	return { dynamicViewVariant: event.variant };
+});
+const assignElementViewVariant = () => machine.assign(({ event }) => {
+	assertEvent(event, "switch.elementViewVariant");
+	return { elementViewVariant: event.variant };
+});
+const onNodeMouseEnter = () => machine.assign(({ context, event }) => {
+	assertEvent(event, "xyflow.nodeMouseEnter");
+	const hoveredNodeId = isString$1(event.node) ? event.node : event.node.id;
+	return { xynodes: context.xynodes.map((n) => {
+		if (n.id === hoveredNodeId) return Base.setHovered(n, true);
+		return n;
+	}) };
+});
+const onNodeMouseLeave = () => machine.assign(({ context, event }) => {
+	assertEvent(event, "xyflow.nodeMouseLeave");
+	const leftNodeId = isString$1(event.node) ? event.node : event.node.id;
+	return { xynodes: context.xynodes.map((n) => {
+		if (n.id === leftNodeId) return Base.setHovered(n, false);
+		return n;
+	}) };
+});
+const emitPaneClick = () => machine.emit(() => ({ type: "paneClick" }));
+const emitOpenSource = (params) => machine.emit(({ event }) => {
+	if (params) return {
+		type: "openSource",
+		params
+	};
+	assertEvent(event, "open.source");
+	return {
+		type: "openSource",
+		params: omit(event, ["type"])
+	};
+});
+const emitOpenSourceOfView = () => machine.emit(({ context }) => ({
+	type: "openSource",
+	params: { view: context.view.id }
+}));
+const emitInitialized = () => machine.emit(({ context }) => {
+	invariant(context.xyflow, "XYFlow instance not found");
+	return {
+		type: "initialized",
+		instance: context.xyflow
+	};
+});
+const emitNodeClick = () => machine.enqueueActions(({ context, event, enqueue }) => {
+	assertEvent(event, "xyflow.nodeClick");
+	const node = findDiagramNode(context, event.node.id);
+	if (!node) return;
+	enqueue.emit({
+		type: "nodeClick",
+		node,
+		xynode: event.node
+	});
+});
+const emitNavigateTo = (params) => machine.emit(({ context }) => ({
+	type: "navigateTo",
+	viewId: params?.viewId ?? nonNullable(context.lastOnNavigate, "Invalid state, lastOnNavigate is null").toView
+}));
+const emitEdgeClick = () => machine.emit(({ context, event }) => {
+	assertEvent(event, "xyflow.edgeClick");
+	return {
+		type: "edgeClick",
+		edge: nonNullable(findDiagramEdge(context, event.edge.id), `Edge ${event.edge.id} not found in diagram`),
+		xyedge: event.edge
+	};
+});
+const triggerChange = (viewChange) => machine.enqueueActions(({ event, enqueue }) => {
+	let change;
+	if (viewChange) change = { ...viewChange };
+	else {
+		assertEvent(event, "trigger.change");
+		change = event.change;
+	}
+	enqueue.assign({ viewportChangedManually: true });
+	enqueue.sendTo(typedSystem.editorActor, {
+		type: "change.view",
+		change
+	});
+});
+const emitOnLayoutTypeChange = () => machine.enqueueActions(({ event, context, enqueue }) => {
+	if (!context.features.enableCompareWithLatest) {
+		console.warn("Layout type cannot be changed while CompareWithLatest feature is disabled");
+		return;
+	}
+	const currentLayoutType = context.view._layout;
+	const nextLayoutType = resolveNextLayoutType(context, event);
+	if (currentLayoutType === nextLayoutType) {
+		console.warn("Ignoring layout type change event, layout type is already", currentLayoutType);
+		return;
+	}
+	enqueue.emit({
+		type: "onLayoutTypeChange",
+		layoutType: nextLayoutType
+	});
+});
+const layoutAlign = (params) => machine.createAction(({ context, event }) => {
+	let mode;
+	if (params) mode = params.mode;
+	else {
+		assertEvent(event, "layout.align");
+		mode = event.mode;
+	}
+	const xystore = nonNullable(context.xystore, "xystore is not initialized");
+	const { nodeLookup, parentLookup } = xystore.getState();
+	const selectedNodes = new Set(nodeLookup.values().filter((n) => n.selected).map((n) => n.id));
+	const nodesToAlign = [...difference$1(selectedNodes, new Set(parentLookup.keys()))];
+	if (!hasAtLeast(nodesToAlign, 2)) {
+		console.warn("At least 2 nodes must be selected to align");
+		return;
+	}
+	const constraints = createLayoutConstraints(xystore, nodesToAlign, viewRouting(context.view));
+	const aligner = getAligner(mode);
+	const nodes = nodesToAlign.map((id) => ({
+		node: nonNullable(nodeLookup.get(id)),
+		rect: nonNullable(constraints.rects.get(id))
+	}));
+	aligner.computeLayout(nodes.map(({ node }) => toNodeRect(node)));
+	for (const { rect, node } of nodes) rect.positionAbsolute = {
+		...rect.positionAbsolute,
+		...aligner.applyPosition(toNodeRect(node))
+	};
+	constraints.updateXYFlow();
+});
+const resetEdgesControlPoints = () => machine.assign(({ context }) => {
+	const { nodeLookup } = context.xystore.getState();
+	return { xyedges: context.xyedges.map((edge) => {
+		if (!edge.data.controlPoints) return edge;
+		const controlPoints = resetEdgeControlPoints(nodeLookup, edge);
+		const pt = controlPoints[0];
+		return {
+			...edge,
+			data: {
+				...edge.data,
+				controlPoints,
+				labelBBox: edge.data.labelBBox ? {
+					...edge.data.labelBBox,
+					x: pt.x,
+					y: pt.y
+				} : null,
+				labelXY: edge.data.labelXY ? pt : null
+			}
+		};
+	}) };
+});
+const notationsHighlight = () => machine.assign(({ context, event }) => {
+	assertEvent(event, "notations.highlight");
+	const { notation, kind } = event;
+	const targetKinds = kind ? [kind] : notation.kinds;
+	const shouldHighlight = (node) => node.notation === notation.title && node.shape === notation.shape && node.color === notation.color && targetKinds.includes(node.kind);
+	return {
+		xynodes: context.xynodes.map((n) => {
+			const node = findDiagramNode(context, n.id);
+			const highlighted = node && shouldHighlight(node);
+			return Base.setDimmed(n, highlighted ? false : "immediate");
+		}),
+		xyedges: context.xyedges.map((edge) => {
+			return Base.setDimmed(edge, true);
+		})
+	};
+});
+const tagHighlight = () => machine.assign(({ context, event }) => {
+	assertEvent(event, "tag.highlight");
+	const tag = event.tag.startsWith("#") ? event.tag.slice(1) : event.tag;
+	return { xynodes: context.xynodes.map((n) => {
+		if (n.data.tags && n.data.tags.includes(tag)) return Base.setDimmed(n, false);
+		return Base.setDimmed(n, true);
+	}) };
+});
+const highlightNodeOrEdge = () => machine.assign(({ context, event }) => {
+	assertEvent(event, ["highlight.edge", "highlight.node"]);
+	switch (event.type) {
+		case "highlight.node": {
+			const nodeId = event.nodeId;
+			if (!context.xynodes.find((n) => n.id === nodeId)) {
+				console.warn(`Node with id ${nodeId} not found for highlighting`);
+				return {};
+			}
+			return {
+				xynodes: context.xynodes.map((n) => {
+					return Base.setDimmed(n, n.id === nodeId ? false : true);
+				}),
+				xyedges: context.xyedges.map(Base.setData({
+					dimmed: true,
+					active: false
+				}))
+			};
+		}
+		case "highlight.edge": {
+			const edgeId = event.edgeId;
+			let edge = context.xyedges.find((e) => e.id === edgeId);
+			if (!edge) {
+				console.warn(`Edge with id ${edgeId} not found for highlighting`);
+				return {};
+			}
+			return {
+				xynodes: context.xynodes.map((n) => {
+					return Base.setDimmed(n, edge.source !== n.id && edge.target !== n.id);
+				}),
+				xyedges: context.xyedges.map((e) => {
+					return Base.setData(e, {
+						dimmed: e.id !== edgeId,
+						active: e.id === edgeId
+					});
+				})
+			};
+		}
+		default: nonexhaustive(event);
+	}
+});
+const assignToggledFeatures = () => machine.assign(({ context, event }) => {
+	assertEvent(event, "toggle.feature");
+	const feature = `enable${event.feature}`;
+	const currentValue = context.toggledFeatures[feature] ?? context.features[feature];
+	const nextValue = event.forceValue ?? !currentValue;
+	return { toggledFeatures: {
+		...context.toggledFeatures,
+		[feature]: nextValue
+	} };
+});
+const closeAllOverlays = () => machine.sendTo(typedSystem.overlaysActor, { type: "close.all" });
+const stopEditorActor = () => machine.enqueueActions(({ enqueue, system }) => {
+	const actor = typedSystem(system).editorActorRef;
+	if (!actor) return;
+	enqueue.stopChild(actor);
+});
+/**
+* Ensure that the sync layout actor is running or stopped based on the read-only state
+*/
+const ensureEditorActor = () => machine.enqueueActions(({ enqueue, context, system, check }) => {
+	const hasEditor = check("enabled: Editor");
+	const editor = typedSystem(system).editorActorRef;
+	if (!hasEditor && editor) {
+		enqueue.stopChild(editor);
+		return;
+	}
+	if (hasEditor && !editor) enqueue.spawnChild("editor", {
+		id: "editor",
+		systemId: "editor",
+		input: { viewId: context.view.id },
+		syncSnapshot: true
+	});
+});
+const startEditing = (subject = "node") => machine.sendTo(typedSystem.editorActor, {
+	type: "edit.move.start",
+	subject
+});
+const sendSynced = () => {
+	if (import.meta.env.DEV) console.log("sendSynced");
+	return machine.sendTo(typedSystem.editorActor, { type: "view.synched" });
+};
+const stopEditing = (wasChanged = false) => machine.sendTo(typedSystem.editorActor, { type: wasChanged ? "edit.move.end" : "edit.move.cancel" });
+const cancelEditing = () => machine.sendTo(typedSystem.editorActor, { type: "cancel" });
+const openNodeDetails = () => machine.enqueueActions(({ context, event, enqueue }) => {
+	let initiatedFrom = null;
+	let fromNodeId;
+	let subject;
+	switch (true) {
+		case event.type === "xyflow.nodeClick": {
+			const clickedSubject = detailsSubject(event.node.data);
+			if (!clickedSubject) {
+				console.warn("No model or deployment reference in clicked node data");
+				return;
+			}
+			subject = clickedSubject;
+			fromNodeId = event.node.data.id;
+			break;
+		}
+		case event.type === "open.nodeDetails":
+			if (isString$1(event.target)) {
+				const node = context.xynodes.find((n) => n.id === event.target);
+				const nodeSubject = node ? detailsSubject(node.data) : null;
+				if (!nodeSubject) {
+					console.warn("No model or deployment reference for node", event.target);
+					return;
+				}
+				subject = nodeSubject;
+				fromNodeId = event.fromNode ?? event.target;
+			} else {
+				subject = event.target;
+				fromNodeId = event.fromNode ?? (subject.type === "deployment" ? context.view.nodes.find((n) => n.deploymentRef === subject.deployment)?.id : void 0);
+			}
+			break;
+		default: {
+			if (!context.lastClickedNode) {
+				console.warn("No last clicked node");
+				return;
+			}
+			fromNodeId = context.lastClickedNode.id;
+			const node = context.xynodes.find((n) => n.id === fromNodeId);
+			const clickedSubject = node ? detailsSubject(node.data) : null;
+			if (!clickedSubject) {
+				console.warn("No model or deployment reference in last clicked node");
+				return;
+			}
+			subject = clickedSubject;
+			break;
+		}
+	}
+	const internalNode = fromNodeId ? context.xystore.getState().nodeLookup.get(fromNodeId) : null;
+	if (fromNodeId && internalNode) {
+		const nodeRect = nodeToRect(internalNode);
+		const zoom = context.xyflow.getZoom();
+		const clientRect = {
+			...context.xyflow.flowToScreenPosition(nodeRect),
+			width: nodeRect.width * zoom,
+			height: nodeRect.height * zoom
+		};
+		initiatedFrom = {
+			node: fromNodeId,
+			clientRect
+		};
+	}
+	enqueue.sendTo(typedSystem.overlaysActor, {
+		type: "open.elementDetails",
+		subject,
+		currentView: context.view,
+		...initiatedFrom && { initiatedFrom }
+	});
+});
+const openOverlay = () => machine.enqueueActions(({ context, event, enqueue, check }) => {
+	assertEvent(event, [
+		"open.relationshipsBrowser",
+		"open.relationshipDetails",
+		"open.nodeDetails"
+	]);
+	if (!check("enabled: Overlays")) {
+		console.warn("Overlays feature is disabled");
+		return;
+	}
+	switch (event.type) {
+		case "open.nodeDetails":
+			check("enabled: ElementDetails") ? enqueue(openNodeDetails()) : console.warn("ElementDetails feature is disabled");
+			break;
+		case "open.relationshipsBrowser":
+			if (!context.features.enableRelationshipBrowser) {
+				console.warn("RelationshipBrowser feature is disabled");
+				return;
+			}
+			enqueue.sendTo(typedSystem.overlaysActor, {
+				type: "open.relationshipsBrowser",
+				subject: event.fqn,
+				viewId: context.view.id,
+				scope: event.scope ?? context.relationshipBrowserScope,
+				closeable: true,
+				enableChangeScope: true,
+				enableSelectSubject: true
+			});
+			break;
+		case "open.relationshipDetails":
+			if (!context.features.enableRelationshipDetails) {
+				console.warn("RelationshipDetails feature is disabled");
+				return;
+			}
+			enqueue.sendTo(typedSystem.overlaysActor, {
+				type: "open.relationshipDetails",
+				viewId: context.view.id,
+				...event.params
+			});
+			break;
+		default: nonexhaustive(event);
+	}
+});
+const openSourceOfFocusedOrLastClickedNode = () => machine.enqueueActions(({ context, enqueue }) => {
+	const nodeId = context.focusedNode ?? context.lastClickedNode?.id;
+	if (!nodeId || !context.features.enableVscode) return;
+	const diagramNode = findDiagramNode(context, nodeId);
+	if (!diagramNode) return;
+	if (diagramNode.deploymentRef) enqueue.raise({
+		type: "open.source",
+		deployment: diagramNode.deploymentRef
+	});
+	else if (diagramNode.modelRef) enqueue.raise({
+		type: "open.source",
+		element: diagramNode.modelRef
+	});
+});
+/**
+* Ensure that the overlays actor is running or stopped based on the current feature flags
+*/
+const ensureOverlaysActor = () => machine.enqueueActions(({ enqueue, check, system }) => {
+	const enabled = check("enabled: Overlays");
+	const running = typedSystem(system).overlaysActorRef;
+	if (enabled && !running) {
+		enqueue.spawnChild("overlays", {
+			id: "overlays",
+			systemId: "overlays",
+			syncSnapshot: true
+		});
+		return;
+	}
+	if (!enabled && running) {
+		enqueue.sendTo(running, { type: "close.all" });
+		enqueue.stopChild(running);
+	}
+});
+/**
+* Ensure that the navigation panel actor is running or stopped based on the current state
+*/
+const ensureNavigationPanelActor = () => machine.enqueueActions(({ enqueue, check, system, context }) => {
+	const enabled = check("enabled: NavigationPanel");
+	const running = typedSystem(system).navigationActorRef;
+	const viewFolder = context.view.title && getViewFolderPath(context.view.title) || "";
+	if (enabled && !running) {
+		enqueue.spawnChild("navigationPanel", {
+			id: "navigationPanel",
+			systemId: "navigationPanel",
+			input: {
+				viewId: context.view.id,
+				viewFolder
+			},
+			syncSnapshot: true
+		});
+		return;
+	}
+	if (!enabled && running) enqueue.stopChild(running);
+});
+/**
+* Ensure that the search actor is running or stopped based on the current feature flags
+*/
+const ensureSearchActor = () => machine.enqueueActions(({ enqueue, check, system }) => {
+	const enabled = check("enabled: Search");
+	const running = typedSystem(system).searchActorRef;
+	if (enabled && !running) {
+		enqueue.spawnChild("search", {
+			id: "search",
+			systemId: "search",
+			syncSnapshot: true
+		});
+		return;
+	}
+	if (!enabled && running) {
+		enqueue.sendTo(running, { type: "close" });
+		enqueue.stopChild(running);
+	}
+});
+const onEdgeMouseEnter = () => machine.enqueueActions(({ enqueue, context, event }) => {
+	assertEvent(event, "xyflow.edgeMouseEnter");
+	let edge = event.edge;
+	let parentFlow = edge.type === "seq-step" && edge.data.parentFlow;
+	enqueue.assign({
+		xyedges: context.xyedges.map((e) => {
+			if (e.id === event.edge.id) {
+				edge = Base.setHovered(e, true);
+				return edge;
+			}
+			return e;
+		}),
+		xynodes: parentFlow ? context.xynodes.map((n) => {
+			if (n.type === "seq-subflow" && n.data.flowId === parentFlow.id) return Base.setHovered(n, true);
+			return n;
+		}) : context.xynodes
+	});
+	enqueue.emit({
+		type: "edgeMouseEnter",
+		edge,
+		event: event.event
+	});
+});
+const onEdgeMouseLeave = () => machine.enqueueActions(({ enqueue, context, event }) => {
+	assertEvent(event, "xyflow.edgeMouseLeave");
+	let edge = event.edge;
+	let parentFlow = edge.type === "seq-step" && edge.data.parentFlow;
+	enqueue.assign({
+		xyedges: context.xyedges.map((e) => {
+			if (e.id === event.edge.id) {
+				edge = Base.setHovered(e, false);
+				return edge;
+			}
+			return e;
+		}),
+		xynodes: parentFlow ? context.xynodes.map((n) => {
+			if (n.type === "seq-subflow" && n.data.flowId === parentFlow.id) return Base.setHovered(n, false);
+			return n;
+		}) : context.xynodes
+	});
+	enqueue.emit({
+		type: "edgeMouseLeave",
+		edge,
+		event: event.event
+	});
+});
+const startHotKeyActor = () => machine.spawnChild("hotkey", {
+	id: "hotkey",
+	systemId: "hotkey",
+	syncSnapshot: true
+});
+const stopHotKeyActor = () => machine.stopChild("hotkey");
+/**
+* Auto-unfocus timer duration in milliseconds.
+* Set to 0 to disable auto-unfocus (focus remains until user clicks elsewhere).
+* Used for focusing nodes from search results.
+*/
+const AUTO_UNFOCUS_DELAY = 3e3;
+const startAutoUnfocusTimer = () => machine.enqueueActions(({ context, enqueue }) => {
+	if (context.autoUnfocusTimer && true) enqueue.raise({ type: "focus.autoUnfocus" }, {
+		delay: AUTO_UNFOCUS_DELAY,
+		id: "autoUnfocusTimer"
+	});
+});
+const cancelAutoUnfocusTimer = () => machine.cancel("autoUnfocusTimer");
+const handleNavigate = () => machine.enqueueActions(({ enqueue, context, event }) => {
+	assertEvent(event, [
+		"navigate.to",
+		"navigate.back",
+		"navigate.forward"
+	]);
+	const { view, focusedNode, activeWalkthrough, dynamicViewVariant, viewport, viewportChangedManually, viewportBefore, navigationHistory } = context;
+	let { currentIndex, history: _history } = navigationHistory;
+	let history = _history;
+	if (currentIndex < _history.length) {
+		const updatedEntry = produce(_history.at(currentIndex) ?? {}, (draft) => {
+			draft.viewport = { ...viewport };
+			draft.viewportChangedManually = viewportChangedManually;
+			draft.focusedNode = focusedNode;
+			if (view._type === "dynamic") {
+				draft.activeWalkthrough = activeWalkthrough?.stepId ?? null;
+				draft.dynamicViewVariant = dynamicViewVariant;
+			} else {
+				draft.activeWalkthrough = null;
+				draft.dynamicViewVariant = null;
+			}
+			if (viewportBefore) draft.viewportBefore = structuredClone(viewportBefore);
+			else delete draft.viewportBefore;
+		});
+		history = [..._history];
+		history[currentIndex] = updatedEntry;
+	}
+	switch (event.type) {
+		case "navigate.to":
+			enqueue.assign({
+				navigationHistory: {
+					currentIndex,
+					history
+				},
+				lastOnNavigate: {
+					fromView: context.view.id,
+					toView: event.viewId,
+					fromNode: event.fromNode ?? null,
+					focusOnElement: event.focusOnElement ?? null
+				}
+			});
+			enqueue(emitNavigateTo());
+			break;
+		case "navigate.back": {
+			invariant(currentIndex > 0, "Cannot navigate back");
+			const stepBack = history[currentIndex - 1];
+			enqueue.assign({
+				navigationHistory: {
+					currentIndex: currentIndex - 1,
+					history
+				},
+				lastOnNavigate: null
+			});
+			enqueue(emitNavigateTo({ viewId: stepBack.viewId }));
+			break;
+		}
+		case "navigate.forward": {
+			invariant(currentIndex < history.length - 1, "Cannot navigate forward");
+			const stepForward = history[currentIndex + 1];
+			enqueue.assign({
+				navigationHistory: {
+					currentIndex: currentIndex + 1,
+					history
+				},
+				lastOnNavigate: null
+			});
+			enqueue(emitNavigateTo({ viewId: stepForward.viewId }));
+			break;
+		}
+		default: nonexhaustive(event);
+	}
+});
+/**
+* Updates the current view in place.
+*
+* @param params.restoreLayoutViewport - when layout type changes (comparing layouts),
+* restore the viewport remembered for the next layout type, or recenter
+*/
+const updateView = (params) => machine.enqueueActions(({ enqueue, event, context }) => {
+	if (event.type !== "update.view") {
+		console.warn(`Ignoring unexpected event type: ${event.type} in action 'update.view'`);
+		return;
+	}
+	const nextView = event.view;
+	if (nextView.id !== context.view.id) {
+		console.warn("updateView called for another view - ignoring", { event });
+		return;
+	}
+	enqueue(assignXYDataFromView());
+	if (event.source === "editor") return;
+	enqueue(sendSynced());
+	const restoreLayoutViewport = params?.restoreLayoutViewport === true;
+	if (restoreLayoutViewport && context.view._layout !== nextView._layout) {
+		if (nextView._layout === "auto" && context.viewportOnAutoLayout) {
+			enqueue(setViewport({
+				viewport: context.viewportOnAutoLayout,
+				duration: 0
+			}));
+			return;
+		}
+		if (nextView._layout === "manual" && context.viewportOnManualLayout) {
+			enqueue(setViewport({
+				viewport: context.viewportOnManualLayout,
+				duration: 0
+			}));
+			return;
+		}
+	}
+	let recenter = !context.viewportChangedManually && !context.focusedNode && !context.activeWalkthrough;
+	recenter = recenter || restoreLayoutViewport && !!nextView._layout && context.view._layout !== nextView._layout;
+	if (nextView._type === "dynamic" && context.view._type === "dynamic") {
+		if (nextView.variant === context.view.variant && nextView.variant !== context.dynamicViewVariant) {
+			const nextCenter = BBox$1.center(viewBounds(context, nextView));
+			enqueue(setViewportCenter(nextCenter));
+		}
+	}
+	if (recenter) {
+		enqueue(cancelFitDiagram());
+		enqueue(raiseFitDiagram());
+	}
+});
+/**
+* Ensures all child actors are started/stopped as needed
+*/
+const ensureAllActors = () => machine.enqueueActions(({ enqueue }) => {
+	enqueue(ensureEditorActor());
+	enqueue(ensureOverlaysActor());
+	enqueue(ensureSearchActor());
+	enqueue(ensureNavigationPanelActor());
+});
+const collapseOrExpandSequenceFlow = () => machine.enqueueActions(({ enqueue, event, context, check }) => {
+	assertEvent(event, ["sequence.flow.*"]);
+	invariant(isDynamicView(context.view));
+	const flowId = event.flowId;
+	const flow = dynamicViewFlow(context.view);
+	const subflow = flow.isSubflow(flowId) ? flow.lookup(flowId) : null;
+	if (!subflow) return;
+	let targets;
+	let isCollapsed;
+	if (flow.guards.isAltOrTry(subflow)) {
+		targets = flow.subflows(subflow).map((s) => s.id);
+		isCollapsed = targets.some((id) => context.collapsedSequenceFlows[id]);
+	} else {
+		targets = [flowId];
+		isCollapsed = context.collapsedSequenceFlows[flowId] ?? false;
+	}
+	if (isCollapsed && event.type === "sequence.flow.collapse" || !isCollapsed && event.type === "sequence.flow.expand") return;
+	enqueue.assign({ collapsedSequenceFlows: {
+		...context.collapsedSequenceFlows,
+		...mapToObj(targets, (id) => [id, !isCollapsed])
+	} });
+	if (check("is dynamic view in sequence variant")) {
+		enqueue(assignXYDataFromView(context.view));
+		if (!context.viewportChangedManually) enqueue(raiseFitDiagram());
+	}
+});
+
+export { assignDynamicViewVariant, assignElementViewVariant, assignFocusedNode, assignLastClickedNode, assignToggledFeatures, assignViewportBefore, assignXYDataFromView, beforeLayoutTypeChangeWhileComparing, cancelAutoUnfocusTimer, cancelEditing, cancelFitDiagram, centerOnNodeOrEdge, closeAllOverlays, collapseOrExpandSequenceFlow, emitEdgeClick, emitInitialized, emitNavigateTo, emitNodeClick, emitOnLayoutTypeChange, emitOpenSource, emitOpenSourceOfView, emitPaneClick, ensureAllActors, ensureEditorActor, ensureNavigationPanelActor, ensureOverlaysActor, ensureSearchActor, exitComparingLayouts, fitDiagram, fitFocusedBounds, focusOnNodesAndEdges, handleNavigate, highlightNodeOrEdge, layoutAlign, notationsHighlight, onEdgeDoubleClick, onEdgeMouseEnter, onEdgeMouseLeave, onNodeMouseEnter, onNodeMouseLeave, openNodeDetails, openOverlay, openSourceOfFocusedOrLastClickedNode, raiseFitDiagram, raiseSetViewport, raiseUpdateView, resetEdgesControlPoints, resetLastClickedNode, resetSelection, returnViewportBefore, sendSynced, setViewport, setViewportCenter, startAutoUnfocusTimer, startEditing, startHotKeyActor, stopEditing, stopEditorActor, stopHotKeyActor, tagHighlight, triggerChange, undimEverything, updateFeatures, updateInputs, updateView };