@likec4/diagram 1.55.0 → 1.56.0

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

@@ -1,824 +1,712 @@
-import { exact, nonNullable, nonexhaustive, invariant } from '@likec4/core';
-import { BBox } from '@likec4/core/geometry';
-import { difference } from '@likec4/core/utils';
-import { nodeToRect } from '@xyflow/system';
-import { produce } from 'immer';
-import { hasAtLeast, isTruthy } from 'remeda';
-import { assertEvent } from 'xstate';
-import { convertToXYFlow } from '../convert-to-xyflow.js';
-import { createLayoutConstraints } from '../useLayoutConstraints.js';
-import { getAligner, toNodeRect } from './aligners.js';
-import { resetEdgeControlPoints, mergeXYNodesEdges, focusNodesEdges } from './assign.js';
-import { setViewport, setViewportCenter, cancelFitDiagram, raiseFitDiagram } from './machine.actions.layout.js';
-export { assignViewportBefore, centerOnNodeOrEdge, fitDiagram, fitFocusedBounds, raiseSetViewport, raiseUpdateView, returnViewportBefore } from './machine.actions.layout.js';
-import { machine } from './machine.setup.js';
-import { typedSystem, findDiagramNode, findDiagramEdge, viewBounds } from './utils.js';
-import { Base } from '../../base/Base.js';
-
-const disableCompareWithLatest = () => machine.assign(({ context }) => {
-  return {
-    toggledFeatures: {
-      ...context.toggledFeatures,
-      enableCompareWithLatest: false
-    },
-    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
+import "../../_virtual/_rolldown/runtime.js";
+import { Base } from "../../base/Base.js";
+import { findDiagramEdge, findDiagramNode, typedSystem, viewBounds } from "./utils.js";
+import { machine } from "./machine.setup.js";
+import { createLayoutConstraints } from "../useLayoutConstraints.js";
+import { focusNodesEdges, mergeXYNodesEdges, resetEdgeControlPoints } from "./assign.js";
+import { convertToXYFlow } from "../convert-to-xyflow.js";
+import { getAligner, toNodeRect } from "./aligners.js";
+import { cancelFitDiagram, raiseFitDiagram, setViewport, setViewportCenter } from "./machine.actions.layout.js";
+import { hasAtLeast, isTruthy } from "remeda";
+import { exact, invariant, nonNullable, nonexhaustive } from "@likec4/core";
+import { BBox as BBox$1 } from "@likec4/core/geometry";
+import { difference as difference$1 } from "@likec4/core/utils";
+import { nodeToRect } from "@xyflow/system";
+import { assertEvent } from "xstate";
+import { produce } from "immer";
+//#region src/likec4diagram/state/machine.actions.ts
+var disableCompareWithLatest = () => machine.assign(({ context }) => {
+	return {
+		toggledFeatures: {
+			...context.toggledFeatures,
+			enableCompareWithLatest: false
+		},
+		viewportOnAutoLayout: null,
+		viewportOnManualLayout: null
+	};
+});
+var 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
+			}
+		};
+	}) };
+});
+var 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()
+	} };
+});
+var 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
+	};
+});
+var resetLastClickedNode = () => machine.assign(() => ({ lastClickedNode: null }));
+var updateFeatures = () => machine.assign(({ context, event }) => {
+	assertEvent(event, "update.features");
+	return { features: {
+		...context.features,
+		...event.features
+	} };
+});
+var updateInputs = () => machine.assign(({ event }) => {
+	assertEvent(event, "update.inputs");
+	return exact({ ...event.inputs });
+});
+var assignXYDataFromView = (view) => machine.assign(({ context, event }) => {
+	let xydata;
+	if (view) xydata = convertToXYFlow({
+		currentViewId: context.view.id,
+		dynamicViewVariant: context.dynamicViewVariant,
+		view,
+		where: context.where
+	});
+	else {
+		assertEvent(event, "update.view");
+		xydata = "xynodes" in event ? event : convertToXYFlow({
+			currentViewId: context.view.id,
+			dynamicViewVariant: context.dynamicViewVariant,
+			view: event.view,
+			where: context.where
+		});
+	}
+	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;
+});
+var focusOnNodesAndEdges = () => machine.enqueueActions(({ context, enqueue }) => {
+	const next = focusNodesEdges(context);
+	if (next) enqueue.assign(next);
+	else enqueue.raise({ type: "key.esc" });
+});
+var undimEverything = () => machine.assign(({ context }) => ({
+	xynodes: context.xynodes.map(Base.setDimmed(false)),
+	xyedges: context.xyedges.map(Base.setData({
+		dimmed: false,
+		active: false
+	}))
 }));
-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;
-  {
-    assertEvent(event, "update.view");
-    xydata = "xynodes" in event ? event : convertToXYFlow({
-      currentViewId: context.view.id,
-      dynamicViewVariant: context.dynamicViewVariant,
-      view: event.view,
-      where: context.where
-    });
-  }
-  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
-  }))
+var assignDynamicViewVariant = () => machine.assign(({ event }) => {
+	assertEvent(event, "switch.dynamicViewVariant");
+	return { dynamicViewVariant: event.variant };
+});
+var onNodeMouseEnter = (params) => machine.assign(({ context, event }) => {
+	let node = params?.node;
+	if (!node) {
+		assertEvent(event, "xyflow.nodeMouseEnter");
+		node = event.node;
+	}
+	return { xynodes: context.xynodes.map((n) => {
+		if (n.id === node.id) return Base.setHovered(n, true);
+		return n;
+	}) };
+});
+var onNodeMouseLeave = (params) => machine.assign(({ context, event }) => {
+	let node = params?.node;
+	if (!node) {
+		assertEvent(event, "xyflow.nodeMouseLeave");
+		node = event.node;
+	}
+	return { xynodes: context.xynodes.map((n) => {
+		if (n.id === node.id) return Base.setHovered(n, false);
+		return n;
+	}) };
+});
+var emitPaneClick = () => machine.emit(() => ({ type: "paneClick" }));
+var emitOpenSource = (params) => machine.emit(({ event }) => {
+	if (params) return {
+		type: "openSource",
+		params
+	};
+	assertEvent(event, "open.source");
+	return {
+		type: "openSource",
+		params: event
+	};
+});
+var emitOpenSourceOfView = () => machine.emit(({ context }) => ({
+	type: "openSource",
+	params: { view: context.view.id }
 }));
-const assignDynamicViewVariant = () => machine.assign(({ event }) => {
-  assertEvent(event, "switch.dynamicViewVariant");
-  return {
-    dynamicViewVariant: event.variant
-  };
-});
-const onNodeMouseEnter = (params) => machine.assign(({ context, event }) => {
-  let node = params?.node;
-  if (!node) {
-    assertEvent(event, "xyflow.nodeMouseEnter");
-    node = event.node;
-  }
-  return {
-    xynodes: context.xynodes.map((n) => {
-      if (n.id === node.id) {
-        return Base.setHovered(n, true);
-      }
-      return n;
-    })
-  };
-});
-const onNodeMouseLeave = (params) => machine.assign(({ context, event }) => {
-  let node = params?.node;
-  if (!node) {
-    assertEvent(event, "xyflow.nodeMouseLeave");
-    node = event.node;
-  }
-  return {
-    xynodes: context.xynodes.map((n) => {
-      if (n.id === node.id) {
-        return Base.setHovered(n, false);
-      }
-      return n;
-    })
-  };
-});
-const emitPaneClick = () => machine.emit(() => ({
-  type: "paneClick"
+var emitInitialized = () => machine.emit(({ context }) => {
+	invariant(context.xyflow, "XYFlow instance not found");
+	return {
+		type: "initialized",
+		instance: context.xyflow
+	};
+});
+var emitNodeClick = () => machine.emit(({ context, event }) => {
+	assertEvent(event, "xyflow.nodeClick");
+	return {
+		type: "nodeClick",
+		node: nonNullable(findDiagramNode(context, event.node.id), `Node ${event.node.id} not found in diagram`),
+		xynode: event.node
+	};
+});
+var emitNavigateTo = (params) => machine.emit(({ context }) => ({
+	type: "navigateTo",
+	viewId: params?.viewId ?? nonNullable(context.lastOnNavigate, "Invalid state, lastOnNavigate is null").toView
 }));
-const emitOpenSource = (params) => machine.emit(({ event }) => {
-  assertEvent(event, "open.source");
-  return {
-    type: "openSource",
-    params: event
-  };
-});
-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.emit(({ context, event }) => {
-  assertEvent(event, "xyflow.nodeClick");
-  const node = nonNullable(findDiagramNode(context, event.node.id), `Node ${event.node.id} not found in diagram`);
-  return {
-    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");
-  const edge = nonNullable(findDiagramEdge(context, event.edge.id), `Edge ${event.edge.id} not found in diagram`);
-  return {
-    type: "edgeClick",
-    edge,
-    xyedge: event.edge
-  };
-});
-const triggerChange = (viewChange) => machine.enqueueActions(({ event, enqueue }) => {
-  let change = viewChange;
-  if (!change) {
-    assertEvent(event, "trigger.change");
-    change = event.change;
-  }
-  enqueue.assign({
-    viewportChangedManually: true
-  });
-  enqueue.sendTo(
-    typedSystem.editorActor,
-    {
-      type: "change",
-      change
-    }
-  );
-});
-const emitOnLayoutTypeChange = () => machine.enqueueActions(({ event, system, context, enqueue }) => {
-  if (!context.features.enableCompareWithLatest) {
-    console.warn("Layout type cannot be changed while CompareWithLatest feature is disabled");
-    return;
-  }
-  const currentLayoutType = context.view._layout;
-  let nextLayoutType = currentLayoutType === "auto" ? "manual" : "auto";
-  if (event.type === "emit.onLayoutTypeChange") {
-    nextLayoutType = event.layoutType;
-  }
-  if (currentLayoutType === nextLayoutType) {
-    console.warn("Ignoring layout type change event, layout type is already", currentLayoutType);
-    return;
-  }
-  if (context.toggledFeatures.enableCompareWithLatest === true) {
-    if (currentLayoutType === "manual" && nextLayoutType === "auto") {
-      typedSystem(system).editorActorRef?.send({
-        type: "cancel"
-      });
-    }
-    const currentViewport = context.viewport;
-    if (currentLayoutType === "auto") {
-      enqueue.assign({
-        viewportOnAutoLayout: currentViewport
-      });
-    }
-    if (currentLayoutType === "manual") {
-      enqueue.assign({
-        viewportOnManualLayout: currentViewport
-      });
-    }
-  }
-  enqueue.emit({
-    type: "onLayoutTypeChange",
-    layoutType: nextLayoutType
-  });
-});
-const layoutAlign = (params) => machine.createAction(({ context, event }) => {
-  let mode;
-  {
-    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(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);
-  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);
-  const xynodes = context.xynodes.map((n) => {
-    const node = findDiagramNode(context, n.id);
-    const highlighted = node && shouldHighlight(node);
-    return Base.setDimmed(n, highlighted ? false : "immediate");
-  });
-  const xyedges = context.xyedges.map((edge) => {
-    return Base.setDimmed(edge, true);
-  });
-  return { xynodes, xyedges };
-});
-const tagHighlight = () => machine.assign(({ context, event }) => {
-  assertEvent(event, "tag.highlight");
-  return {
-    xynodes: context.xynodes.map((n) => {
-      if (n.data.tags?.includes(event.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;
-      const node = context.xynodes.find((n) => n.id === nodeId);
-      if (!node) {
-        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 closeSearch = () => machine.sendTo(
-  typedSystem.searchActor,
-  {
-    type: "close"
-  }
-);
-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);
-});
-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("editorActor", {
-      id: "editor",
-      systemId: "editor",
-      input: {
-        viewId: context.view.id
-      },
-      syncSnapshot: true
-    });
-  }
-});
-const startEditing = (subject = "node") => machine.sendTo(
-  typedSystem.editorActor,
-  {
-    type: "edit.start",
-    subject
-  }
-);
-const sendSynced = () => machine.sendTo(
-  typedSystem.editorActor,
-  {
-    type: "synced"
-  }
-);
-const stopEditing = (wasChanged = false) => machine.sendTo(
-  typedSystem.editorActor,
-  {
-    type: "edit.finish",
-    wasChanged
-  }
-);
-const cancelEditing = () => machine.sendTo(
-  typedSystem.editorActor,
-  {
-    type: "cancel"
-  }
-);
-const hasModelFqn = (node) => "modelFqn" in node.data && isTruthy(node.data.modelFqn);
-const openElementDetails = (params) => machine.enqueueActions(({ context, event, enqueue }) => {
-  let initiatedFrom = null;
-  let fromNodeId, subject;
-  switch (true) {
-    // Use from params if available
-    case false: {
-      subject = params.fqn;
-      fromNodeId = params.fromNode ?? context.view.nodes.find((n) => n.modelRef === params.fqn)?.id;
-      break;
-    }
-    case event.type === "xyflow.nodeClick": {
-      if (!hasModelFqn(event.node)) {
-        console.warn("No modelFqn in clicked node data");
-        return;
-      }
-      subject = event.node.data.modelFqn;
-      fromNodeId = event.node.data.id;
-      break;
-    }
-    case event.type === "open.elementDetails": {
-      subject = event.fqn;
-      fromNodeId = event.fromNode;
-      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);
-      if (!node || !hasModelFqn(node)) {
-        console.warn("No modelFqn in last clicked node");
-        return;
-      }
-      subject = node.data.modelFqn;
-      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.elementDetails"]);
-  if (!check("enabled: Overlays")) {
-    console.warn("Overlays feature is disabled");
-    return;
-  }
-  switch (event.type) {
-    case "open.elementDetails": {
-      check("enabled: ElementDetails") ? enqueue(openElementDetails()) : 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: "view",
-          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 });
-  }
-});
-const ensureOverlaysActor = () => machine.enqueueActions(({ enqueue, check, system }) => {
-  const enabled = check("enabled: Overlays");
-  const running = typedSystem(system).overlaysActorRef;
-  if (enabled && !running) {
-    enqueue.spawnChild("overlaysActorLogic", {
-      id: "overlays",
-      systemId: "overlays",
-      syncSnapshot: true
-    });
-    return;
-  }
-  if (!enabled && running) {
-    enqueue.sendTo(running, {
-      type: "close.all"
-    });
-    enqueue.stopChild(running);
-  }
-});
-const ensureSearchActor = () => machine.enqueueActions(({ enqueue, check, system }) => {
-  const enabled = check("enabled: Search");
-  const running = typedSystem(system).searchActorRef;
-  if (enabled && !running) {
-    enqueue.spawnChild("searchActorLogic", {
-      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;
-  enqueue.assign({
-    xyedges: context.xyedges.map((e) => {
-      if (e.id === event.edge.id) {
-        edge = Base.setHovered(e, true);
-        return edge;
-      }
-      return e;
-    })
-  });
-  enqueue.emit({
-    type: "edgeMouseEnter",
-    edge,
-    event: event.event
-  });
-});
-const onEdgeMouseLeave = () => machine.enqueueActions(({ enqueue, context, event }) => {
-  assertEvent(event, "xyflow.edgeMouseLeave");
-  let edge = event.edge;
-  enqueue.assign({
-    xyedges: context.xyedges.map((e) => {
-      if (e.id === event.edge.id) {
-        edge = Base.setHovered(e, false);
-        return edge;
-      }
-      return e;
-    })
-  });
-  enqueue.emit({
-    type: "edgeMouseLeave",
-    edge,
-    event: event.event
-  });
-});
-const startHotKeyActor = () => machine.spawnChild("hotkeyActorLogic", { id: "hotkey" });
-const stopHotKeyActor = () => machine.stopChild("hotkey");
-const AUTO_UNFOCUS_DELAY = 3e3;
-const startAutoUnfocusTimer = () => machine.enqueueActions(({ context, enqueue }) => {
-  if (context.autoUnfocusTimer && AUTO_UNFOCUS_DELAY > 0) {
-    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);
-  }
-});
-const updateView = () => 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;
-    const isAnotherView = nextView.id !== context.view.id;
-    if (isAnotherView) {
-      console.warn("updateView called for another view - ignoring", { event });
-      return;
-    }
-    enqueue(assignXYDataFromView());
-    if (event.source === "editor") {
-      return;
-    }
-    enqueue(sendSynced());
-    if (context.toggledFeatures.enableCompareWithLatest === true && 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 || context.toggledFeatures.enableCompareWithLatest === true && !!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.center(viewBounds(context, nextView));
-        enqueue(setViewportCenter(nextCenter));
-      }
-    }
-    if (recenter) {
-      enqueue(cancelFitDiagram());
-      enqueue(raiseFitDiagram());
-    }
-  }
-);
-
-export { assignDynamicViewVariant, assignFocusedNode, assignLastClickedNode, assignToggledFeatures, assignXYDataFromView, cancelAutoUnfocusTimer, cancelEditing, cancelFitDiagram, closeAllOverlays, closeSearch, disableCompareWithLatest, emitEdgeClick, emitInitialized, emitNavigateTo, emitNodeClick, emitOnLayoutTypeChange, emitOpenSource, emitOpenSourceOfView, emitPaneClick, ensureEditorActor, ensureOverlaysActor, ensureSearchActor, focusOnNodesAndEdges, handleNavigate, highlightNodeOrEdge, layoutAlign, notationsHighlight, onEdgeDoubleClick, onEdgeMouseEnter, onEdgeMouseLeave, onNodeMouseEnter, onNodeMouseLeave, openElementDetails, openOverlay, openSourceOfFocusedOrLastClickedNode, raiseFitDiagram, resetEdgesControlPoints, resetLastClickedNode, sendSynced, setViewport, setViewportCenter, startAutoUnfocusTimer, startEditing, startHotKeyActor, stopEditing, stopEditorActor, stopHotKeyActor, tagHighlight, triggerChange, undimEverything, updateFeatures, updateInputs, updateView };
+var 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
+	};
+});
+var triggerChange = (viewChange) => machine.enqueueActions(({ event, enqueue }) => {
+	let change = viewChange;
+	if (!change) {
+		assertEvent(event, "trigger.change");
+		change = event.change;
+	}
+	enqueue.assign({ viewportChangedManually: true });
+	enqueue.sendTo(typedSystem.editorActor, {
+		type: "change",
+		change
+	});
+});
+var emitOnLayoutTypeChange = () => machine.enqueueActions(({ event, system, context, enqueue }) => {
+	if (!context.features.enableCompareWithLatest) {
+		console.warn("Layout type cannot be changed while CompareWithLatest feature is disabled");
+		return;
+	}
+	const currentLayoutType = context.view._layout;
+	let nextLayoutType = currentLayoutType === "auto" ? "manual" : "auto";
+	if (event.type === "emit.onLayoutTypeChange") nextLayoutType = event.layoutType;
+	if (currentLayoutType === nextLayoutType) {
+		console.warn("Ignoring layout type change event, layout type is already", currentLayoutType);
+		return;
+	}
+	if (context.toggledFeatures.enableCompareWithLatest === true) {
+		if (currentLayoutType === "manual" && nextLayoutType === "auto") typedSystem(system).editorActorRef?.send({ type: "cancel" });
+		const currentViewport = context.viewport;
+		if (currentLayoutType === "auto") enqueue.assign({ viewportOnAutoLayout: currentViewport });
+		if (currentLayoutType === "manual") enqueue.assign({ viewportOnManualLayout: currentViewport });
+	}
+	enqueue.emit({
+		type: "onLayoutTypeChange",
+		layoutType: nextLayoutType
+	});
+});
+var 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 nodesToAlign = [...difference$1(new Set(nodeLookup.values().filter((n) => n.selected).map((n) => n.id)), 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);
+	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();
+});
+var 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
+			}
+		};
+	}) };
+});
+var 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);
+		})
+	};
+});
+var tagHighlight = () => machine.assign(({ context, event }) => {
+	assertEvent(event, "tag.highlight");
+	return { xynodes: context.xynodes.map((n) => {
+		if (n.data.tags?.includes(event.tag)) return Base.setDimmed(n, false);
+		return Base.setDimmed(n, true);
+	}) };
+});
+var 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);
+	}
+});
+var 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
+	} };
+});
+var closeSearch = () => machine.sendTo(typedSystem.searchActor, { type: "close" });
+var closeAllOverlays = () => machine.sendTo(typedSystem.overlaysActor, { type: "close.all" });
+var 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
+*/
+var 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("editorActor", {
+		id: "editor",
+		systemId: "editor",
+		input: { viewId: context.view.id },
+		syncSnapshot: true
+	});
+});
+var startEditing = (subject = "node") => machine.sendTo(typedSystem.editorActor, {
+	type: "edit.start",
+	subject
+});
+var sendSynced = () => machine.sendTo(typedSystem.editorActor, { type: "synced" });
+var stopEditing = (wasChanged = false) => machine.sendTo(typedSystem.editorActor, {
+	type: "edit.finish",
+	wasChanged
+});
+var cancelEditing = () => machine.sendTo(typedSystem.editorActor, { type: "cancel" });
+var hasModelFqn = (node) => "modelFqn" in node.data && isTruthy(node.data.modelFqn);
+var openElementDetails = (params) => machine.enqueueActions(({ context, event, enqueue }) => {
+	let initiatedFrom = null;
+	let fromNodeId;
+	let subject;
+	switch (true) {
+		case !!params:
+			subject = params.fqn;
+			fromNodeId = params.fromNode ?? context.view.nodes.find((n) => n.modelRef === params.fqn)?.id;
+			break;
+		case event.type === "xyflow.nodeClick":
+			if (!hasModelFqn(event.node)) {
+				console.warn("No modelFqn in clicked node data");
+				return;
+			}
+			subject = event.node.data.modelFqn;
+			fromNodeId = event.node.data.id;
+			break;
+		case event.type === "open.elementDetails":
+			subject = event.fqn;
+			fromNodeId = event.fromNode;
+			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);
+			if (!node || !hasModelFqn(node)) {
+				console.warn("No modelFqn in last clicked node");
+				return;
+			}
+			subject = node.data.modelFqn;
+			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 }
+	});
+});
+var openOverlay = () => machine.enqueueActions(({ context, event, enqueue, check }) => {
+	assertEvent(event, [
+		"open.relationshipsBrowser",
+		"open.relationshipDetails",
+		"open.elementDetails"
+	]);
+	if (!check("enabled: Overlays")) {
+		console.warn("Overlays feature is disabled");
+		return;
+	}
+	switch (event.type) {
+		case "open.elementDetails":
+			check("enabled: ElementDetails") ? enqueue(openElementDetails()) : 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: "view",
+				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);
+	}
+});
+var 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
+*/
+var ensureOverlaysActor = () => machine.enqueueActions(({ enqueue, check, system }) => {
+	const enabled = check("enabled: Overlays");
+	const running = typedSystem(system).overlaysActorRef;
+	if (enabled && !running) {
+		enqueue.spawnChild("overlaysActorLogic", {
+			id: "overlays",
+			systemId: "overlays",
+			syncSnapshot: true
+		});
+		return;
+	}
+	if (!enabled && running) {
+		enqueue.sendTo(running, { type: "close.all" });
+		enqueue.stopChild(running);
+	}
+});
+/**
+* Ensure that the search actor is running or stopped based on the current feature flags
+*/
+var ensureSearchActor = () => machine.enqueueActions(({ enqueue, check, system }) => {
+	const enabled = check("enabled: Search");
+	const running = typedSystem(system).searchActorRef;
+	if (enabled && !running) {
+		enqueue.spawnChild("searchActorLogic", {
+			id: "search",
+			systemId: "search",
+			syncSnapshot: true
+		});
+		return;
+	}
+	if (!enabled && running) {
+		enqueue.sendTo(running, { type: "close" });
+		enqueue.stopChild(running);
+	}
+});
+var onEdgeMouseEnter = () => machine.enqueueActions(({ enqueue, context, event }) => {
+	assertEvent(event, "xyflow.edgeMouseEnter");
+	let edge = event.edge;
+	enqueue.assign({ xyedges: context.xyedges.map((e) => {
+		if (e.id === event.edge.id) {
+			edge = Base.setHovered(e, true);
+			return edge;
+		}
+		return e;
+	}) });
+	enqueue.emit({
+		type: "edgeMouseEnter",
+		edge,
+		event: event.event
+	});
+});
+var onEdgeMouseLeave = () => machine.enqueueActions(({ enqueue, context, event }) => {
+	assertEvent(event, "xyflow.edgeMouseLeave");
+	let edge = event.edge;
+	enqueue.assign({ xyedges: context.xyedges.map((e) => {
+		if (e.id === event.edge.id) {
+			edge = Base.setHovered(e, false);
+			return edge;
+		}
+		return e;
+	}) });
+	enqueue.emit({
+		type: "edgeMouseLeave",
+		edge,
+		event: event.event
+	});
+});
+var startHotKeyActor = () => machine.spawnChild("hotkeyActorLogic", { id: "hotkey" });
+var 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.
+*/
+var AUTO_UNFOCUS_DELAY = 3e3;
+var startAutoUnfocusTimer = () => machine.enqueueActions(({ context, enqueue }) => {
+	if (context.autoUnfocusTimer && AUTO_UNFOCUS_DELAY > 0) enqueue.raise({ type: "focus.autoUnfocus" }, {
+		delay: AUTO_UNFOCUS_DELAY,
+		id: "autoUnfocusTimer"
+	});
+});
+var cancelAutoUnfocusTimer = () => machine.cancel("autoUnfocusTimer");
+var 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);
+	}
+});
+var updateView = () => 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());
+	if (context.toggledFeatures.enableCompareWithLatest === true && 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 || context.toggledFeatures.enableCompareWithLatest === true && !!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) enqueue(setViewportCenter(BBox$1.center(viewBounds(context, nextView))));
+	}
+	if (recenter) {
+		enqueue(cancelFitDiagram());
+		enqueue(raiseFitDiagram());
+	}
+});
+//#endregion
+export { assignDynamicViewVariant, assignFocusedNode, assignLastClickedNode, assignToggledFeatures, assignXYDataFromView, cancelAutoUnfocusTimer, cancelEditing, closeAllOverlays, closeSearch, disableCompareWithLatest, emitEdgeClick, emitInitialized, emitNodeClick, emitOnLayoutTypeChange, emitOpenSource, emitOpenSourceOfView, emitPaneClick, ensureEditorActor, ensureOverlaysActor, ensureSearchActor, focusOnNodesAndEdges, handleNavigate, highlightNodeOrEdge, layoutAlign, notationsHighlight, onEdgeDoubleClick, onEdgeMouseEnter, onEdgeMouseLeave, onNodeMouseEnter, onNodeMouseLeave, openElementDetails, openOverlay, openSourceOfFocusedOrLastClickedNode, resetEdgesControlPoints, resetLastClickedNode, startAutoUnfocusTimer, startEditing, startHotKeyActor, stopEditing, stopEditorActor, stopHotKeyActor, tagHighlight, triggerChange, undimEverything, updateFeatures, updateInputs, updateView };