@weasel-js/diagram 1.11.0 → 1.11.1

package/dist/chunk-CI3I3I6T.js

@@ -0,0 +1,3600 @@
+import { createAvoidRouter, placeLabels, edgeHops, DEFAULT_HOP_SIZE, HOPS_DOC_KEY, simplifyStops } from './chunk-T6DQT553.js';
+import { edgeRouter, registerMarkShape, withDiagramRegistry, diagramGroupOf, diagramLabelOf, editEdgeLabelBinding, editEdgeLabelAction, diagramContainerOf, headerBox, labelFollowsLayout, buildGraph, LABEL_DRAG_AFFORDANCE_KIND, EDIT_EDGE_LABEL_ACTION_ID, labelDragLayer, laneOutlineOf, routerOf, labelScratchOf, ROUTERS, avoid, LABEL_PLACEMENT, editableLabels, titleIdOf, orthogonal, diagramAnchorOf, MIN_LANE_SIZE, endAims, resolveEnd, EDGE_DERIVE_PATH, titlePose, regionSpecs, DIAGRAM_THEME_KEY, diagramThemeOf, boxCenter, themeLabelFamily, roleEdgeStyle, roleStyle, themeLabelFont, firstLanes, DEFAULT_LANE_SIZE, bodyBox } from './chunk-43LDZ6L4.js';
+import { diagramEdgeOf, isPromise, dataKeyReader, diagramNodeOf, portsOf, portSitesOf, outlinePath, samePoints, layoutWritesRoute, plannerPlan, planOf, layered, forceRelaxation, center, layoutOwnsPort, chain, force, tree, portOf, labelCenter, labelSpotAt, isPinned, layoutOwnsRoute } from './chunk-IM6DHWZO.js';
+import { bodyPredicate, dragPanContribution, WeaselProvider, useScene, useSelection, useLatest, SceneCanvas, useDepSource, fitViewToBounds, registerNodeShape, reconcileSpecs, nodeGates, effectivePose, pagesBounds, pagesLayer, AUTO_POSE_DESCRIPTOR, usePoseRun, drawnBoundsScene, pointAlongPath, drawnAABBOf, RECT_POSE_DESCRIPTOR, commandFill, commandStroke, translatePoseViaDescriptor, composeAffordanceLayer, createResizeAction, createDeleteAction, polylineFromPoints, SNAP_ROLES, ActionDisabledReason, paintsLayer, viewToTransform, ellipsePath, snapMods, documentDepOf, carriedDescendants, sceneCarrySource, derivedDepOf, PathBuilder, createInsertOp, createSetDataOp, documentPose } from '@weasel-js/core';
+import { AUTO_POSE_DESCRIPTOR as AUTO_POSE_DESCRIPTOR$1, rotatePoint } from '@weasel-js/core/math';
+import { placeRect, pathContainsPoint } from '@weasel-js/geom';
+import { useLatest as useLatest$1, adoptCssOnce } from '@weasel-js/react';
+import { forwardRef, useMemo, useEffect, useState, useRef, useCallback, useImperativeHandle, useLayoutEffect } from 'react';
+import '@weasel-js/animator';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+var PORT_LAYER_ID = "diagram-ports";
+var PORT_AFFORDANCE_KIND = `layer:${PORT_LAYER_ID}`;
+function offersPorts(p, view) {
+  return p.hidden !== true && p.locked !== true && paintsLayer(view, p.layer);
+}
+var DEFAULT_HIT_PX = 8;
+var DEFAULT_SIZE_PX = 7;
+function portScratchOf(hit) {
+  const payload = hit?.payload;
+  return payload !== void 0 && typeof payload.portId === "string" ? payload : null;
+}
+function withPaint(paint) {
+  return paint === void 0 ? {} : { paint };
+}
+function createPortAffordance(participants, opts = {}) {
+  const {
+    id = PORT_LAYER_ID,
+    hitRadiusPx = DEFAULT_HIT_PX,
+    sizePx = DEFAULT_SIZE_PX,
+    strength = "exclusive"
+  } = opts;
+  const portOpts = {
+    ...opts.geometry ? { geometry: opts.geometry } : {},
+    ...opts.read ? { read: opts.read } : {}
+  };
+  const paintOf2 = (port) => {
+    if (sizePx <= 0) return void 0;
+    const fill = typeof opts.fill === "function" ? opts.fill(port) : opts.fill;
+    const look = { ...fill ? { fill } : {}, ...opts.stroke ? { stroke: opts.stroke } : {} };
+    if (opts.shape !== "circle") return { kind: "square", sizePx, ...look };
+    return {
+      kind: "custom",
+      // An affordance layer paints in screen pixels, so the mark stays one size at any zoom.
+      draw: ({ world, view }) => {
+        const t = viewToTransform(view);
+        const x = t.panX + world.x * t.zoom.x - sizePx / 2;
+        const y = t.panY + world.y * t.zoom.y - sizePx / 2;
+        return [{ kind: "path", path: ellipsePath({ x, y, width: sizePx, height: sizePx }), ...look }];
+      }
+    };
+  };
+  return {
+    id,
+    regions(state) {
+      const out = [];
+      for (const participant of participants()) {
+        if (!offersPorts(participant, state)) continue;
+        const { node, pose } = participant;
+        if (opts.shows !== void 0 && !opts.shows(node, state)) continue;
+        for (const port of portsOf(node, pose, portOpts)) {
+          if (opts.showsPort !== void 0 && !opts.showsPort(port)) continue;
+          out.push({
+            id: `${node.id}:${port.id}`,
+            targetId: null,
+            shape: { kind: "point", x: port.point.x, y: port.point.y, hitRadiusPx },
+            ...withPaint(paintOf2(port)),
+            ...opts.cursor !== void 0 ? { cursor: opts.cursor } : {},
+            strength,
+            claimedKinds: ["pointer"],
+            bind: () => ({
+              initialScratch: {
+                targetId: node.id,
+                nodeId: node.id,
+                portId: port.id,
+                port
+              }
+            })
+          });
+        }
+      }
+      return out;
+    }
+  };
+}
+function isBodyEnd(end) {
+  return end.kind === "body";
+}
+function bodyAt(participants, at, opts = {}) {
+  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR$1;
+  let hit = null;
+  for (const participant of participants()) {
+    const { node } = participant;
+    if (!offersPorts(participant, opts.view)) continue;
+    if (diagramEdgeOf(node) !== null || diagramLabelOf(node) !== null || diagramGroupOf(node) !== null) continue;
+    const trait = diagramNodeOf(node, opts.read);
+    if (trait === null || trait.group !== void 0) continue;
+    const bounds = geometry.getBounds(participant.pose);
+    if (bounds.width <= 0 || bounds.height <= 0) continue;
+    const rotation = geometry.getRotation?.(participant.pose) ?? 0;
+    const local = rotation === 0 ? at : rotatePoint(at.x, at.y, bounds.x + bounds.width / 2, bounds.y + bounds.height / 2, -rotation);
+    const inside2 = trait.outline === void 0 ? local.x >= bounds.x && local.x <= bounds.x + bounds.width && local.y >= bounds.y && local.y <= bounds.y + bounds.height : pathContainsPoint(outlinePath(trait.outline, bounds), local.x, local.y);
+    if (inside2) hit = { end: { kind: "body", nodeId: node.id, point: { x: at.x, y: at.y } }, participant };
+  }
+  return hit;
+}
+function createTargets(opts) {
+  const portOpts = {
+    ...opts.geometry ? { geometry: opts.geometry } : {},
+    ...opts.read ? { read: opts.read } : {}
+  };
+  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR$1;
+  function portTarget(from, at, view) {
+    let best = null;
+    let bestD2 = opts.snapRadius * opts.snapRadius;
+    for (const participant of opts.participants()) {
+      if (!offersPorts(participant, view)) continue;
+      for (const port of portsOf(participant.node, participant.pose, portOpts)) {
+        if (opts.showsPort !== void 0 && !opts.showsPort(port)) continue;
+        if (!opts.canConnect(from, port)) continue;
+        const d2 = (port.point.x - at.x) ** 2 + (port.point.y - at.y) ** 2;
+        if (d2 <= bestD2) {
+          bestD2 = d2;
+          best = port;
+        }
+      }
+    }
+    return best;
+  }
+  function target(from, at, view) {
+    const port = portTarget(from, at, view);
+    if (port !== null || !opts.bodies) return port;
+    const body = bodyAt(opts.participants, at, { ...portOpts, view });
+    if (body === null || portsOf(body.participant.node, body.participant.pose, portOpts).length === 0) return null;
+    return opts.canConnect(from, body.end) ? body.end : null;
+  }
+  function participantOf(nodeId) {
+    for (const participant of opts.participants()) {
+      if (participant.node.id === nodeId) return participant;
+    }
+    return void 0;
+  }
+  function centerOf(end) {
+    const participant = participantOf(end.nodeId);
+    return participant === void 0 ? end.point : boxCenter(geometry, participant.pose);
+  }
+  function portFor(end, toward2) {
+    if (!isBodyEnd(end)) return end;
+    const participant = participantOf(end.nodeId);
+    if (participant === void 0) return null;
+    const dep = { node: participant.node, pose: participant.pose };
+    const all = (d) => portsOf(d.node, d.pose, portOpts);
+    return resolveEnd({}, dep, toward2, portOpts, all) ?? null;
+  }
+  function preview(route, fixed, at, view, moving = "to", waypoints = []) {
+    const landed = target(fixed, at, view);
+    const [fixedCenter, landedCenter] = [centerOf(fixed), landed === null ? at : centerOf(landed)];
+    const aims = moving === "to" ? endAims(fixedCenter, landedCenter, waypoints) : endAims(landedCenter, fixedCenter, waypoints);
+    const [fixedAim, landedAim] = moving === "to" ? [aims.from, aims.to] : [aims.to, aims.from];
+    const free = landed === null ? { id: "", nodeId: "", point: at, normal: null } : portFor(landed, landedAim);
+    const anchored = portFor(fixed, fixedAim);
+    if (free === null || anchored === null) return [];
+    return moving === "to" ? route({ from: anchored, to: free, waypoints }) : route({ from: free, to: anchored, waypoints });
+  }
+  return { target, portFor, preview };
+}
+var CONNECT_ACTION_ID = "diagram.connect";
+var defaultCanConnect = (from, to) => {
+  if (isBodyEnd(from) || isBodyEnd(to)) return from.nodeId !== to.nodeId;
+  if (from.nodeId === to.nodeId && from.id === to.id) return false;
+  if (from.type === void 0 || to.type === void 0) return true;
+  return from.type === to.type;
+};
+var DEFAULT_SNAP = 16;
+var DEFAULT_EDGE_STROKE = {
+  paint: { color: "#7ba7c7" },
+  width: 2,
+  markerEnd: "arrow"
+};
+var DEFAULT_ROUTER = "straight";
+function connectBinding(actionId = CONNECT_ACTION_ID) {
+  return {
+    spec: { kind: "drag", target: `affordance:${PORT_AFFORDANCE_KIND}` },
+    actionId
+  };
+}
+var GRAB_PORT_ACTION_ID = "diagram.grabPort";
+function grabPortAction(id = GRAB_PORT_ACTION_ID) {
+  return {
+    id,
+    label: "Grab port",
+    group: "diagram",
+    invoker: { timing: "immediate", run: () => {
+    } },
+    enabled: () => true
+  };
+}
+function grabPortBindings(actionId = GRAB_PORT_ACTION_ID, kind = PORT_AFFORDANCE_KIND) {
+  return [
+    { spec: { kind: "pointerDown", target: `affordance:${kind}` }, actionId },
+    { spec: { kind: "click", target: `affordance:${kind}` }, actionId }
+  ];
+}
+function commitEdgeToScene(edge, ctx, opts = {}) {
+  const scene = ctx.deps.scene;
+  if (scene === void 0) return;
+  const trait = {
+    from: edgeEndOf(edge.from),
+    to: edgeEndOf(edge.to),
+    router: edge.router
+  };
+  const source = scene.get(edge.from.nodeId);
+  scene.add({
+    kind: "leaf",
+    layer: source?.layer ?? scene.layers[0].id,
+    pose: { x: 0, y: 0, width: 0, height: 0 },
+    data: { diagram: trait, stroke: opts.stroke ?? DEFAULT_EDGE_STROKE },
+    dependsOn: [edge.from.nodeId, edge.to.nodeId],
+    // Without this the edge re-resolves on every dependency move and paints
+    // nothing. `EDGE_DERIVE_PATH` rather than a fresh `edgeDerivePath()` so the
+    // scene can find its registry key and the edge survives `toJSON`.
+    derivePath: EDGE_DERIVE_PATH
+  });
+}
+function edgeEndOf(end) {
+  return isBodyEnd(end) ? {} : { port: end.id };
+}
+function createConnectAction(opts) {
+  const {
+    id = CONNECT_ACTION_ID,
+    canConnect = defaultCanConnect,
+    snapRadius = DEFAULT_SNAP,
+    router: routerKey = DEFAULT_ROUTER
+  } = opts;
+  const stroke = opts.edgeStroke;
+  const commit = opts.commit ?? ((edge, ctx) => commitEdgeToScene(edge, ctx, stroke ? { stroke } : {}));
+  const routers = opts.routers ?? ROUTERS;
+  const route = routers[routerKey] ?? routers["straight"] ?? ROUTERS["straight"];
+  const targets = createTargets({ ...opts, canConnect, snapRadius, bodies: opts.bodies ?? false });
+  function startEnd(ctx) {
+    const pressed = portScratchOf(ctx.drag?.affordance);
+    if (pressed !== null) return pressed.port;
+    if (opts.startFrom !== "body") return null;
+    return bodyAt(opts.participants, ctx.world, { ...opts, view: ctx.deps.view })?.end ?? null;
+  }
+  return {
+    id,
+    label: "Connect",
+    group: "diagram",
+    requires: ["scene", "view"],
+    invoker: {
+      timing: "ongoing",
+      start(ctx) {
+        const from = startEnd(ctx);
+        if (from === null) return {};
+        const scratch = {
+          from,
+          current: { x: ctx.world.x, y: ctx.world.y },
+          open: true,
+          deps: ctx.deps
+        };
+        return {
+          kind: "diagram-connect",
+          onMove(moveCtx) {
+            scratch.current = { x: moveCtx.world.x, y: moveCtx.world.y };
+          },
+          overlay() {
+            if (!scratch.open) return null;
+            const points = targets.preview(route, scratch.from, scratch.current, scratch.deps.view);
+            if (points.length < 2) return null;
+            return { kind: "polyline", points, role: "connector" };
+          },
+          onEnd(endCtx, reason) {
+            scratch.open = false;
+            if (reason === "cancel") return;
+            const to = targets.target(scratch.from, { x: endCtx.world.x, y: endCtx.world.y }, scratch.deps.view);
+            if (to === null) return;
+            commit(
+              { from: scratch.from, to, router: routerKey },
+              { ...endCtx, deps: scratch.deps }
+            );
+          }
+        };
+      }
+    },
+    enabled: () => true
+  };
+}
+
+// src/containers/canDropInto.ts
+function diagramCanDropInto(scene) {
+  const nodeOf = (id) => scene.get(id);
+  const roleOf = (id) => {
+    const node = nodeOf(id);
+    return node === void 0 ? null : diagramContainerOf(node)?.role ?? null;
+  };
+  const attached = (id) => {
+    const node = nodeOf(id);
+    return node !== void 0 && (diagramEdgeOf(node) !== null || diagramLabelOf(node) !== null);
+  };
+  return (parent, ids) => {
+    const node = nodeOf(parent);
+    if (node === void 0 || ids.some(attached)) return false;
+    const role = roleOf(parent);
+    if (role === "pool") return ids.every((id) => roleOf(id) === "lane");
+    if (ids.some((id) => roleOf(id) === "lane")) return false;
+    if (role !== null) return ids.every((id) => roleOf(id) !== "pool");
+    return !attached(parent) && dataKeyReader(node) === null;
+  };
+}
+function diagramDropParentAt(scene, point, role) {
+  if (role === "pool" || role === "lane") return null;
+  let best = null;
+  const walk = (ids) => {
+    for (const id of ids) {
+      const node = scene.get(id);
+      if (node === void 0 || node.kind !== "container") continue;
+      const trait = diagramContainerOf(node);
+      const b = bodyBox(node.pose, trait?.header);
+      const inside2 = point.x >= b.x && point.x < b.x + b.width && point.y >= b.y && point.y < b.y + b.height;
+      if (!inside2) continue;
+      if (trait?.role === "container" || trait?.role === "lane") best = id;
+      walk(scene.childrenOf(id));
+    }
+  };
+  walk(scene.roots);
+  return best;
+}
+
+// src/theme/themeWrites.ts
+var traitOf = (data) => {
+  const d = data?.diagram;
+  return d !== null && typeof d === "object" ? d : null;
+};
+var ownOf = (trait) => new Set(trait.ownStyle ?? []);
+var ownsSize = (trait) => trait.ownFont?.includes("size") === true;
+function containerRole(trait) {
+  const c = trait.container;
+  return c !== null && typeof c === "object" && typeof c.role === "string" ? c.role : null;
+}
+function laneIndex(scene, node) {
+  if (node.parent === null) return 0;
+  const lanes = scene.childrenOf(node.parent).filter((id) => {
+    const t = traitOf(scene.get(id)?.data);
+    return t !== null && containerRole(t) === "lane";
+  });
+  return Math.max(0, lanes.indexOf(node.id));
+}
+function boxLook(scene, node, theme) {
+  const trait = traitOf(node.data);
+  if (trait === null || "from" in trait || "label" in trait || "anchor" in trait || "mark" in trait) return null;
+  const own = ownOf(trait);
+  const ownSize = ownsSize(trait);
+  const role = containerRole(trait);
+  if (role === "pool") return { style: theme.lane.header, own, ownSize };
+  if (role === "lane") {
+    const bodies = theme.lane.bodies;
+    return { style: bodies[laneIndex(scene, node) % bodies.length] ?? theme.container, own, ownSize };
+  }
+  if (role !== null || "group" in trait) return { style: theme.container, own, ownSize };
+  return { style: roleStyle(theme, trait.style), own, ownSize };
+}
+var recolored = (paint, color) => paint?.paint?.color === color ? void 0 : { ...paint, paint: { ...paint?.paint, color } };
+function paintBox(data, look) {
+  const fill = look.own.has("fill") ? void 0 : recolored(data.fill, look.style.fill);
+  const stroke = look.own.has("stroke") || data.stroke === void 0 ? void 0 : recolored(data.stroke, look.style.stroke);
+  if (fill === void 0 && stroke === void 0) return null;
+  return { ...data, ...fill ? { fill } : {}, ...stroke ? { stroke } : {} };
+}
+function paintText(data, color, family, step) {
+  const fill = color === void 0 ? void 0 : recolored(data.fill, color);
+  const size = data.style?.fontSize;
+  const resized = step !== 0 && typeof size === "number" ? { fontSize: Math.max(1, size + step) } : {};
+  const face = data.style !== void 0 && (data.style.fontFamily !== family || "fontSize" in resized) ? { ...data.style, fontFamily: family, ...resized } : void 0;
+  if (fill === void 0 && face === void 0) return null;
+  return { ...data, ...fill ? { fill } : {}, ...face ? { style: face } : {} };
+}
+function paintTag(data, theme, step) {
+  const text = paintText(data, theme.label.fill, themeLabelFamily(theme), step);
+  const background = recolored(data.background, theme.page);
+  if (text === null && background === void 0) return null;
+  return { ...text ?? data, ...background ? { background } : {} };
+}
+function edgeLook(trait, theme) {
+  const style = roleEdgeStyle(theme, trait.style);
+  return { stroke: style.stroke, label: style.label ?? style.stroke, own: ownOf(trait), ownSize: ownsSize(trait) };
+}
+var ownerOf = (node) => Array.isArray(node.dependsOn) && node.dependsOn.length === 1 ? node.dependsOn[0] : node.parent;
+function themeWrites(scene, theme, ids, from) {
+  const out = /* @__PURE__ */ new Map();
+  const step = from === void 0 ? 0 : theme.font.size - from.font.size;
+  const labelStep = from === void 0 ? 0 : themeLabelFont(theme).fontSize - themeLabelFont(from).fontSize;
+  const looks = /* @__PURE__ */ new Map();
+  const lookOf = (id) => {
+    if (!looks.has(id)) {
+      const node = scene.get(id);
+      looks.set(id, node === void 0 ? null : boxLook(scene, node, theme));
+    }
+    return looks.get(id);
+  };
+  const write = (id, next) => {
+    if (next !== null) out.set(id, next);
+  };
+  for (const node of scene.renderOrderNodes()) {
+    const data = node.data;
+    if (data === null || typeof data !== "object") continue;
+    const trait = traitOf(data);
+    if (trait !== null && "from" in trait && "to" in trait) {
+      if (ids !== void 0 && !ids.has(node.id)) continue;
+      const look2 = edgeLook(trait, theme);
+      const stroke = look2.own.has("stroke") || data.stroke === void 0 ? void 0 : recolored(data.stroke, look2.stroke);
+      if (stroke !== void 0) out.set(node.id, { ...data, stroke });
+      continue;
+    }
+    if (trait !== null && "label" in trait) {
+      const edgeId = ownerOf(node);
+      const edgeTrait = edgeId === null ? null : traitOf(scene.get(edgeId)?.data);
+      if (edgeId === null || edgeTrait === null || ids !== void 0 && !ids.has(edgeId)) continue;
+      const look2 = edgeLook(edgeTrait, theme);
+      write(node.id, paintText(data, look2.own.has("text") ? void 0 : look2.label, themeLabelFamily(theme), look2.ownSize ? 0 : labelStep));
+      continue;
+    }
+    if (trait !== null && "offPageTag" in trait) {
+      const edgeId = ownerOf(node);
+      if (ids === void 0 || edgeId !== null && ids.has(edgeId)) write(node.id, paintTag(data, theme, labelStep));
+      continue;
+    }
+    if (trait !== null && "mark" in trait) continue;
+    const look = lookOf(node.id);
+    if (look !== null) {
+      if (ids === void 0 || ids.has(node.id)) write(node.id, paintBox(data, look));
+      continue;
+    }
+    const owner = ownerOf(node);
+    const ownerLook = owner === null ? null : lookOf(owner);
+    if (ownerLook === null || typeof data.text !== "string" || ids !== void 0 && !ids.has(owner)) continue;
+    write(node.id, paintText(data, ownerLook.own.has("text") ? void 0 : ownerLook.style.text, theme.font.family, ownerLook.ownSize ? 0 : step));
+  }
+  return out;
+}
+var CONTAINER_STENCILS = [
+  { id: "container", label: "Container", role: "container", size: { width: 240, height: 160 }, icon: (
+    /* @icon */
+    "diagram:container"
+  ) },
+  { id: "pool-rows", label: "Pool (rows)", role: "pool", axis: "y", size: { width: 480, height: 240 }, icon: (
+    /* @icon */
+    "diagram:poolRows"
+  ) },
+  { id: "pool-columns", label: "Pool (columns)", role: "pool", axis: "x", size: { width: 480, height: 300 }, icon: (
+    /* @icon */
+    "diagram:poolColumns"
+  ) }
+];
+var NEW_LANE_SIZE = 120;
+function placedBounds(stencil, b) {
+  if (b.width > 0 && b.height > 0) return { ...b };
+  const { width, height } = stencil.size;
+  return { x: b.x + b.width / 2 - width / 2, y: b.y + b.height / 2 - height / 2, width, height };
+}
+function containerBuild(stencil, bounds, opts) {
+  const id = opts.newId();
+  const axis = stencil.axis ?? "y";
+  const at = placedBounds(stencil, bounds);
+  const title = stencil.role === "pool" ? "Pool" : stencil.label;
+  const style = stencil.role === "pool" && opts.laneStyles ? opts.laneStyles.header : opts.style;
+  const specs = [
+    ...regionSpecs(stencil.role, axis, at, title, {
+      id,
+      layer: opts.layer,
+      parent: opts.parent ?? null,
+      ...style ? { style } : {}
+    }),
+    ...stencil.role === "pool" ? firstLanes(id, axis, at, opts) : []
+  ];
+  const label = `Insert ${stencil.label}`;
+  return { id, ops: specs.map((node) => createInsertOp({ node, label })) };
+}
+var poolAxisOf = (pool) => pool.header?.side === "top" ? "x" : "y";
+function lanesOf(scene, poolId) {
+  const pool = scene.get(poolId);
+  const trait = pool === void 0 ? null : diagramContainerOf(pool);
+  if (pool === void 0 || trait?.role !== "pool") return [];
+  const axis = poolAxisOf(trait);
+  const start = (id) => {
+    const p = scene.get(id).pose;
+    return axis === "y" ? p.y : p.x;
+  };
+  return scene.childrenOf(pool.id).filter((id) => diagramContainerOf(scene.get(id))?.role === "lane").sort((a, b) => start(a) - start(b));
+}
+function addLane(scene, poolId, index, style) {
+  const pool = scene.get(poolId);
+  const trait = pool === void 0 ? null : diagramContainerOf(pool);
+  if (pool === void 0 || trait?.role !== "pool") return null;
+  const axis = poolAxisOf(trait);
+  const lanes = lanesOf(scene, poolId);
+  const b = pool.pose;
+  const at = index === void 0 || index >= lanes.length ? null : scene.get(lanes[index]).pose;
+  const boundary = at !== null ? axis === "y" ? at.y : at.x : axis === "y" ? b.y + b.height : b.x + b.width;
+  const start = boundary - NEW_LANE_SIZE / 2;
+  const offset = trait.header?.size ?? 0;
+  const pose = axis === "y" ? { x: b.x + offset, y: start, width: b.width - offset, height: NEW_LANE_SIZE } : { x: start, y: b.y + offset, width: NEW_LANE_SIZE, height: b.height - offset };
+  const id = scene.mintId();
+  const specs = regionSpecs("lane", axis, pose, `Lane ${lanes.length + 1}`, {
+    id,
+    layer: pool.layer,
+    parent: poolId,
+    ...style ? { style } : {}
+  });
+  scene.batch("Add lane", () => {
+    for (const spec of specs) scene.add(spec);
+    if (style === void 0 && scene.doc.get(DIAGRAM_THEME_KEY) !== void 0) {
+      const writes = themeWrites(scene, diagramThemeOf(scene), /* @__PURE__ */ new Set([id]));
+      for (const [at2, data] of writes) scene.update(at2, { data });
+    }
+  });
+  return id;
+}
+function releasedFrom(scene, id) {
+  const parent = scene.get(id).parent;
+  const around = parent === null ? void 0 : scene.get(parent);
+  return around !== void 0 && diagramContainerOf(around)?.role === "pool" ? around.id : id;
+}
+function releaseMembers(scene, id) {
+  const node = scene.get(id);
+  const trait = node === void 0 ? null : diagramContainerOf(node);
+  if (node === void 0 || trait === null) return;
+  const membersOf2 = (c) => scene.childrenOf(c).filter((m) => m !== titleIdOf(c));
+  const members2 = trait.role === "pool" ? membersOf2(node.id).flatMap(membersOf2) : membersOf2(node.id);
+  const beside = releasedFrom(scene, node.id);
+  const parent = scene.get(beside).parent;
+  const index = (parent === null ? scene.roots : scene.childrenOf(parent)).indexOf(beside);
+  scene.batch("Release members", () => {
+    members2.forEach((m, k) => scene.move(m, parent, index + k));
+    scene.remove(node.id);
+  });
+}
+var LANE_LAYER_ID = "diagram-lanes";
+var LANE_AFFORDANCE_KIND = `layer:${LANE_LAYER_ID}`;
+function laneScratchOf(hit) {
+  const payload = hit?.payload;
+  return payload !== void 0 && typeof payload.poolId === "string" ? payload : null;
+}
+function poolsOf(scene) {
+  const out = [];
+  for (const node of scene.renderOrderNodes()) {
+    const trait = diagramContainerOf(node);
+    if (trait?.role !== "pool" || scene.isHidden(node.id) || scene.isLocked(node.id)) continue;
+    out.push({
+      id: node.id,
+      axis: poolAxisOf(trait),
+      pose: node.pose,
+      lanes: lanesOf(scene, node.id).map((id) => ({ id, pose: scene.get(id).pose }))
+    });
+  }
+  return out;
+}
+var DEFAULT_FILL = { paint: { kind: "solid", color: "#ffffff" } };
+var DEFAULT_STROKE = { paint: { kind: "solid", color: "#3b6fd4" }, width: 1.5 };
+var ADD_STANDOFF_PX = 14;
+function boundaryOf(axis, lane) {
+  const b = new PathBuilder();
+  return axis === "y" ? b.moveTo(lane.x, lane.y + lane.height).lineTo(lane.x + lane.width, lane.y + lane.height).build() : b.moveTo(lane.x + lane.width, lane.y).lineTo(lane.x + lane.width, lane.y + lane.height).build();
+}
+function addPaint(sizePx, fill, stroke) {
+  return {
+    kind: "custom",
+    draw: ({ world, view }) => {
+      const t = viewToTransform(view);
+      const cx = t.panX + world.x * t.zoom.x;
+      const cy = t.panY + world.y * t.zoom.y;
+      const r = sizePx / 2;
+      const arm = r * 0.55;
+      return [
+        { kind: "path", path: ellipsePath({ x: cx - r, y: cy - r, width: sizePx, height: sizePx }), fill, stroke },
+        { kind: "path", path: polylineFromPoints([{ x: cx - arm, y: cy }, { x: cx + arm, y: cy }]), stroke },
+        { kind: "path", path: polylineFromPoints([{ x: cx, y: cy - arm }, { x: cx, y: cy + arm }]), stroke }
+      ];
+    }
+  };
+}
+function createLaneAffordance(scene, opts = {}) {
+  const { hitRadiusPx = 4, addSizePx = 14 } = opts;
+  const fill = opts.fill ?? DEFAULT_FILL;
+  const stroke = opts.stroke ?? DEFAULT_STROKE;
+  return {
+    id: LANE_LAYER_ID,
+    regions(state) {
+      const out = [];
+      for (const pool of poolsOf(scene)) {
+        if (!paintsLayer(state, scene.get(pool.id).layer)) continue;
+        const cursor = pool.axis === "y" ? "row-resize" : "col-resize";
+        for (const lane of pool.lanes) {
+          out.push({
+            id: `${lane.id}:boundary`,
+            targetId: null,
+            shape: { kind: "outline", path: boundaryOf(pool.axis, lane.pose), hitRadiusPx },
+            cursor,
+            strength: "exclusive",
+            claimedKinds: ["pointer"],
+            bind: () => ({ initialScratch: { targetId: pool.id, poolId: pool.id, laneId: lane.id } })
+          });
+        }
+        if (addSizePx <= 0) continue;
+        const p = pool.pose;
+        const end = pool.axis === "y" ? { x: p.x + p.width / 2, y: p.y + p.height, normal: { x: 0, y: 1 } } : { x: p.x + p.width, y: p.y + p.height / 2, normal: { x: 1, y: 0 } };
+        out.push({
+          id: `${pool.id}:add-lane`,
+          targetId: null,
+          shape: { kind: "point", x: end.x, y: end.y, hitRadiusPx: addSizePx / 2 + 2, standoff: { px: ADD_STANDOFF_PX, normal: end.normal } },
+          paint: addPaint(addSizePx, fill, stroke),
+          cursor: "pointer",
+          strength: "exclusive",
+          claimedKinds: ["pointer"],
+          bind: () => ({ initialScratch: { targetId: pool.id, poolId: pool.id } })
+        });
+      }
+      return out;
+    }
+  };
+}
+function laneLayer(scene, opts = {}) {
+  return composeAffordanceLayer(LANE_LAYER_ID, "Diagram lanes", [createLaneAffordance(scene, opts)]);
+}
+var LANE_RESIZE_ACTION_ID = "diagram.resizeLane";
+var ADD_LANE_ACTION_ID = "diagram.addLane";
+var RELEASE_MEMBERS_ACTION_ID = "diagram.releaseMembers";
+var GRAB_LANE_ACTION_ID = "diagram.grabLane";
+function commitLaneResizeToScene(resize, ctx) {
+  const scene = ctx.deps.scene;
+  const pool = scene?.get(resize.poolId);
+  const lane = scene?.get(resize.laneId);
+  if (scene === void 0 || pool === void 0 || lane === void 0) return;
+  const axis = diagramContainerOf(pool)?.header?.side === "top" ? "x" : "y";
+  const l = lane.pose;
+  const p = pool.pose;
+  const d = resize.size - (axis === "y" ? l.height : l.width);
+  scene.batch("Resize lane", () => {
+    scene.setPose(lane.id, axis === "y" ? { ...l, height: resize.size } : { ...l, width: resize.size });
+    scene.setPose(pool.id, axis === "y" ? { ...p, height: p.height + d } : { ...p, width: p.width + d });
+  });
+}
+function laneResizeFrame(scene, pool, index, size) {
+  const { axis } = pool;
+  const along2 = (r) => axis === "y" ? r.height : r.width;
+  const grow = (r, by) => axis === "y" ? { ...r, height: r.height + by } : { ...r, width: r.width + by };
+  const shift = (r, by) => axis === "y" ? { ...r, y: r.y + by } : { ...r, x: r.x + by };
+  const lane = pool.lanes[index];
+  const d = size - along2(lane.pose);
+  const out = /* @__PURE__ */ new Map();
+  const placeTitle = (id, at) => {
+    const node = scene.get(id);
+    if (node !== void 0 && scene.get(titleIdOf(id)) !== void 0) {
+      out.set(titleIdOf(id), titlePose(at, diagramContainerOf(node)?.header));
+    }
+  };
+  const laneAt = grow(lane.pose, d);
+  out.set(lane.id, laneAt);
+  placeTitle(lane.id, laneAt);
+  const poolAt = grow(pool.pose, d);
+  out.set(pool.id, poolAt);
+  placeTitle(pool.id, poolAt);
+  for (const later of pool.lanes.slice(index + 1)) {
+    out.set(later.id, shift(later.pose, d));
+    const carried = carriedDescendants(sceneCarrySource(scene), later.id, (p) => shift(p, d));
+    for (const [id, p] of carried) out.set(id, p);
+  }
+  return out;
+}
+function createLaneResizeAction(opts) {
+  const commit = opts.commitResize ?? commitLaneResizeToScene;
+  return {
+    id: LANE_RESIZE_ACTION_ID,
+    label: "Resize lane",
+    group: "diagram",
+    requires: ["scene"],
+    invoker: {
+      timing: "ongoing",
+      start(ctx) {
+        const pressed = laneScratchOf(ctx.drag?.affordance);
+        const pool = poolsOf(opts.scene).find((p) => p.id === pressed?.poolId);
+        const index = pool?.lanes.findIndex((l) => l.id === pressed?.laneId) ?? -1;
+        if (pressed === null || pool === void 0 || index < 0) return {};
+        const lane = pool.lanes[index];
+        const start = pool.axis === "y" ? lane.pose.height : lane.pose.width;
+        const press = ctx.drag?.start ?? ctx.world;
+        const sizeAt = (at) => Math.max(MIN_LANE_SIZE, start + (pool.axis === "y" ? at.y - press.y : at.x - press.x));
+        let frame = null;
+        let open = true;
+        return {
+          kind: "diagram-resize-lane",
+          onMove(moveCtx) {
+            const size = sizeAt(moveCtx.world);
+            frame = size === start ? null : laneResizeFrame(opts.scene, pool, index, size);
+          },
+          previewIds: () => open && frame !== null ? [...frame.keys()] : null,
+          previewPose: (id) => open ? frame?.get(id) ?? null : null,
+          onEnd(endCtx, reason) {
+            open = false;
+            if (reason === "cancel") return;
+            const size = sizeAt(endCtx.world);
+            if (size !== start) commit({ poolId: pool.id, laneId: lane.id, size }, { ...endCtx, deps: ctx.deps });
+          }
+        };
+      }
+    },
+    enabled: () => true
+  };
+}
+var NO_MODIFIERS = { alt: false, shift: false, meta: false, ctrl: false };
+function createAddLaneAction(opts) {
+  const commit = opts.commitAddLane ?? ((poolId, ctx) => {
+    const scene = ctx.deps.scene;
+    if (scene !== void 0) addLane(scene, poolId);
+  });
+  return {
+    id: ADD_LANE_ACTION_ID,
+    label: "Add lane",
+    group: "diagram",
+    requires: ["scene"],
+    invoker: {
+      timing: "immediate",
+      run(deps, params) {
+        const pressed = laneScratchOf(params?.affordance);
+        if (pressed === null || pressed.laneId !== void 0) return;
+        const world = { x: Number(params?.worldX), y: Number(params?.worldY) };
+        commit(pressed.poolId, { world, modifiers: NO_MODIFIERS, deps });
+      }
+    },
+    enabled: () => true
+  };
+}
+var selectedContainers = (opts) => (opts.selected?.() ?? []).filter((id) => {
+  const node = opts.scene.get(id);
+  return node !== void 0 && diagramContainerOf(node) !== null;
+});
+function createReleaseMembersAction(opts) {
+  return {
+    id: RELEASE_MEMBERS_ACTION_ID,
+    label: "Release members",
+    group: "diagram",
+    requires: ["scene"],
+    invoker: {
+      timing: "immediate",
+      run() {
+        const ids = selectedContainers(opts);
+        if (ids.length === 0) return;
+        const commit = opts.commitRelease;
+        if (commit !== void 0) {
+          for (const id of ids) commit(id);
+          return;
+        }
+        opts.scene.batch("Release members", () => {
+          for (const id of ids) releaseMembers(opts.scene, id);
+        });
+      }
+    },
+    enabled: () => selectedContainers(opts).length > 0 ? true : ActionDisabledReason.NotApplicable
+  };
+}
+function diagramContainers(opts) {
+  const target = `affordance:${LANE_AFFORDANCE_KIND}`;
+  return {
+    layer: laneLayer(opts.scene, opts),
+    contribution: {
+      id: "weasel-diagram-containers",
+      eligibility: { claimed: true },
+      actions: [
+        createLaneResizeAction(opts),
+        createAddLaneAction(opts),
+        createReleaseMembersAction(opts),
+        grabPortAction(GRAB_LANE_ACTION_ID)
+      ],
+      bindings: [
+        { spec: { kind: "drag", target }, actionId: LANE_RESIZE_ACTION_ID },
+        { spec: { kind: "click", target }, actionId: ADD_LANE_ACTION_ID },
+        ...grabPortBindings(GRAB_LANE_ACTION_ID, LANE_AFFORDANCE_KIND).filter((b) => b.spec.kind !== "click")
+      ]
+    }
+  };
+}
+var EDIT_CONTAINER_TITLE_ACTION_ID = "diagram.editContainerTitle";
+function regionHeaderAt(deps, at) {
+  if (deps === void 0 || at === void 0) return null;
+  const scene = deps.scene;
+  for (let id = deps.nodeAtPoint?.(at) ?? null; id != null && scene !== void 0; id = scene.get(id)?.parent ?? null) {
+    const node = scene.get(id);
+    const trait = node === void 0 ? null : diagramContainerOf(node);
+    if (node === void 0 || trait === null) continue;
+    const h = headerBox(node.pose, trait.header);
+    if (h !== null && at.x >= h.x && at.x <= h.x + h.width && at.y >= h.y && at.y <= h.y + h.height) return id;
+  }
+  return null;
+}
+function editContainerTitleAction(commit) {
+  return {
+    id: EDIT_CONTAINER_TITLE_ACTION_ID,
+    label: "Edit container title",
+    group: "diagram",
+    requires: ["scene", "nodeAtPoint"],
+    eligible: { mode: { in: ["normal", "isolation"] } },
+    invoker: {
+      timing: "immediate",
+      run(deps, params) {
+        const id = regionHeaderAt(deps, { x: Number(params?.worldX), y: Number(params?.worldY) });
+        if (id !== null) commit(id);
+      }
+    },
+    enabled: (deps, at) => regionHeaderAt(deps, at) !== null ? true : ActionDisabledReason.NotApplicable
+  };
+}
+var onBody = bodyPredicate((target) => target === "selected-body" || target === "unselected-body");
+function editContainerTitleBinding() {
+  return { spec: { kind: "doubleClick", target: { kindOf: onBody } }, actionId: EDIT_CONTAINER_TITLE_ACTION_ID };
+}
+
+// src/hops/hopsAction.ts
+var SET_HOPS_ACTION_ID = "diagram.hops";
+function createSetHopsAction(opts = {}) {
+  const size = opts.size ?? DEFAULT_HOP_SIZE;
+  return {
+    id: SET_HOPS_ACTION_ID,
+    label: "Line jumps",
+    group: "diagram",
+    requires: ["scene"],
+    invoker: {
+      timing: "immediate",
+      run(deps) {
+        const doc = deps.scene?.doc;
+        doc?.set(HOPS_DOC_KEY, doc.get(HOPS_DOC_KEY) === void 0 ? { size } : void 0);
+      }
+    },
+    active: (deps) => deps?.scene?.doc.get(HOPS_DOC_KEY) !== void 0
+  };
+}
+var MOVE_LABEL_ACTION_ID = "diagram.moveLabel";
+var placementAt = (spot) => ({ at: spot.at, offset: spot.offset, dodge: false });
+function placedData(data, placement) {
+  const record = data;
+  return { ...record, diagram: { ...record.diagram, label: placement } };
+}
+function movedLabelData(data, spot) {
+  return placedData(data, placementAt(spot));
+}
+function commitLabelToScene(edit, ctx) {
+  const scene = ctx.deps.scene;
+  const node = scene?.get(edit.labelId);
+  if (scene === void 0 || node === void 0 || diagramLabelOf(node) === null) return;
+  const placement = edit.placement ?? LABEL_PLACEMENT;
+  scene.batch(edit.placement === null ? "Reset label" : "Move label", () => {
+    scene.update(node.id, { data: placedData(node.data, placement) });
+  });
+}
+function pressOf(ctx) {
+  const pressed = labelScratchOf(ctx.drag?.affordance);
+  const scene = ctx.deps.scene;
+  const node = pressed === null ? void 0 : scene?.get(pressed.labelId);
+  if (pressed === null || scene === void 0 || node === void 0 || diagramLabelOf(node) === null) return null;
+  const path = documentDepOf(scene, pressed.edgeId)?.path ?? null;
+  if (path === null) return null;
+  const pose = effectivePose(scene, node);
+  const box = AUTO_POSE_DESCRIPTOR.getBounds(pose);
+  const center2 = { x: box.x + box.width / 2, y: box.y + box.height / 2 };
+  const press = ctx.drag?.start ?? { x: ctx.world.x, y: ctx.world.y };
+  return {
+    labelId: pressed.labelId,
+    edgeId: pressed.edgeId,
+    data: node.data,
+    pose,
+    path,
+    center: center2,
+    size: { width: box.width, height: box.height },
+    grab: { x: center2.x - press.x, y: center2.y - press.y },
+    deps: ctx.deps
+  };
+}
+var spotAt = (p, ctx) => labelSpotAt(p.path, { x: ctx.world.x + p.grab.x, y: ctx.world.y + p.grab.y }, p.size);
+function poseAt(p, spot) {
+  const c = labelCenter(p.path, placementAt(spot), p.size);
+  return c === null ? p.pose : translatePoseViaDescriptor(p.pose, c.x - p.center.x, c.y - p.center.y, AUTO_POSE_DESCRIPTOR);
+}
+function createLabelDragAction(opts = {}) {
+  const { commit = commitLabelToScene } = opts;
+  return {
+    id: opts.id ?? MOVE_LABEL_ACTION_ID,
+    label: "Move label",
+    group: "diagram",
+    requires: ["scene"],
+    eligible: { mode: { in: ["normal", "isolation"] } },
+    invoker: {
+      timing: "ongoing",
+      start(ctx) {
+        const p = pressOf(ctx);
+        if (p === null) return {};
+        let spot = null;
+        let open = true;
+        const proposed = () => open ? spot : null;
+        return {
+          kind: "diagram-move-label",
+          onMove(moveCtx) {
+            spot = spotAt(p, moveCtx);
+          },
+          previewIds: () => proposed() === null ? null : [p.labelId],
+          previewPose: (id) => {
+            const next = proposed();
+            return id === p.labelId && next !== null ? poseAt(p, next) : null;
+          },
+          previewData: (id) => {
+            const next = proposed();
+            return id === p.labelId && next !== null ? movedLabelData(p.data, next) : null;
+          },
+          onEnd(endCtx, reason) {
+            open = false;
+            const final = reason === "commit" && spot !== null ? spotAt(p, endCtx) ?? spot : null;
+            if (final !== null) {
+              commit({ labelId: p.labelId, edgeId: p.edgeId, placement: placementAt(final) }, { ...endCtx, deps: p.deps });
+            }
+          }
+        };
+      }
+    },
+    enabled: () => true
+  };
+}
+var RESET_LABEL_ACTION_ID = "diagram.resetLabel";
+var NO_MODIFIERS2 = { alt: false, shift: false, meta: false, ctrl: false };
+function draggedLabels(scene, selected) {
+  if (scene === void 0 || selected.length === 0) return [];
+  const out = [];
+  for (const { labelId, edgeId, label } of editableLabels(scene, new Set(selected))) {
+    if (label.dodge === false) out.push({ labelId, edgeId, placement: null });
+  }
+  return out;
+}
+function createResetLabelAction(opts) {
+  const { commit = commitLabelToScene } = opts;
+  return {
+    id: RESET_LABEL_ACTION_ID,
+    label: "Reset label",
+    group: "diagram",
+    requires: ["scene"],
+    invoker: {
+      timing: "immediate",
+      run(deps) {
+        const edits = draggedLabels(deps.scene, opts.selected());
+        const ctx = { world: { x: 0, y: 0 }, modifiers: NO_MODIFIERS2, deps };
+        const all = () => {
+          for (const edit of edits) commit(edit, ctx);
+        };
+        if (deps.scene === void 0) all();
+        else deps.scene.batch("Reset label", all);
+      }
+    },
+    enabled: (deps) => draggedLabels(deps?.scene, opts.selected()).length > 0 ? true : ActionDisabledReason.NotApplicable
+  };
+}
+function sceneParticipants(scene) {
+  return function* () {
+    const gates = nodeGates(scene);
+    for (const node of scene.renderOrderNodes()) {
+      const hidden = gates.hidden(node.id);
+      const locked = gates.locked(node.id);
+      yield {
+        node,
+        pose: effectivePose(scene, node),
+        ...node.layer !== void 0 ? { layer: node.layer } : {},
+        ...hidden ? { hidden } : {},
+        ...locked ? { locked } : {}
+      };
+    }
+  };
+}
+function portLayer(participants, opts = {}) {
+  return composeAffordanceLayer(
+    opts.id ?? PORT_LAYER_ID,
+    "Diagram ports",
+    [createPortAffordance(participants, opts)]
+  );
+}
+var EDGE_END_LAYER_ID = "diagram-edge-ends";
+var EDGE_END_AFFORDANCE_KIND = `layer:${EDGE_END_LAYER_ID}`;
+function edgeEndScratchOf(hit) {
+  const payload = hit?.payload;
+  return payload !== void 0 && typeof payload.edgeId === "string" && (payload.end === "from" || payload.end === "to") ? payload : null;
+}
+function createEdgeEnds(participants, opts = {}) {
+  const derive = edgeRouter({
+    ...opts.geometry ? { geometry: opts.geometry } : {},
+    ...opts.read ? { read: opts.read } : {},
+    ...opts.routers ? { routers: opts.routers } : {}
+  });
+  return function endsOf(edgeId) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const p2 of participants()) byId.set(p2.node.id, p2);
+    const edge = byId.get(edgeId);
+    if (edge === void 0) return null;
+    const trait = diagramEdgeOf(edge.node);
+    const deps = edge.node.dependsOn;
+    if (trait === null || !Array.isArray(deps) || deps.length !== 2) return null;
+    const from = byId.get(deps[0]);
+    const to = byId.get(deps[1]);
+    if (from === void 0 || to === void 0) return null;
+    const dep = (p2) => ({ node: p2.node, pose: p2.pose });
+    const route = derive(edge.node, [dep(from), dep(to)]);
+    const p = route?.points;
+    if (route === null || p === void 0 || p.length < 2) return null;
+    return { edge, trait, from, to, points: { from: p[0], to: p[p.length - 1] }, route };
+  };
+}
+var DEFAULT_HIT_PX2 = 8;
+var DEFAULT_SIZE_PX2 = 8;
+function createEdgeEndAffordance(participants, selected, opts = {}) {
+  const { id = EDGE_END_LAYER_ID, hitRadiusPx = DEFAULT_HIT_PX2, sizePx = DEFAULT_SIZE_PX2 } = opts;
+  const endsOf = createEdgeEnds(participants, opts);
+  const look = { ...opts.fill ? { fill: opts.fill } : {}, ...opts.stroke ? { stroke: opts.stroke } : {} };
+  const paint = sizePx > 0 ? { paint: { kind: "square", sizePx, ...look } } : {};
+  return {
+    id,
+    regions(state) {
+      const out = [];
+      for (const edgeId of selected()) {
+        const ends = endsOf(edgeId);
+        if (ends === null || !offersPorts(ends.edge, state)) continue;
+        for (const end of ["from", "to"]) {
+          const at = ends.points[end];
+          out.push({
+            id: `${edgeId}:${end}`,
+            targetId: null,
+            shape: { kind: "point", x: at.x, y: at.y, hitRadiusPx },
+            ...paint,
+            ...opts.cursor !== void 0 ? { cursor: opts.cursor } : {},
+            strength: "exclusive",
+            claimedKinds: ["pointer"],
+            bind: () => ({ initialScratch: { targetId: edgeId, edgeId, end } })
+          });
+        }
+      }
+      return out;
+    }
+  };
+}
+function edgeEndLayer(participants, selected, opts = {}) {
+  return composeAffordanceLayer(
+    opts.id ?? EDGE_END_LAYER_ID,
+    "Diagram edge ends",
+    [createEdgeEndAffordance(participants, selected, opts)]
+  );
+}
+
+// src/waypoints.ts
+var EPS = 1e-6;
+var JOG = 16;
+var same = (a, b) => Math.abs(a.x - b.x) <= EPS && Math.abs(a.y - b.y) <= EPS;
+function segmentAxis(a, b) {
+  if (same(a, b)) return null;
+  if (Math.abs(a.y - b.y) <= EPS) return "x";
+  if (Math.abs(a.x - b.x) <= EPS) return "y";
+  return null;
+}
+function stopIndices(drawn, stops) {
+  const out = [];
+  let from = 0;
+  for (const stop of stops) {
+    let i = from;
+    while (i < drawn.length && !same(drawn[i], stop)) i++;
+    if (i === drawn.length) return null;
+    out.push(i);
+    from = i;
+  }
+  return out;
+}
+function middleOf(drawn, a, b) {
+  let total = 0;
+  for (let i = a; i < b; i++) total += Math.hypot(drawn[i + 1].x - drawn[i].x, drawn[i + 1].y - drawn[i].y);
+  let left = total / 2;
+  for (let i = a; i < b; i++) {
+    const p = drawn[i];
+    const q = drawn[i + 1];
+    const len = Math.hypot(q.x - p.x, q.y - p.y);
+    if (len >= left && len > 0) return { x: p.x + (q.x - p.x) * left / len, y: p.y + (q.y - p.y) * left / len };
+    left -= len;
+  }
+  return drawn[a];
+}
+function routeHandles(drawn, stops, router) {
+  if (router === orthogonal || router === avoid) {
+    const out2 = [];
+    for (let i = 0; i + 1 < drawn.length; i++) {
+      const a = drawn[i];
+      const b = drawn[i + 1];
+      const axis = segmentAxis(a, b);
+      if (axis !== null) out2.push({ kind: "segment", index: i, axis, at: { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 } });
+    }
+    return out2;
+  }
+  const out = [];
+  for (let k = 1; k + 1 < stops.length; k++) out.push({ kind: "vertex", index: k - 1, at: stops[k] });
+  const at = stopIndices(drawn, stops);
+  for (let leg = 0; leg + 1 < stops.length; leg++) {
+    const a = stops[leg];
+    const b = stops[leg + 1];
+    out.push({
+      kind: "insert",
+      leg,
+      at: at === null ? { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 } : middleOf(drawn, at[leg], at[leg + 1])
+    });
+  }
+  return out;
+}
+var interior = (stops) => stops.slice(1, -1).map((p) => ({ x: p.x, y: p.y }));
+function dragVertex(stops, index, to) {
+  const out = interior(stops);
+  out[index] = { x: to.x, y: to.y };
+  return out;
+}
+function insertWaypoint(stops, leg, at) {
+  const out = interior(stops);
+  out.splice(leg, 0, { x: at.x, y: at.y });
+  return out;
+}
+function removeWaypoint(stops, index) {
+  const out = interior(stops);
+  out.splice(index, 1);
+  return out;
+}
+var shifted = (p, axis, offset) => axis === "x" ? { x: p.x, y: p.y + offset } : { x: p.x + offset, y: p.y };
+function toward(a, b, distance) {
+  const len = Math.hypot(b.x - a.x, b.y - a.y);
+  return len === 0 ? a : { x: a.x + (b.x - a.x) * distance / len, y: a.y + (b.y - a.y) * distance / len };
+}
+function dragSegment(drawn, index, offset) {
+  const a = drawn[index];
+  const b = drawn[index + 1];
+  const axis = segmentAxis(a, b);
+  if (axis === null) return interior(drawn);
+  const jog = Math.min(JOG, Math.hypot(b.x - a.x, b.y - a.y) / 2);
+  const start = index === 0 ? toward(a, b, jog) : null;
+  const end = index === drawn.length - 2 ? toward(b, a, jog) : null;
+  const route = [
+    ...drawn.slice(0, index),
+    ...start === null ? [] : [a, start],
+    shifted(start ?? a, axis, offset),
+    shifted(end ?? b, axis, offset),
+    ...end === null ? [] : [end, b],
+    ...drawn.slice(index + 2)
+  ];
+  return interior(simplifyStops(route));
+}
+function pinSegment(drawn, stops, index, offset) {
+  const a = drawn[index];
+  const b = drawn[index + 1];
+  const axis = segmentAxis(a, b);
+  const waypoints = interior(stops);
+  if (axis === null) return waypoints;
+  const jog = Math.min(JOG, Math.hypot(b.x - a.x, b.y - a.y) / 2);
+  const start = index === 0 ? toward(a, b, jog) : a;
+  const end = index === drawn.length - 2 ? toward(b, a, jog) : b;
+  const at = waypoints.map((w) => drawn.findIndex((p) => same(p, w)));
+  const before = waypoints.filter((w, k) => at[k] >= 0 && at[k] <= index && !same(w, a));
+  const after = waypoints.filter((w, k) => (at[k] < 0 || at[k] > index) && !same(w, b));
+  return [...before, shifted(start, axis, offset), shifted(end, axis, offset), ...after];
+}
+function unpinSegment(drawn, stops, index) {
+  const ends = [drawn[index], drawn[index + 1]];
+  const waypoints = interior(stops);
+  const kept = waypoints.filter((w) => !ends.some((e) => same(e, w)));
+  return kept.length === waypoints.length ? null : kept;
+}
+function removeSegment(drawn, index) {
+  const last = drawn.length - 2;
+  if (index <= 0 || index >= last) return null;
+  const axis = segmentAxis(drawn[index], drawn[index + 1]);
+  if (axis === null) return null;
+  const across = (p) => axis === "x" ? p.x : p.y;
+  const prev = index - 1;
+  const next = index + 1;
+  if (next < last) return dragSegment(drawn, next, across(drawn[index]) - across(drawn[index + 1]));
+  if (prev > 0) return dragSegment(drawn, prev, across(drawn[index + 1]) - across(drawn[index]));
+  return null;
+}
+var WAYPOINT_LAYER_ID = "diagram-waypoints";
+var WAYPOINT_AFFORDANCE_KIND = `layer:${WAYPOINT_LAYER_ID}`;
+function waypointScratchOf(hit) {
+  const payload = hit?.payload;
+  return payload !== void 0 && typeof payload.edgeId === "string" && typeof payload.handle?.kind === "string" ? payload : null;
+}
+function routeStateOf(ends, routers) {
+  const { route } = ends;
+  const stops = [route.from.point, ...route.waypoints, route.to.point];
+  const router = routerOf(ends.trait, routers);
+  const handles = route.stubs !== void 0 ? [] : routeHandles(route.points, stops, router);
+  return { from: route.from, to: route.to, stops, drawn: route.points, router, handles };
+}
+var WAYPOINT_HIT_PX = 7;
+var DEFAULT_SIZE_PX3 = 8;
+var DEFAULT_FILL2 = { paint: { kind: "solid", color: "#ffffff" } };
+var DEFAULT_STROKE2 = { paint: { kind: "solid", color: "#3b6fd4" }, width: 1.5 };
+function paintOf(handle, sizePx, fill, stroke) {
+  return {
+    kind: "custom",
+    draw: ({ world, view }) => {
+      const t = viewToTransform(view);
+      const cx = t.panX + world.x * t.zoom.x;
+      const cy = t.panY + world.y * t.zoom.y;
+      if (handle.kind === "segment") {
+        const [w, h] = handle.axis === "x" ? [sizePx * 2, sizePx / 2] : [sizePx / 2, sizePx * 2];
+        return [{ kind: "path", path: { kind: "rect", x: cx - w / 2, y: cy - h / 2, width: w, height: h }, fill, stroke }];
+      }
+      const d = handle.kind === "vertex" ? sizePx : sizePx * 0.75;
+      const path = ellipsePath({ x: cx - d / 2, y: cy - d / 2, width: d, height: d });
+      return [handle.kind === "vertex" ? { kind: "path", path, fill, stroke } : { kind: "path", path, stroke }];
+    }
+  };
+}
+function createWaypointAffordance(participants, selected, opts = {}) {
+  const { id = WAYPOINT_LAYER_ID, hitRadiusPx = WAYPOINT_HIT_PX, sizePx = DEFAULT_SIZE_PX3 } = opts;
+  const endsOf = createEdgeEnds(participants, opts);
+  const fill = opts.fill ?? DEFAULT_FILL2;
+  const stroke = opts.stroke ?? DEFAULT_STROKE2;
+  return {
+    id,
+    regions(state) {
+      const out = [];
+      for (const edgeId of selected()) {
+        const ends = endsOf(edgeId);
+        if (ends === null || !offersPorts(ends.edge, state)) continue;
+        for (const handle of routeStateOf(ends, opts.routers).handles) {
+          out.push({
+            id: `${edgeId}:${handle.kind}:${handle.kind === "insert" ? handle.leg : handle.index}`,
+            targetId: null,
+            shape: { kind: "point", x: handle.at.x, y: handle.at.y, hitRadiusPx },
+            ...sizePx > 0 ? { paint: paintOf(handle, sizePx, fill, stroke) } : {},
+            ...opts.cursor !== void 0 ? { cursor: opts.cursor } : {},
+            strength: "exclusive",
+            claimedKinds: ["pointer"],
+            bind: () => ({ initialScratch: { targetId: edgeId, edgeId, handle } })
+          });
+        }
+      }
+      return out;
+    }
+  };
+}
+function waypointLayer(participants, selected, opts = {}) {
+  return composeAffordanceLayer(
+    opts.id ?? WAYPOINT_LAYER_ID,
+    "Diagram waypoints",
+    [createWaypointAffordance(participants, selected, opts)]
+  );
+}
+
+// src/routeSnapSource.ts
+var BOTH = ["x", "y"];
+var ALONG = { x: { x: 0, y: 1 }, y: { x: 1, y: 0 } };
+function portAxes(port) {
+  const n = port.normal;
+  if (n === null) return BOTH;
+  return Math.abs(n.x) >= Math.abs(n.y) ? ["y"] : ["x"];
+}
+function routeSnapSource(opts) {
+  const targets = [
+    ...opts.stops.map((at) => ({ at, axes: BOTH })),
+    ...opts.ports.map((p) => ({ at: p.point, axes: portAxes(p) }))
+  ];
+  return {
+    id: opts.id,
+    tier: "target",
+    reachPx: opts.reachPx,
+    roles: ["pointer"],
+    gestures: ["point"],
+    *collect(q) {
+      const reach = q.reachWorld(q.reachPx);
+      for (const p of q.probes) {
+        for (const t of targets) {
+          for (const axis of t.axes) {
+            if (Math.abs(p.at[axis] - t.at[axis]) > reach) continue;
+            yield {
+              probe: p.id,
+              locus: { at: { ...p.at, [axis]: t.at[axis] }, dirs: [ALONG[axis]] },
+              mark: (delta) => ({
+                kind: "line",
+                from: t.at,
+                to: { x: p.at.x - q.delta0.x + delta.x, y: p.at.y - q.delta0.y + delta.y }
+              })
+            };
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/waypointAction.ts
+var ROUTE_EDIT_ACTION_ID = "diagram.editRoute";
+var DEFAULT_SNAP_PX = 6;
+var ROUTE_SNAP_ID = "diagram-route";
+function routedData(data, trait, waypoints) {
+  const { waypoints: _w, laidOut: _l, ...rest } = trait;
+  return { ...data, diagram: waypoints.length > 0 ? { ...rest, waypoints } : rest };
+}
+function commitRouteToScene(edit, ctx) {
+  const scene = ctx.deps.scene;
+  const node = scene?.get(edit.edgeId);
+  const trait = node === void 0 ? null : diagramEdgeOf(node);
+  if (scene === void 0 || node === void 0 || trait === null) return;
+  scene.batch("Edit route", () => {
+    scene.update(node.id, { data: routedData(node.data, trait, edit.waypoints) });
+  });
+}
+function beginSnap(ctx, p, reachPx) {
+  const { handle, route } = p;
+  const segment = handle.kind === "segment";
+  const stops = segment ? route.drawn.filter((_, i) => i !== handle.index && i !== handle.index + 1) : neighborsOf(handle, route.stops);
+  const source = routeSnapSource({ id: ROUTE_SNAP_ID, stops, ports: segment ? [] : [route.from, route.to], reachPx });
+  return ctx.deps.snap?.begin({
+    gesture: "point",
+    press: handle.at,
+    ids: [p.edgeId],
+    omit: ["path-snap"],
+    sources: [source],
+    ...segment ? { handle: handle.axis === "x" ? { x: "free", y: "min" } : { x: "min", y: "free" } } : { constrain: "axis" }
+  }) ?? null;
+}
+function neighborsOf(handle, stops) {
+  const at = handle.kind === "vertex" ? handle.index + 1 : handle.leg + 1;
+  return [stops[at - 1], stops[handle.kind === "vertex" ? at + 1 : at]];
+}
+function moveOf(p, session, ctx) {
+  const d = { x: ctx.world.x - p.press.x, y: ctx.world.y - p.press.y };
+  if (session === null) return d;
+  const at = session.at({ x: p.handle.at.x + d.x, y: p.handle.at.y + d.y }, snapMods(ctx)).point;
+  return { x: at.x - p.handle.at.x, y: at.y - p.handle.at.y };
+}
+function waypointsAt(p, d) {
+  if (d.x === 0 && d.y === 0) return null;
+  const { handle, route } = p;
+  let next;
+  if (handle.kind === "segment") {
+    const across = handle.axis === "x" ? "y" : "x";
+    const offset = d[across];
+    next = route.router === avoid ? pinSegment(route.drawn, route.stops, handle.index, offset) : dragSegment(route.drawn, handle.index, offset);
+  } else {
+    const point = { x: handle.at.x + d.x, y: handle.at.y + d.y };
+    next = handle.kind === "vertex" ? dragVertex(route.stops, handle.index, point) : insertWaypoint(route.stops, handle.leg, point);
+  }
+  return samePoints(next, p.trait.waypoints ?? []) ? null : next;
+}
+function createRouteEditAction(opts) {
+  const { commit = commitRouteToScene, snapPx = DEFAULT_SNAP_PX } = opts;
+  const endsOf = createEdgeEnds(opts.participants, opts);
+  return {
+    id: opts.id ?? ROUTE_EDIT_ACTION_ID,
+    label: "Edit route",
+    group: "diagram",
+    requires: ["scene", "view", "snap"],
+    modifierRoles: SNAP_ROLES,
+    invoker: {
+      timing: "ongoing",
+      start(ctx) {
+        const pressed = waypointScratchOf(ctx.drag?.affordance);
+        const ends = pressed === null ? null : endsOf(pressed.edgeId);
+        if (pressed === null || ends === null) return {};
+        const p = {
+          edgeId: pressed.edgeId,
+          handle: pressed.handle,
+          route: routeStateOf(ends, opts.routers),
+          trait: ends.trait,
+          data: ends.edge.node.data,
+          pose: ends.edge.pose,
+          press: ctx.drag?.start ?? { x: ctx.world.x, y: ctx.world.y },
+          deps: ctx.deps
+        };
+        const session = beginSnap(ctx, p, snapPx);
+        let waypoints = null;
+        let open = true;
+        const proposed = () => open ? waypoints : null;
+        return {
+          kind: "diagram-edit-route",
+          onMove(moveCtx) {
+            waypoints = waypointsAt(p, moveOf(p, session, moveCtx));
+          },
+          previewIds: () => proposed() === null ? null : [p.edgeId],
+          previewPose: (id) => id === p.edgeId && proposed() !== null ? p.pose : null,
+          previewData: (id) => {
+            const next = proposed();
+            return id === p.edgeId && next !== null ? routedData(p.data, p.trait, next) : null;
+          },
+          onEnd(endCtx, reason) {
+            open = false;
+            const final = reason === "commit" ? waypointsAt(p, moveOf(p, session, endCtx)) : null;
+            session?.end();
+            if (final !== null) commit({ edgeId: p.edgeId, waypoints: final }, { ...endCtx, deps: p.deps });
+          }
+        };
+      }
+    },
+    enabled: () => true
+  };
+}
+var REMOVE_WAYPOINT_ACTION_ID = "diagram.removeWaypoint";
+var RESET_ROUTE_ACTION_ID = "diagram.resetRoute";
+var NO_MODIFIERS3 = { alt: false, shift: false, meta: false, ctrl: false };
+function removalOf(route, handle) {
+  if (handle.kind === "vertex") return removeWaypoint(route.stops, handle.index);
+  if (handle.kind === "segment") {
+    return route.router === avoid ? unpinSegment(route.drawn, route.stops, handle.index) : removeSegment(route.drawn, handle.index);
+  }
+  return null;
+}
+function createRemoveWaypointAction(opts) {
+  const { commit = commitRouteToScene, hitRadiusPx = WAYPOINT_HIT_PX } = opts;
+  const endsOf = createEdgeEnds(opts.participants, opts);
+  const routeOf3 = (edgeId) => {
+    const ends = endsOf(edgeId);
+    return ends === null ? null : routeStateOf(ends, opts.routers);
+  };
+  const removalAt = (deps, at) => {
+    const reach = hitRadiusPx / Math.abs(deps?.view?.get().scale.x || 1);
+    for (const edgeId of opts.selected()) {
+      const route = routeOf3(edgeId);
+      for (const handle of route?.handles ?? []) {
+        if (Math.max(Math.abs(handle.at.x - at.x), Math.abs(handle.at.y - at.y)) > reach) continue;
+        const waypoints = removalOf(route, handle);
+        if (waypoints !== null) return { edgeId, waypoints };
+      }
+    }
+    return null;
+  };
+  return {
+    id: REMOVE_WAYPOINT_ACTION_ID,
+    label: "Remove waypoint",
+    group: "diagram",
+    requires: ["scene", "view"],
+    invoker: {
+      timing: "immediate",
+      run(deps, params) {
+        const world = { x: Number(params?.worldX), y: Number(params?.worldY) };
+        const pressed = waypointScratchOf(params?.affordance);
+        const route = pressed === null ? null : routeOf3(pressed.edgeId);
+        const waypoints = pressed === null || route === null ? null : removalOf(route, pressed.handle);
+        const edit = pressed !== null && waypoints !== null ? { edgeId: pressed.edgeId, waypoints } : removalAt(deps, world);
+        if (edit !== null) commit(edit, { world, modifiers: NO_MODIFIERS3, deps });
+      }
+    },
+    enabled: (deps, at) => at !== void 0 && removalAt(deps, at) !== null ? true : ActionDisabledReason.NotApplicable
+  };
+}
+function routedEdges(opts) {
+  const ids = new Set(opts.selected());
+  if (ids.size === 0) return [];
+  const out = [];
+  for (const { node } of opts.participants()) {
+    if (ids.has(node.id) && (diagramEdgeOf(node)?.waypoints ?? []).length > 0) out.push(node.id);
+  }
+  return out;
+}
+function createResetRouteAction(opts) {
+  const { commit = commitRouteToScene } = opts;
+  return {
+    id: RESET_ROUTE_ACTION_ID,
+    label: "Reset route",
+    group: "diagram",
+    requires: ["scene"],
+    invoker: {
+      timing: "immediate",
+      run(deps) {
+        const edges = routedEdges(opts);
+        const ctx = { world: { x: 0, y: 0 }, modifiers: NO_MODIFIERS3, deps };
+        const all = () => {
+          for (const edgeId of edges) commit({ edgeId, waypoints: [] }, ctx);
+        };
+        if (deps.scene === void 0) all();
+        else deps.scene.batch("Reset route", all);
+      }
+    },
+    enabled: () => routedEdges(opts).length > 0 ? true : ActionDisabledReason.NotApplicable
+  };
+}
+var SET_ROUTER_ACTION_IDS = {
+  avoid: "diagram.router.avoid",
+  orthogonal: "diagram.router.orthogonal",
+  straight: "diagram.router.straight",
+  bezier: "diagram.router.bezier"
+};
+var ROUTER_LABELS = {
+  avoid: "Around shapes",
+  orthogonal: "Orthogonal",
+  straight: "Straight",
+  bezier: "Curved"
+};
+function withRouter(data, trait, router) {
+  const { route: _r, ...rest } = trait;
+  return { ...data, diagram: { ...rest, router } };
+}
+function commitRouterToScene(edit, ctx) {
+  const scene = ctx.deps.scene;
+  const node = scene?.get(edit.edgeId);
+  const trait = node === void 0 ? null : diagramEdgeOf(node);
+  if (scene === void 0 || node === void 0 || trait === null) return;
+  scene.update(node.id, { data: withRouter(node.data, trait, edit.router) });
+}
+function selectedEdges(opts) {
+  const ids = new Set(opts.selected());
+  if (ids.size === 0) return [];
+  const out = [];
+  for (const { node } of opts.participants()) {
+    const trait = ids.has(node.id) ? diagramEdgeOf(node) : null;
+    if (trait !== null) out.push({ id: node.id, router: trait.router ?? "straight" });
+  }
+  return out;
+}
+var NO_MODIFIERS4 = { alt: false, shift: false, meta: false, ctrl: false };
+function createSetRouterAction(router, opts) {
+  const { commit = commitRouterToScene } = opts;
+  return {
+    id: SET_ROUTER_ACTION_IDS[router],
+    label: ROUTER_LABELS[router],
+    group: "diagram",
+    requires: ["scene"],
+    invoker: {
+      timing: "immediate",
+      run(deps) {
+        const edges = selectedEdges(opts).filter((e) => e.router !== router);
+        const ctx = { world: { x: 0, y: 0 }, modifiers: NO_MODIFIERS4, deps };
+        const all = () => {
+          for (const e of edges) commit({ edgeId: e.id, router }, ctx);
+        };
+        if (deps.scene === void 0) all();
+        else deps.scene.batch(`Route ${ROUTER_LABELS[router].toLowerCase()}`, all);
+      }
+    },
+    enabled: () => selectedEdges(opts).length > 0 ? true : ActionDisabledReason.NotApplicable,
+    active: () => {
+      const edges = selectedEdges(opts);
+      return edges.length > 0 && edges.every((e) => e.router === router);
+    }
+  };
+}
+function routerActions(opts) {
+  return Object.keys(SET_ROUTER_ACTION_IDS).map((r) => createSetRouterAction(r, opts));
+}
+function createDiagramContribution(opts) {
+  const actionId = opts.id ?? CONNECT_ACTION_ID;
+  return {
+    id: "weasel-diagram",
+    eligibility: { claimed: true },
+    actions: [createConnectAction({ ...opts, id: actionId }), grabPortAction()],
+    bindings: [connectBinding(actionId), ...grabPortBindings()]
+  };
+}
+function diagramPorts(opts) {
+  return {
+    layer: portLayer(opts.participants, opts),
+    contribution: createDiagramContribution(opts)
+  };
+}
+var GRAB_WAYPOINT_ACTION_ID = "diagram.grabWaypoint";
+function diagramWaypoints(opts) {
+  const actionId = opts.id ?? ROUTE_EDIT_ACTION_ID;
+  const target = `affordance:${WAYPOINT_AFFORDANCE_KIND}`;
+  return {
+    // `opts.id` names the drag action; the layer keeps its own id.
+    layer: waypointLayer(opts.participants, opts.selected, { ...opts, id: WAYPOINT_LAYER_ID }),
+    contribution: {
+      id: "weasel-diagram-waypoints",
+      eligibility: { claimed: true },
+      actions: [
+        createRouteEditAction({ ...opts, id: actionId }),
+        createRemoveWaypointAction(opts),
+        createResetRouteAction(opts),
+        ...routerActions({ participants: opts.participants, selected: opts.selected }),
+        createSetHopsAction(),
+        grabPortAction(GRAB_WAYPOINT_ACTION_ID)
+      ],
+      bindings: [
+        { spec: { kind: "drag", target }, actionId },
+        { spec: { kind: "doubleClick", target }, actionId: REMOVE_WAYPOINT_ACTION_ID },
+        ...grabPortBindings(GRAB_WAYPOINT_ACTION_ID, WAYPOINT_AFFORDANCE_KIND)
+      ]
+    }
+  };
+}
+var GRAB_LABEL_ACTION_ID = "diagram.grabLabel";
+var SELECT_LABEL_EDGE_ACTION_ID = "diagram.selectLabelEdge";
+var NO_MODIFIERS5 = { shift: false, meta: false, ctrl: false };
+var ANY_MODIFIERS = { shift: "optional", meta: "optional", ctrl: "optional", alt: "optional" };
+function selectLabelEdgeAction() {
+  return {
+    id: SELECT_LABEL_EDGE_ACTION_ID,
+    label: "Select label edge",
+    group: "diagram",
+    requires: ["selection"],
+    invoker: {
+      timing: "immediate",
+      run(deps, params) {
+        const p = params;
+        const pressed = labelScratchOf(p?.affordance);
+        if (pressed !== null) deps.selection?.applyClick(pressed.edgeId, p?.mods ?? NO_MODIFIERS5);
+      }
+    },
+    enabled: (deps) => deps?.selection !== void 0 ? true : ActionDisabledReason.NotApplicable
+  };
+}
+function diagramLabelDrag(opts) {
+  const actionId = opts.id ?? MOVE_LABEL_ACTION_ID;
+  const target = `affordance:${LABEL_DRAG_AFFORDANCE_KIND}`;
+  return {
+    layer: labelDragLayer(opts.scene, opts.cursor !== void 0 ? { cursor: opts.cursor } : {}),
+    contribution: {
+      id: "weasel-diagram-label-drag",
+      eligibility: { claimed: true },
+      actions: [
+        createLabelDragAction({ ...opts, id: actionId }),
+        createResetLabelAction({ selected: opts.selected, ...opts.commit ? { commit: opts.commit } : {} }),
+        grabPortAction(GRAB_LABEL_ACTION_ID),
+        selectLabelEdgeAction()
+      ],
+      bindings: [
+        { spec: { kind: "drag", target }, actionId },
+        { spec: { kind: "pointerDown", target }, actionId: GRAB_LABEL_ACTION_ID },
+        { spec: { kind: "click", target, mods: ANY_MODIFIERS }, actionId: SELECT_LABEL_EDGE_ACTION_ID },
+        { spec: { kind: "doubleClick", target }, actionId: EDIT_EDGE_LABEL_ACTION_ID }
+      ]
+    }
+  };
+}
+var headerIdOf = (id) => `${id}/header`;
+var facingPorts = (ports) => ports.flatMap((p) => p.normal === null ? [] : [{ point: p.point, normal: p.normal }]);
+function members(scene, node, into) {
+  const under = Array.isArray(node.dependsOn) && diagramGroupOf(node) !== null ? node.dependsOn : scene.childrenOf(node.id);
+  for (const id of under) {
+    if (into.has(id)) continue;
+    into.add(id);
+    const child = scene.get(id);
+    if (child !== void 0) members(scene, child, into);
+  }
+  return into;
+}
+function avoidSceneInput(scene, opts = {}, poseOf) {
+  const sc = scene;
+  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
+  const portOpts = { geometry, ...opts.read ? { read: opts.read } : {} };
+  const key = opts.routerKey ?? "avoid";
+  const poses = /* @__PURE__ */ new Map();
+  const pose = (node) => {
+    let p = poses.get(node.id);
+    if (p === void 0) {
+      p = poseOf?.(node.id) ?? documentPose(sc, node);
+      poses.set(node.id, p);
+    }
+    return p;
+  };
+  const obstacles = [];
+  const edgeNodes = [];
+  const labels = /* @__PURE__ */ new Map();
+  const labelNodes = /* @__PURE__ */ new Map();
+  const split = [];
+  for (const node of sc.renderOrderNodes()) {
+    const edge = diagramEdgeOf(node);
+    if (edge !== null) {
+      if (edge.router === key && edge.offPage === void 0) edgeNodes.push(node);
+      else if (edge.router === key) split.push(node.id);
+      continue;
+    }
+    const label = diagramLabelOf(node);
+    if (label !== null) {
+      const owner = Array.isArray(node.dependsOn) ? node.dependsOn[0] : void 0;
+      const { width, height } = geometry.getBounds(node.pose);
+      if (owner !== void 0 && !labels.has(owner)) {
+        labels.set(owner, { id: node.id, placement: label, size: { width, height } });
+        labelNodes.set(owner, node);
+      }
+      continue;
+    }
+    const container = diagramContainerOf(node);
+    const isParticipant = diagramNodeOf(node, opts.read) !== null;
+    if (!isParticipant && container?.role !== "lane") continue;
+    const box = geometry.getBounds(pose(node));
+    const header = container === null ? null : headerBox(box, container.header);
+    if (header !== null) obstacles.push({ id: headerIdOf(node.id), kind: "shape", box: header });
+    if (container?.role === "lane") continue;
+    const region = container !== null || diagramGroupOf(node) !== null;
+    obstacles.push(region ? { id: node.id, kind: "region", box, members: members(sc, node, /* @__PURE__ */ new Set()) } : { id: node.id, kind: "shape", box });
+  }
+  for (const id of split) {
+    const node = labelNodes.get(id);
+    if (node !== void 0) obstacles.push({ id: node.id, kind: "label", edge: id, box: geometry.getBounds(pose(node)) });
+  }
+  const edges = [];
+  for (const node of edgeNodes) {
+    const edge = diagramEdgeOf(node);
+    const ends = node.dependsOn;
+    if (!Array.isArray(ends) || ends.length !== 2) continue;
+    if (ends[0] === ends[1] && edge.from.port === void 0 && edge.to.port === void 0) continue;
+    const [a, b] = ends.map((id) => sc.get(id));
+    if (a === void 0 || b === void 0) continue;
+    const portsAt = (n, port) => facingPorts(port === void 0 ? portsOf(n, pose(n), portOpts) : portSitesOf(n, pose(n), port, portOpts));
+    const from = portsAt(a, edge.from.port);
+    const to = portsAt(b, edge.to.port);
+    if (from.length === 0 || to.length === 0) continue;
+    edges.push({
+      id: node.id,
+      from: { node: a.id, ports: from },
+      to: { node: b.id, ports: to },
+      ...edge.waypoints !== void 0 && edge.waypoints.length > 0 ? { waypoints: edge.waypoints } : {},
+      ...edge.route !== void 0 ? { route: edge.route } : {},
+      ...labels.has(node.id) ? { label: labels.get(node.id) } : {}
+    });
+  }
+  return { obstacles, edges };
+}
+
+// src/avoid/specRoutes.ts
+var facing = (ports) => ports.flatMap((p) => p.normal === null ? [] : [{ point: p.point, normal: p.normal }]);
+function obstaclesOf(specs) {
+  const children = /* @__PURE__ */ new Map();
+  for (const s of specs) {
+    if (s.parent == null) continue;
+    children.set(s.parent, [...children.get(s.parent) ?? [], s.id]);
+  }
+  const inside2 = (id, into) => {
+    for (const child of children.get(id) ?? []) {
+      into.add(child);
+      inside2(child, into);
+    }
+    return into;
+  };
+  const out = [];
+  for (const spec of specs) {
+    const node = { id: spec.id, kind: spec.kind, data: spec.data };
+    if (spec.derivePose !== void 0 || diagramEdgeOf(spec) !== null) continue;
+    const region = diagramContainerOf(spec);
+    if (diagramNodeOf(node) === null && region?.role !== "lane") continue;
+    const header = region === null ? null : headerBox(spec.pose, region.header);
+    if (header !== null) out.push({ id: headerIdOf(node.id), kind: "shape", box: header });
+    if (region?.role === "lane") continue;
+    out.push(region === null ? { id: node.id, kind: "shape", box: spec.pose } : { id: node.id, kind: "region", box: spec.pose, members: inside2(node.id, /* @__PURE__ */ new Set()) });
+  }
+  return out;
+}
+function labelsOf(specs) {
+  const out = /* @__PURE__ */ new Map();
+  for (const spec of specs) {
+    const label = diagramLabelOf(spec);
+    const owner = Array.isArray(spec.dependsOn) ? spec.dependsOn[0] : void 0;
+    if (label === null || owner === void 0 || out.has(owner)) continue;
+    const { width, height } = spec.pose;
+    out.set(owner, { id: spec.id, placement: label, size: { width, height } });
+  }
+  return out;
+}
+function createSpecRouter(options = {}) {
+  const router = createAvoidRouter(options);
+  let held = /* @__PURE__ */ new Map();
+  return (specs) => {
+    const byId = new Map(specs.map((s) => [s.id, s]));
+    const labels = labelsOf(specs);
+    const obstacles = obstaclesOf(specs);
+    const edges = [];
+    for (const spec of specs) {
+      const edge = diagramEdgeOf(spec);
+      if (edge === null || edge.offPage !== void 0) continue;
+      const ends = Array.isArray(spec.dependsOn) ? spec.dependsOn.map((id) => byId.get(id)) : [];
+      const [a, b] = ends;
+      if (a === void 0 || b === void 0 || a === b) continue;
+      const portsAt = (s, port) => {
+        const n = { id: s.id, kind: s.kind, data: s.data };
+        return facing(port === void 0 ? portsOf(n, s.pose) : portSitesOf(n, s.pose, port));
+      };
+      const route = held.get(spec.id);
+      edges.push({
+        id: spec.id,
+        from: { node: a.id, ports: portsAt(a, edge.from.port) },
+        to: { node: b.id, ports: portsAt(b, edge.to.port) },
+        ...edge.waypoints !== void 0 && edge.waypoints.length > 0 ? { waypoints: edge.waypoints } : {},
+        ...route != null ? { route } : {},
+        ...labels.has(spec.id) ? { label: labels.get(spec.id) } : {}
+      });
+    }
+    if (edges.length === 0) return [...specs];
+    const next = new Map(held);
+    for (const [id, route] of router.update({ obstacles, edges })) next.set(id, route);
+    held = new Map(edges.map((e) => [e.id, next.get(e.id) ?? null]));
+    return specs.map((spec) => {
+      const edge = diagramEdgeOf(spec);
+      if (edge === null || !held.has(spec.id)) return spec;
+      const route = held.get(spec.id);
+      const { route: _r, ...rest } = edge;
+      const diagram = { ...rest, router: "avoid", ...route != null ? { route } : {} };
+      return { ...spec, data: { ...spec.data, diagram } };
+    });
+  };
+}
+function sceneEdges(scene) {
+  const out = [];
+  for (const node of scene.renderOrderNodes()) {
+    const trait = diagramEdgeOf(node);
+    const ends = node.dependsOn;
+    if (trait === null || !Array.isArray(ends) || ends.length !== 2) continue;
+    out.push({ node, trait, ends: [ends[0], ends[1]] });
+  }
+  return out;
+}
+function edgePolylines(scene, opts = {}) {
+  const route = edgeRouter({ geometry: AUTO_POSE_DESCRIPTOR, ...opts });
+  const dep = (id) => {
+    const node = scene.get(id);
+    return node === void 0 ? void 0 : { node, pose: documentPose(scene, node), path: null };
+  };
+  return (edge) => {
+    const routed = route(edge.node, [dep(edge.ends[0]), dep(edge.ends[1])]);
+    const points = routed?.stubs === void 0 ? routed?.points : void 0;
+    return points === void 0 || points.length < 2 ? null : [...points];
+  };
+}
+function inOrUnder(scene, id, ids) {
+  for (let at = id; at != null; at = scene.get(at)?.parent) {
+    if (ids.has(at)) return true;
+  }
+  return false;
+}
+function withHopsData(data, trait, hops) {
+  const { hops: _h, ...rest } = trait;
+  return { ...data, diagram: hops.length === 0 ? rest : { ...rest, hops } };
+}
+var sameHop = (a, b) => a.at.x === b.at.x && a.at.y === b.at.y && a.r === b.r && a.over.length === b.over.length && a.over.every((o, i) => o === b.over[i]);
+function hopDataOps(scene, hops) {
+  const ops = [];
+  for (const [id, list] of hops) {
+    const node = scene.get(id);
+    const trait = node === void 0 ? null : diagramEdgeOf(node);
+    if (node === void 0 || trait === null) continue;
+    const had = trait.hops ?? [];
+    if (had.length === list.length && had.every((h, i) => sameHop(h, list[i]))) continue;
+    ops.push(createSetDataOp({ id, from: node.data, to: withHopsData(node.data, trait, list), label: "Line jumps" }));
+  }
+  return ops;
+}
+
+// src/hops/specHops.ts
+function createSpecHops(r) {
+  const route = edgeRouter();
+  return (specs) => {
+    const byId = new Map(specs.map((s) => [s.id, s]));
+    const dep = (id) => {
+      const s = byId.get(id);
+      return s === void 0 ? void 0 : { node: s, pose: s.pose, path: null };
+    };
+    const polylines = /* @__PURE__ */ new Map();
+    const order = [];
+    for (const spec of specs) {
+      const ends = spec.dependsOn;
+      if (diagramEdgeOf(spec) === null || !Array.isArray(ends) || ends.length !== 2) continue;
+      const routed = route(spec, [dep(ends[0]), dep(ends[1])]);
+      const points = routed?.stubs === void 0 ? routed?.points : void 0;
+      if (points === void 0 || points.length < 2) continue;
+      polylines.set(spec.id, [...points]);
+      order.push(spec.id);
+    }
+    const hops = edgeHops(polylines, order, r);
+    return specs.map((spec) => {
+      const trait = diagramEdgeOf(spec);
+      const list = hops.get(spec.id) ?? [];
+      if (trait === null || list.length === 0 && trait.hops === void 0) return spec;
+      return { ...spec, data: withHopsData(spec.data, trait, list) };
+    });
+  };
+}
+
+// src/reconnect.ts
+var RECONNECT_ACTION_ID = "diagram.reconnect";
+var GRAB_EDGE_END_ACTION_ID = "diagram.grabEdgeEnd";
+var DEFAULT_SNAP2 = 16;
+function commitReconnectToScene(change, ctx) {
+  const scene = ctx.deps.scene;
+  if (scene === void 0) return;
+  const node = scene.get(change.edgeId);
+  const trait = node === void 0 ? null : diagramEdgeOf(node);
+  const deps = node?.dependsOn;
+  if (node === void 0 || trait === null || !Array.isArray(deps) || deps.length !== 2) return;
+  const data = node.data;
+  const nextDeps = [...deps];
+  nextDeps[change.end === "from" ? 0 : 1] = change.target.nodeId;
+  scene.batch("Reconnect edge", () => {
+    scene.update(node.id, {
+      data: { ...data, diagram: { ...trait, [change.end]: edgeEndOf(change.target) } }
+    });
+    scene.setDependsOn(node.id, nextDeps);
+  });
+}
+function fixedEndOf(ends, moving, opts) {
+  const side = moving === "from" ? "to" : "from";
+  const { node, pose } = ends[side];
+  const named = ends.trait[side].port;
+  const port = named === void 0 ? void 0 : portOf(node, pose, named, {
+    ...opts.geometry ? { geometry: opts.geometry } : {},
+    ...opts.read ? { read: opts.read } : {}
+  });
+  return port ?? { kind: "body", nodeId: node.id, point: ends.points[side] };
+}
+function sameEnd(ends, moving, target) {
+  if (ends[moving].node.id !== target.nodeId) return false;
+  const named = ends.trait[moving].port;
+  return isBodyEnd(target) ? named === void 0 : named === target.id;
+}
+function createReconnectAction(opts) {
+  const { canConnect = defaultCanConnect, commit = commitReconnectToScene } = opts;
+  const endsOf = createEdgeEnds(opts.participants, opts);
+  const shared = { ...opts, snapRadius: opts.snapRadius ?? DEFAULT_SNAP2, bodies: opts.bodies ?? true };
+  const targetsFor = (moving) => createTargets({
+    ...shared,
+    canConnect: moving.end === "to" ? (fixed, candidate) => canConnect(fixed, candidate, moving) : (fixed, candidate) => canConnect(candidate, fixed, moving)
+  });
+  return {
+    id: opts.id ?? RECONNECT_ACTION_ID,
+    label: "Reconnect",
+    group: "diagram",
+    requires: ["scene", "view"],
+    invoker: {
+      timing: "ongoing",
+      start(ctx) {
+        const pressed = edgeEndScratchOf(ctx.drag?.affordance);
+        const ends = pressed === null ? null : endsOf(pressed.edgeId);
+        if (pressed === null || ends === null) return {};
+        const scratch = {
+          edgeId: pressed.edgeId,
+          moving: pressed.end,
+          fixed: fixedEndOf(ends, pressed.end, opts),
+          ends,
+          route: routerOf(ends.trait, opts.routers),
+          current: { x: ctx.world.x, y: ctx.world.y },
+          open: true,
+          deps: ctx.deps
+        };
+        const resolver = targetsFor({ edge: scratch.edgeId, end: scratch.moving });
+        return {
+          kind: "diagram-reconnect",
+          onMove(moveCtx) {
+            scratch.current = { x: moveCtx.world.x, y: moveCtx.world.y };
+          },
+          overlay() {
+            if (!scratch.open) return null;
+            const points = resolver.preview(scratch.route, scratch.fixed, scratch.current, scratch.deps.view, scratch.moving, scratch.ends.trait.waypoints);
+            return points.length < 2 ? null : { kind: "polyline", points, role: "connector" };
+          },
+          onEnd(endCtx, reason) {
+            scratch.open = false;
+            if (reason === "cancel") return;
+            const target = resolver.target(scratch.fixed, { x: endCtx.world.x, y: endCtx.world.y }, scratch.deps.view);
+            if (target === null || sameEnd(scratch.ends, scratch.moving, target)) return;
+            commit({ edgeId: scratch.edgeId, end: scratch.moving, target }, { ...endCtx, deps: scratch.deps });
+          }
+        };
+      }
+    },
+    enabled: () => true
+  };
+}
+function reconnectBinding(actionId = RECONNECT_ACTION_ID) {
+  return { spec: { kind: "drag", target: `affordance:${EDGE_END_AFFORDANCE_KIND}` }, actionId };
+}
+function diagramEdgeEnds(opts) {
+  const actionId = opts.id ?? RECONNECT_ACTION_ID;
+  return {
+    // `opts.id` names the action; the layer keeps its own id.
+    layer: edgeEndLayer(opts.participants, opts.selected, { ...opts, id: EDGE_END_LAYER_ID }),
+    contribution: {
+      id: "weasel-diagram-edge-ends",
+      eligibility: { claimed: true },
+      actions: [createReconnectAction({ ...opts, id: actionId }), grabPortAction(GRAB_EDGE_END_ACTION_ID)],
+      bindings: [
+        reconnectBinding(actionId),
+        ...grabPortBindings(GRAB_EDGE_END_ACTION_ID, EDGE_END_AFFORDANCE_KIND)
+      ]
+    }
+  };
+}
+function packed(items, spans, order) {
+  const gaps = items.slice(1).map((m, i) => spans.get(m).start - (spans.get(items[i]).start + spans.get(items[i]).size));
+  const out = /* @__PURE__ */ new Map();
+  let at = items.length > 0 ? spans.get(items[0]).start : 0;
+  order.forEach((m, i) => {
+    out.set(m, at);
+    at += spans.get(m).size + (gaps[i] ?? gaps[gaps.length - 1] ?? 0);
+  });
+  return out;
+}
+var carriedBy = (item) => item.carries ?? [item.id];
+var RELEASE_MS = 500;
+function slideOthers(scene, slots, carried) {
+  const { axis } = slots;
+  const size = axis === "x" ? "width" : "height";
+  const ids = slots.items.map((i) => i.id);
+  const spans = new Map(slots.items.map((i) => [i.id, { start: i.bounds[axis], size: i.bounds[size] }]));
+  const nodes = slots.items.map((item) => ({
+    id: item.id,
+    poses: carriedBy(item).flatMap((id) => {
+      const node = scene.get(id);
+      return node === void 0 || node.derivePose !== void 0 ? [] : [{ id, pose: effectivePose(scene, node) }];
+    })
+  }));
+  const hold = scene.overrides.hold();
+  return {
+    /** The items standing in `order`, or as they were for `null`, with the carried one `by` along. */
+    show(order, by) {
+      const starts = packed(ids, spans, order ?? ids);
+      hold.set(nodes.flatMap(({ id, poses }) => {
+        const d = id === carried ? by : starts.get(id) - spans.get(id).start;
+        return poses.map(({ id: node, pose }) => [node, { ...pose, [axis]: pose[axis] + d }]);
+      }));
+    },
+    drop: () => hold.drop(),
+    /** Held until the host's new specs land, so the items do not jump back for
+     *  the frames in between; a host that keeps the old order gets it back shortly after. */
+    keep() {
+      const release = () => {
+        stop();
+        clearTimeout(timer);
+        hold.drop();
+      };
+      const stop = scene.subscribe(release);
+      const timer = setTimeout(release, RELEASE_MS);
+    }
+  };
+}
+
+// src/reorder.ts
+var REORDER_ACTION_ID = "diagram.reorder";
+var END_GAP = 24;
+var inside = (p, b) => p.x >= b.x && p.x <= b.x + b.width && p.y >= b.y && p.y <= b.y + b.height;
+function sequenceSlots(axis, items) {
+  const [along2, across, size, depth] = axis === "x" ? ["x", "y", "width", "height"] : ["y", "x", "height", "width"];
+  const lo = (b) => b[along2];
+  const hi = (b) => b[along2] + b[size];
+  const bar = (at, boxes2) => {
+    const from = Math.min(...boxes2.map((b) => b[across]));
+    const to = Math.max(...boxes2.map((b) => b[across] + b[depth]));
+    const point = (c) => axis === "x" ? { x: at, y: c } : { x: c, y: at };
+    return { a: point(from), b: point(to) };
+  };
+  const boxes = items.map((i) => i.bounds);
+  const halves = boxes.slice(1).map((b, k) => (lo(b) - hi(boxes[k])) / 2);
+  const gaps = [];
+  if (boxes.length === 0) return { axis, items, gaps };
+  gaps.push({ index: 0, ...bar(lo(boxes[0]) - (halves[0] ?? END_GAP / 2), [boxes[0]]) });
+  for (let k = 1; k < boxes.length; k++) gaps.push({ index: k, ...bar(hi(boxes[k - 1]) + halves[k - 1], [boxes[k - 1], boxes[k]]) });
+  const last = boxes[boxes.length - 1];
+  gaps.push({ index: boxes.length, ...bar(hi(last) + (halves[halves.length - 1] ?? END_GAP / 2), [last]) });
+  return { axis, items, gaps };
+}
+function pickAt(slots, at) {
+  const from = slots?.items.findIndex((i) => i.grip !== null && inside(at, i.grip ?? i.bounds)) ?? -1;
+  return from < 0 ? null : { from, item: slots.items[from] };
+}
+function gapAt(held, by) {
+  const { axis, gaps } = held.slots;
+  const size = axis === "x" ? "width" : "height";
+  const mid = held.item.bounds[axis] + held.item.bounds[size] / 2 + by;
+  let best = null;
+  for (const g of gaps) if (best === null || Math.abs(g.a[axis] - mid) < Math.abs(best.a[axis] - mid)) best = g;
+  return best === null || best.index === held.from || best.index === held.from + 1 ? null : best;
+}
+function moveOf2(held, gap) {
+  const order = held.slots.items.map((i) => i.id);
+  order.splice(held.from, 1);
+  order.splice(gap.index > held.from ? gap.index - 1 : gap.index, 0, held.item.id);
+  return { id: held.item.id, from: held.from, to: gap.index, order };
+}
+function createReorderAction(opts) {
+  const { canDrop = () => true, show = "bar" } = opts;
+  return {
+    id: opts.id ?? REORDER_ACTION_ID,
+    label: opts.label ?? "Reorder",
+    group: "diagram",
+    requires: ["scene", ...opts.requires ?? []],
+    cursor: "grab",
+    activeCursor: "grabbing",
+    enabled: (deps, at) => deps === void 0 || at === void 0 || pickAt(opts.slots(deps, at), at) !== null ? true : ActionDisabledReason.NotApplicable,
+    invoker: {
+      timing: "ongoing",
+      start(ctx) {
+        const start = { x: (ctx.drag?.start ?? ctx.world).x, y: (ctx.drag?.start ?? ctx.world).y };
+        const slots = opts.slots(ctx.deps, start);
+        const picked = pickAt(slots, start);
+        if (slots === null || picked === null) return {};
+        const held = { slots, ...picked };
+        const { axis } = slots;
+        let by = ctx.world[axis] - start[axis];
+        let open = true;
+        const verdicts = /* @__PURE__ */ new Map();
+        const landing = (gap) => {
+          if (gap === null) return null;
+          if (!verdicts.has(gap.index)) {
+            const move = moveOf2(held, gap);
+            verdicts.set(gap.index, canDrop(move) ? move : null);
+          }
+          return verdicts.get(gap.index);
+        };
+        const finish = (endCtx, reason) => {
+          open = false;
+          by = endCtx.world[axis] - start[axis];
+          const move = reason === "commit" ? landing(gapAt(held, by)) : null;
+          if (move !== null) opts.commit(move, { ...endCtx, deps: ctx.deps });
+          return move;
+        };
+        if (show === "slide") {
+          const slide = ctx.deps.scene === void 0 ? null : slideOthers(ctx.deps.scene, held.slots, held.item.id);
+          return {
+            kind: "diagram-reorder",
+            onMove(moveCtx) {
+              by = moveCtx.world[axis] - start[axis];
+              slide?.show(landing(gapAt(held, by))?.order ?? null, by);
+            },
+            onEnd(endCtx, reason) {
+              const move = finish(endCtx, reason);
+              if (move === null) slide?.drop();
+              else slide?.keep();
+            }
+          };
+        }
+        const carried = carriedBy(held.item);
+        const poses = /* @__PURE__ */ new Map();
+        for (const id of carried) {
+          const pose = ctx.deps.scene?.get(id)?.pose;
+          if (pose !== void 0) poses.set(id, pose);
+        }
+        return {
+          kind: "diagram-reorder",
+          onMove(moveCtx) {
+            by = moveCtx.world[axis] - start[axis];
+          },
+          previewIds: () => open && poses.size > 0 ? [...poses.keys()] : null,
+          previewPose: (id) => {
+            const pose = poses.get(id);
+            return pose === void 0 ? null : { ...pose, [axis]: pose[axis] + by };
+          },
+          previewOpaqueIds: () => [...carried],
+          overlay() {
+            const gap = open ? gapAt(held, by) : null;
+            if (gap === null) return null;
+            return { kind: "polyline", points: [gap.a, gap.b], role: landing(gap) !== null ? "insert" : "refused" };
+          },
+          onEnd(endCtx, reason) {
+            finish(endCtx, reason);
+          }
+        };
+      }
+    }
+  };
+}
+var ANYWHERE = bodyPredicate(() => true);
+function reorderBinding(actionId = REORDER_ACTION_ID, on = ANYWHERE) {
+  return { spec: { kind: "drag", target: { kindOf: on } }, actionId };
+}
+function reorderContribution(opts) {
+  const actionId = opts.id ?? REORDER_ACTION_ID;
+  return {
+    id: `weasel-diagram-reorder:${actionId}`,
+    eligibility: { always: true },
+    actions: [createReorderAction({ ...opts, id: actionId })],
+    bindings: [reorderBinding(actionId, opts.on)]
+  };
+}
+function worldRectOf(scene, id) {
+  const node = scene.get(id);
+  if (node === void 0) return null;
+  const drawn = drawnBoundsScene(scene);
+  const route = diagramEdgeOf(node) === null ? null : drawn.derivedPathOf?.(id) ?? null;
+  const mid = route === null ? null : pointAlongPath(route, 0.5);
+  if (mid != null) return { x: mid.point.x, y: mid.point.y, width: 0, height: 0 };
+  return drawnAABBOf(drawn, id, effectivePose(scene, node), { includeStroke: false });
+}
+function screenRectOf(rect, view) {
+  return {
+    x: (rect.x - view.x) * view.scale.x,
+    y: (rect.y - view.y) * view.scale.y,
+    width: rect.width * view.scale.x,
+    height: rect.height * view.scale.y
+  };
+}
+var CENTER = "center";
+function place(el, overlay, anchor, width, height) {
+  const size = { width: el.offsetWidth, height: el.offsetHeight };
+  const placement = overlay.placement ?? CENTER;
+  const at = placement === CENTER ? { x: anchor.x + (anchor.width - size.width) / 2, y: anchor.y + (anchor.height - size.height) / 2 } : placeRect({
+    anchor,
+    overlay: size,
+    boundary: { x: 0, y: 0, width, height },
+    placement,
+    offset: overlay.offset ?? 0
+  }).rect;
+  el.style.transform = `translate(${Math.round(at.x)}px, ${Math.round(at.y)}px)`;
+}
+function useOverlayPlacement(canvasRef, scene, overlays) {
+  const elements = useRef(/* @__PURE__ */ new Map());
+  const current = useLatest$1(overlays);
+  const placeAll = useCallback(() => {
+    const canvas = canvasRef.current;
+    const surface = canvas?.element;
+    if (canvas == null || surface == null) return;
+    const view = canvas.getView();
+    for (const overlay of current.current) {
+      const el = elements.current.get(overlay.key ?? overlay.target);
+      if (el === void 0) continue;
+      const world = worldRectOf(scene, overlay.target);
+      el.hidden = world === null;
+      if (world === null) continue;
+      const rect = screenRectOf(world, view);
+      const anchor = { ...rect, x: rect.x + surface.offsetLeft, y: rect.y + surface.offsetTop };
+      place(el, overlay, anchor, surface.offsetWidth, surface.offsetHeight);
+    }
+  }, [canvasRef, scene, current]);
+  useLayoutEffect(() => {
+    placeAll();
+    const canvas = canvasRef.current;
+    if (canvas == null) return;
+    const stop = canvas.subscribeFrame(placeAll);
+    const observer = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(placeAll);
+    for (const el of elements.current.values()) observer?.observe(el);
+    return () => {
+      stop();
+      observer?.disconnect();
+    };
+  }, [canvasRef, placeAll, overlays]);
+  const refs = useRef(/* @__PURE__ */ new Map());
+  return useCallback((key) => {
+    let ref = refs.current.get(key);
+    if (ref === void 0) {
+      ref = (el) => {
+        if (el !== null) {
+          elements.current.set(key, el);
+          return;
+        }
+        elements.current.delete(key);
+        refs.current.delete(key);
+      };
+      refs.current.set(key, ref);
+    }
+    return ref;
+  }, []);
+}
+
+// src/reorderModel.ts
+var depsOf = (node) => Array.isArray(node?.dependsOn) ? node.dependsOn : [];
+function holders(scene) {
+  const out = /* @__PURE__ */ new Map();
+  for (const node of scene.renderOrderNodes()) {
+    if (diagramGroupOf(node) === null) continue;
+    for (const dep of depsOf(node)) {
+      const member = scene.get(dep);
+      if (member !== void 0 && diagramLabelOf(member) === null) out.set(dep, node.id);
+    }
+  }
+  return out;
+}
+function membersOf(scene, group) {
+  return depsOf(scene.get(group)).filter((id) => {
+    const node = scene.get(id);
+    return node !== void 0 && diagramLabelOf(node) === null;
+  });
+}
+function reorderTargetOf(scene, id, boxOf) {
+  const held = holders(scene);
+  for (let member = id, group = held.get(id); group !== void 0; member = group, group = held.get(group)) {
+    const axis = diagramGroupOf(scene.get(group))?.reorder;
+    if (axis === void 0) continue;
+    const start = (m) => {
+      const box = boxOf(m);
+      return box === null ? 0 : axis === "x" ? box.x : box.y;
+    };
+    const members2 = membersOf(scene, group).sort((a, b) => start(a) - start(b));
+    return { group, axis, member, members: members2 };
+  }
+  return null;
+}
+function carriedWith(scene, member) {
+  const out = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (out.has(id)) return;
+    out.add(id);
+    const node = scene.get(id);
+    if (node !== void 0 && diagramGroupOf(node) !== null) depsOf(node).forEach(visit);
+    scene.childrenOf?.(id).forEach(visit);
+  };
+  visit(member);
+  for (const node of scene.renderOrderNodes()) {
+    const on = depsOf(node)[0];
+    if (on !== void 0 && out.has(on) && diagramAnchorOf(node) !== null) out.add(node.id);
+  }
+  return out;
+}
+
+// src/groupReorder.ts
+var STEP_REORDER_ACTION_ID = "diagram.stepReorder";
+var sceneOf = (deps) => deps?.scene;
+function targetAt(deps, id) {
+  const scene = sceneOf(deps);
+  if (scene === void 0 || id == null) return null;
+  return reorderTargetOf(scene, id, (m) => worldRectOf(scene, m));
+}
+function groupReorderSlots(deps, at) {
+  const scene = sceneOf(deps);
+  const target = targetAt(deps, deps.nodeAtPoint?.(at));
+  if (scene === void 0 || target === null) return null;
+  return sequenceSlots(target.axis, target.members.map((m) => ({
+    id: m,
+    bounds: worldRectOf(scene, m) ?? { x: 0, y: 0, width: 0, height: 0 },
+    carries: [...carriedWith(scene, m)]
+  })));
+}
+var STEPS = [
+  { key: "ArrowUp", axis: "y", step: -1 },
+  { key: "ArrowDown", axis: "y", step: 1 },
+  { key: "ArrowLeft", axis: "x", step: -1 },
+  { key: "ArrowRight", axis: "x", step: 1 }
+];
+function createStepReorderAction(report) {
+  const selectedTarget = (deps) => targetAt(deps, deps?.selection?.get()[0]);
+  return {
+    id: STEP_REORDER_ACTION_ID,
+    label: "Move along",
+    group: "diagram",
+    defaultBinding: STEPS.map(({ key, axis, step }) => ({
+      spec: { kind: "key", key, mods: { alt: true } },
+      opts: { params: { axis, step } }
+    })),
+    requires: ["scene", "selection"],
+    invoker: {
+      timing: "immediate",
+      run(deps, params) {
+        const target = selectedTarget(deps);
+        if (target === null || params?.axis !== target.axis) return;
+        const { members: members2, member } = target;
+        const at = members2.indexOf(member);
+        const to = at + (params.step === -1 ? -1 : 1);
+        if (to < 0 || to >= members2.length) return;
+        const order = [...members2];
+        order.splice(at, 1);
+        order.splice(to, 0, member);
+        report({ group: target.group, order });
+      }
+    },
+    enabled: (deps) => selectedTarget(deps) !== null ? true : ActionDisabledReason.NotApplicable
+  };
+}
+var onBody2 = bodyPredicate((target) => target === "selected-body" || target === "unselected-body");
+function groupReorderContribution(report) {
+  const drag = reorderContribution({
+    slots: groupReorderSlots,
+    requires: ["nodeAtPoint"],
+    show: "slide",
+    on: onBody2,
+    commit: (move, ctx) => {
+      const group = targetAt(ctx.deps, move.id)?.group;
+      if (group !== void 0) report({ group, order: move.order });
+    }
+  });
+  return { ...drag, id: "weasel-diagram-reorder", actions: [...drag.actions ?? [], createStepReorderAction(report)] };
+}
+
+// src/labels/specLabels.ts
+var routeOf = edgeRouter();
+function inputOf(specs) {
+  const byId = new Map(specs.map((s) => [s.id, s]));
+  const dep = (id) => {
+    const s = byId.get(id);
+    return s === void 0 ? void 0 : { node: { ...s, parent: null }, pose: s.pose, path: null };
+  };
+  const shapes = [];
+  const routes = [];
+  const labels = [];
+  for (const spec of specs) {
+    const id = spec.id;
+    const ends = Array.isArray(spec.dependsOn) ? spec.dependsOn : [];
+    if (diagramEdgeOf(spec) !== null) {
+      const points = routeOf(spec, ends.map(dep))?.points;
+      if (points !== void 0 && points.length >= 2) routes.push({ id, points });
+      continue;
+    }
+    const placement = diagramLabelOf(spec);
+    if (placement !== null) {
+      const { width, height } = spec.pose;
+      if (ends[0] !== void 0) labels.push({ id, edge: ends[0], placement, size: { width, height } });
+      continue;
+    }
+    const node = { id, kind: spec.kind, data: spec.data };
+    if (spec.derivePose !== void 0 || diagramContainerOf(node) !== null || diagramGroupOf(node) !== null || diagramNodeOf(node) === null) continue;
+    shapes.push({ id, box: spec.pose });
+  }
+  return { shapes, routes, labels };
+}
+var keyOf = (input) => JSON.stringify([
+  input.shapes.map((s) => [s.id, s.box.x, s.box.y, s.box.width, s.box.height]),
+  input.routes.map((r) => [r.id, r.points.flatMap((p) => [p.x, p.y])]),
+  input.labels.map((l) => [l.id, l.edge, l.placement.at, l.placement.offset, l.placement.dodge, l.size.width, l.size.height])
+]);
+function createSpecLabelPlacer(opts = {}) {
+  let last = null;
+  return (specs) => {
+    const input = inputOf(specs);
+    if (input.labels.length === 0) return [...specs];
+    const key = keyOf(input);
+    if (last?.key !== key) last = { key, placed: placeLabels(input, opts) };
+    const placed = last.placed;
+    return specs.map((spec) => {
+      const spot = placed.get(spec.id);
+      const label = diagramLabelOf(spec);
+      if (spot === void 0 || label === null) return spec;
+      const { placed: _p, ...preferred } = label;
+      const next = spot === null ? preferred : { ...preferred, placed: spot };
+      return { ...spec, data: { ...spec.data, diagram: { ...spec.data.diagram, label: next } } };
+    });
+  };
+}
+
+// src/resizable.ts
+function diagramResizable(scene) {
+  return (id) => {
+    const node = scene.get(id);
+    return node === void 0 || diagramEdgeOf(node) === null && diagramLabelOf(node) === null && diagramGroupOf(node) === null && diagramContainerOf(node)?.role !== "lane";
+  };
+}
+
+// src/routeWrites.ts
+var ROUTE_TOLERANCE = 1e-3;
+function routesOf(graph, plan) {
+  return {
+    edges: new Set(graph.edges.map((e) => e.origin?.id ?? e.id)),
+    waypoints: plan.waypoints ?? /* @__PURE__ */ new Map(),
+    ...plan.labels !== void 0 ? { labels: plan.labels } : {},
+    ...plan.ports !== void 0 ? { ports: plan.ports } : {}
+  };
+}
+function routeWrites(scene, routes) {
+  const out = /* @__PURE__ */ new Map();
+  const owned = /* @__PURE__ */ new Set();
+  for (const id of routes.edges) {
+    const node = scene.get(id);
+    const edge = node === void 0 ? null : diagramEdgeOf(node);
+    if (node === void 0 || edge === null || scene.isLocked(id)) {
+      if (edge !== null && layoutWritesRoute(edge)) owned.add(id);
+      continue;
+    }
+    let next = edge;
+    if (layoutWritesRoute(edge)) {
+      owned.add(id);
+      next = rerouted(edge, routes.waypoints.get(id));
+    }
+    const ports = routes.ports?.get(id);
+    const from = renamed(edge.from, ports?.from);
+    const to = renamed(edge.to, ports?.to);
+    if (from !== edge.from || to !== edge.to) next = { ...next, from, to };
+    if (next !== edge) out.set(id, withTrait(node.data, next));
+  }
+  const stationed = /* @__PURE__ */ new Set();
+  for (const node of scene.renderOrderNodes()) {
+    const label = diagramLabelOf(node);
+    const deps = node.dependsOn;
+    if (label === null || !Array.isArray(deps) || deps.length !== 1 || !owned.has(deps[0])) continue;
+    if (!labelFollowsLayout(label.at) || stationed.has(deps[0])) continue;
+    stationed.add(deps[0]);
+    const near2 = routes.labels?.get(deps[0]);
+    const at = near2 === void 0 ? "mid" : { near: near2 };
+    if (sameAt(label.at, at) || scene.isLocked(node.id)) continue;
+    out.set(node.id, withTrait(node.data, { ...label, at }, "label"));
+  }
+  return out;
+}
+function rerouted(edge, route) {
+  if (route === void 0 || route.length === 0) {
+    if ((edge.waypoints ?? []).length === 0 && edge.laidOut === void 0) return edge;
+    const { waypoints: _w, laidOut: _l, ...rest } = edge;
+    return rest;
+  }
+  if (edge.waypoints !== void 0 && near(edge.waypoints, route)) return edge;
+  return { ...edge, waypoints: route, laidOut: route };
+}
+function renamed(end, port) {
+  if (!layoutOwnsPort(end) || end.port === port && (port === void 0 || end.laidOut === port)) return end;
+  const { port: _p, laidOut: _l, ...rest } = end;
+  return port === void 0 ? rest : { ...rest, port, laidOut: port };
+}
+function near(a, b) {
+  return a.length === b.length && a.every((p, i) => Math.abs(p.x - b[i].x) <= ROUTE_TOLERANCE && Math.abs(p.y - b[i].y) <= ROUTE_TOLERANCE);
+}
+function sameAt(a, b) {
+  if (typeof a === "object" && typeof b === "object") return near([a.near], [b.near]);
+  return a === b;
+}
+function withTrait(data, value, key) {
+  const own = data;
+  const diagram = key === void 0 ? value : { ...own.diagram, [key]: value };
+  return { ...own, diagram };
+}
+var LAYOUTS = Object.freeze({
+  layered,
+  tree,
+  force,
+  chain
+});
+function applyLayout(scene, result, opts = {}) {
+  const poses = layoutPoses(scene, result, opts.geometry);
+  const data = opts.routes === void 0 ? /* @__PURE__ */ new Map() : routeWrites(scene, opts.routes);
+  if (poses.size === 0 && data.size === 0) return 0;
+  const open = [...poses].filter(([id]) => !scene.isLocked(id));
+  if (open.length === 0 && data.size === 0) return 0;
+  scene.batch(opts.label ?? "Layout", () => {
+    for (const [id, pose] of open) scene.setPose(id, pose);
+    for (const [id, d] of data) scene.update(id, { data: d });
+  });
+  const wrote = new Set(open.map(([id]) => id));
+  let moved = 0;
+  for (const id of result.keys()) if (wrote.has(id)) moved++;
+  return moved;
+}
+function layoutPoses(scene, result, geometry = AUTO_POSE_DESCRIPTOR) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [id, at] of result) {
+    const node = scene.get(id);
+    if (node === void 0) continue;
+    const bounds = geometry.getBounds(node.pose);
+    const dx = at.x - bounds.x;
+    const dy = at.y - bounds.y;
+    if (dx === 0 && dy === 0) continue;
+    out.set(id, translatePoseViaDescriptor(node.pose, dx, dy, geometry));
+    for (const descendant of subtreeOf(scene, id)) {
+      const child = scene.get(descendant);
+      if (child === void 0) continue;
+      out.set(descendant, translatePoseViaDescriptor(child.pose, dx, dy, geometry));
+    }
+  }
+  return out;
+}
+function subtreeOf(scene, id) {
+  const out = [];
+  const stack = [...scene.childrenOf(id)];
+  while (stack.length > 0) {
+    const next = stack.pop();
+    out.push(next);
+    stack.push(...scene.childrenOf(next));
+  }
+  return out;
+}
+var LAYOUT_ACTION_ID = "diagram.layout";
+function createLayoutAction(opts) {
+  const algorithm = typeof opts.algorithm === "function" ? opts.algorithm : LAYOUTS[opts.algorithm ?? "layered"] ?? layered;
+  const build = {
+    ...opts.read ? { read: opts.read } : {},
+    ...opts.geometry ? { geometry: opts.geometry } : {}
+  };
+  return {
+    id: opts.id ?? LAYOUT_ACTION_ID,
+    label: opts.label ?? "Lay out diagram",
+    group: opts.group ?? "diagram",
+    requires: ["scene"],
+    invoker: {
+      timing: "immediate",
+      run: (deps) => {
+        const scene = deps["scene"];
+        if (scene === void 0) return;
+        const graph = buildGraph(opts.source, build);
+        const plan = planOf(algorithm, graph, opts.layout);
+        applyLayout(scene, plan.moves, {
+          ...opts.geometry ? { geometry: opts.geometry } : {},
+          ...opts.label ? { label: opts.label } : {},
+          routes: routesOf(graph, plan)
+        });
+      }
+    },
+    enabled: () => true
+  };
+}
+var EASE_FRAMES = 24;
+var easeInOut = (t) => t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
+function progress(frame, frames, easing) {
+  const t = Math.min((frame + 1) / frames, 1);
+  return { t, u: easing(t) };
+}
+var REST_DISTANCE = 0.1;
+var REST_TICKS = 5;
+function forceProducer(graph, opts = {}) {
+  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
+  const relaxation = forceRelaxation(graph, opts);
+  const dragAlpha = opts.dragAlpha ?? 0.3;
+  const restDistance = opts.restDistance ?? REST_DISTANCE;
+  const restTicks = opts.restTicks ?? REST_TICKS;
+  const was = relaxation.bodies.map((b) => ({ x: b.x, y: b.y }));
+  let still = 0;
+  return ({ pinned }) => {
+    for (const node of graph.nodes) {
+      const body = relaxation.byId.get(node.id);
+      if (body === void 0) continue;
+      const held = pinned.get(node.id);
+      if (held !== void 0) {
+        const bounds = geometry.getBounds(held);
+        body.fx = center(bounds, "x");
+        body.fy = center(bounds, "y");
+      } else if (!relaxation.pinned.has(node.id)) {
+        delete body.fx;
+        delete body.fy;
+      }
+    }
+    relaxation.sim.alphaTarget(pinned.size > 0 ? dragAlpha : 0);
+    relaxation.sim.tick();
+    let moved = 0;
+    relaxation.bodies.forEach((body, i) => {
+      const at = was[i];
+      moved = Math.max(moved, Math.hypot(body.x - at.x, body.y - at.y));
+      at.x = body.x;
+      at.y = body.y;
+    });
+    still = pinned.size === 0 && moved < restDistance ? still + 1 : 0;
+    const done = still >= restTicks || relaxation.sim.isSettled();
+    return { result: relaxation.placed(), done };
+  };
+}
+function easedProducer(graph, algorithm, opts = {}) {
+  const frames = opts.frames ?? EASE_FRAMES;
+  const easing = opts.easing ?? easeInOut;
+  const target = algorithm(graph, opts.layout);
+  const from = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) from.set(node.id, { x: node.bounds.x, y: node.bounds.y });
+  return ({ pinned, frame }) => {
+    const { t, u } = progress(frame, frames, easing);
+    const result = /* @__PURE__ */ new Map();
+    for (const [id, to] of target) {
+      if (pinned.has(id)) continue;
+      const start = from.get(id);
+      if (start === void 0) continue;
+      result.set(id, {
+        x: start.x + (to.x - start.x) * u,
+        y: start.y + (to.y - start.y) * u
+      });
+    }
+    return { result, done: t >= 1 };
+  };
+}
+function shapeOf(graph) {
+  const nodes = graph.nodes.map((n) => n.id).sort().join(",");
+  const edges = graph.edges.map((e) => `${e.from}>${e.to}`).sort().join(",");
+  return `${nodes}|${edges}`;
+}
+function sameGraph(a, b) {
+  if (shapeOf(a) !== shapeOf(b)) return false;
+  return a.nodes.every((n) => {
+    const m = b.node(n.id)?.bounds;
+    const k = n.bounds;
+    return m !== void 0 && m.x === k.x && m.y === k.y && m.width === k.width && m.height === k.height;
+  });
+}
+function usePendingPlan() {
+  const generation = useRef(0);
+  const waiting = useRef(false);
+  const pending = useMemo(() => ({
+    request(answer, ready, failed) {
+      const mine = ++generation.current;
+      waiting.current = true;
+      const current = () => generation.current === mine;
+      void answer.then(
+        (plan) => {
+          if (!current()) return;
+          waiting.current = false;
+          ready(plan);
+        },
+        (error) => {
+          if (!current()) return;
+          waiting.current = false;
+          failed(error);
+        }
+      );
+    },
+    drop() {
+      generation.current++;
+      waiting.current = false;
+    },
+    isWaiting: () => waiting.current
+  }), []);
+  useEffect(() => () => pending.drop(), [pending]);
+  return pending;
+}
+var lerp = (a, b, u) => ({ x: a.x + (b.x - a.x) * u, y: a.y + (b.y - a.y) * u });
+function along(points, s) {
+  if (points.length === 1) return points[0];
+  const lengths = points.slice(1).map((p, i) => Math.hypot(p.x - points[i].x, p.y - points[i].y));
+  const total = lengths.reduce((a, b) => a + b, 0);
+  let left = s * total;
+  for (const [i, len] of lengths.entries()) {
+    if (left <= len || i === lengths.length - 1) return lerp(points[i], points[i + 1], len === 0 ? 0 : Math.min(left / len, 1));
+    left -= len;
+  }
+  return points[points.length - 1];
+}
+var straightRun = (count, start, end) => Array.from({ length: count }, (_, k) => lerp(start, end, (k + 1) / (count + 1)));
+function respread(points, count, start, end) {
+  if (points.length === count) return [...points];
+  if (points.length === 0) return straightRun(count, start, end);
+  return Array.from({ length: count }, (_, k) => along(points, count === 1 ? 0.5 : k / (count - 1)));
+}
+function routeEasings(scene, graph, routes) {
+  const centerOf = (id) => {
+    const ids = graph.node(id) !== void 0 ? [id] : graph.groups?.find((g) => g.id === id)?.members ?? [];
+    const boxes = ids.flatMap((m) => graph.node(m)?.bounds ?? []);
+    if (boxes.length === 0) return null;
+    const x0 = Math.min(...boxes.map((b) => b.x));
+    const y0 = Math.min(...boxes.map((b) => b.y));
+    const x1 = Math.max(...boxes.map((b) => b.x + b.width));
+    const y1 = Math.max(...boxes.map((b) => b.y + b.height));
+    return { x: (x0 + x1) / 2, y: (y0 + y1) / 2 };
+  };
+  const writes = routeWrites(scene, routes);
+  const out = [];
+  for (const id of routes.edges) {
+    const node = scene.get(id);
+    const edge = node === void 0 ? null : diagramEdgeOf(node);
+    const written = writes.get(id);
+    if (node === void 0 || edge === null || written === void 0) continue;
+    const next = diagramEdgeOf({ data: written });
+    if (next === null) continue;
+    const ends = { from: next.from, to: next.to };
+    const was = edge.waypoints ?? [];
+    if (!layoutWritesRoute(edge)) {
+      out.push({ id, from: was, to: was, ends });
+      continue;
+    }
+    const after = routes.waypoints.get(id) ?? [];
+    if (after.length === 0) {
+      out.push({ id, from: was, to: null, ends });
+      continue;
+    }
+    const deps = Array.isArray(node.dependsOn) ? node.dependsOn : [];
+    const [a, b] = deps.length === 2 ? [centerOf(deps[0]), centerOf(deps[1])] : [null, null];
+    if (a === null || b === null) continue;
+    const count = Math.max(was.length, after.length);
+    out.push({ id, from: respread(was, count, a, b), to: respread(after, count, a, b), ends });
+  }
+  return out;
+}
+function easedPaths(scene, easings, u, poseOf, geometry = AUTO_POSE_DESCRIPTOR) {
+  const depOf = frameDeps(scene, poseOf);
+  const centerOf = (dep) => {
+    const b = geometry.getBounds(dep.pose);
+    return { x: b.x + b.width / 2, y: b.y + b.height / 2 };
+  };
+  const out = /* @__PURE__ */ new Map();
+  for (const { id, from, to, ends } of easings) {
+    const node = scene.get(id);
+    if (node?.derivePath === void 0 || !Array.isArray(node.dependsOn)) continue;
+    const deps = node.dependsOn.map(depOf);
+    let target = to;
+    if (target === null) {
+      const [a, b] = deps;
+      target = u >= 1 || a === void 0 || b === void 0 ? [] : straightRun(from.length, centerOf(a), centerOf(b));
+    }
+    const waypoints = target.length === 0 && u >= 1 ? [] : from.map((p, k) => lerp(p, target[k], u));
+    const data = node.data;
+    const diagram = { ...data.diagram, ...ends, waypoints };
+    const path = node.derivePath({ ...node, data: { ...data, diagram } }, deps);
+    if (path !== null) out.set(id, path);
+  }
+  return out;
+}
+function frameDeps(scene, poseOf) {
+  const memo = /* @__PURE__ */ new Map();
+  const depOf = (id) => {
+    if (memo.has(id)) return memo.get(id);
+    memo.set(id, derivedDepOf(scene, id));
+    const shown = memo.get(id);
+    if (shown === void 0) return void 0;
+    const pose = poseOf(id) ?? derivedFromFrame(scene, shown, depOf) ?? shown.pose;
+    const dep = { node: shown.node, pose, get path() {
+      return shown.path;
+    } };
+    memo.set(id, dep);
+    return dep;
+  };
+  return depOf;
+}
+function derivedFromFrame(scene, shown, depOf) {
+  const { node } = shown;
+  if (node.derivePose === void 0 || scene.overrides.read(node.id)?.pose !== void 0) return void 0;
+  const ids = node.dependsOn === "children" ? scene.childrenOf(node.id) : node.dependsOn ?? [];
+  if (ids.length === 0) return void 0;
+  return node.derivePose(node, ids.map(depOf)) ?? void 0;
+}
+function pathHold(scene) {
+  const held = /* @__PURE__ */ new Map();
+  const release = (id, entry) => {
+    held.delete(id);
+    if (scene.overrides.get(id) === entry) scene.overrides.clear(id);
+  };
+  return {
+    show(paths) {
+      for (const [id, entry] of held) if (!paths.has(id)) release(id, entry);
+      for (const [id, path] of paths) {
+        const entry = held.get(id);
+        if (entry !== void 0 && scene.overrides.get(id) === entry) {
+          entry.path = path;
+          continue;
+        }
+        const fresh = { path };
+        held.set(id, fresh);
+        scene.overrides.set(id, fresh);
+      }
+    },
+    drop() {
+      for (const [id, entry] of held) release(id, entry);
+    }
+  };
+}
+function useEasedRoutes() {
+  const easings = useRef([]);
+  const held = useRef(null);
+  const routes = useMemo(() => ({
+    set(next) {
+      held.current?.hold.drop();
+      easings.current = next;
+    },
+    show(scene, u, poseOf, geometry) {
+      if (u === null) held.current?.hold.drop();
+      if (u === null || easings.current.length === 0) return;
+      if (held.current?.scene !== scene) {
+        held.current?.hold.drop();
+        held.current = { scene, hold: pathHold(scene) };
+      }
+      held.current.hold.show(easedPaths(scene, easings.current, u, poseOf, geometry));
+    },
+    drop() {
+      held.current?.hold.drop();
+    }
+  }), []);
+  useEffect(() => () => routes.drop(), [routes]);
+  return routes;
+}
+
+// src/live.ts
+function graphOf(o) {
+  return buildGraph(o.source, {
+    ...o.read ? { read: o.read } : {},
+    ...o.geometry ? { geometry: o.geometry } : {}
+  });
+}
+function planFor(graph, o) {
+  const algorithm = o.algorithm ?? "force";
+  if (algorithm === "force") return null;
+  if (typeof algorithm === "object") return plannerPlan(algorithm, graph, o.layout);
+  return planOf(typeof algorithm === "function" ? algorithm : LAYOUTS[algorithm] ?? layered, graph, o.layout);
+}
+function producerFor(graph, plan, o) {
+  if (plan === null) return forceProducer(graph, { ...o.layout, ...o.force, ...o.geometry ? { geometry: o.geometry } : {} });
+  return easedProducer(graph, () => plan.moves, {
+    ...o.frames === void 0 ? {} : { frames: o.frames },
+    ...o.easing ? { easing: o.easing } : {}
+  });
+}
+function useLiveLayout(opts) {
+  const optsRef = useLatest(opts);
+  const producer = useRef(null);
+  const producerFrame = useRef(0);
+  const shape = useRef("");
+  const routes = useRef(void 0);
+  const held = useRef(false);
+  const eased = useEasedRoutes();
+  const pending = usePendingPlan();
+  const install = useCallback((graph, plan) => {
+    const o = optsRef.current;
+    producerFrame.current = 0;
+    held.current = false;
+    routes.current = routesOf(graph, plan ?? { });
+    eased.set(routeEasings(o.scene, graph, routes.current));
+    producer.current = producerFor(graph, plan, o);
+  }, [optsRef, eased]);
+  const step = useCallback((ctx) => {
+    const o = optsRef.current;
+    if (producer.current === null) return { poses: [], done: true };
+    if (ctx.pinned.size > 0) held.current = true;
+    const frame = producerFrame.current++;
+    const { result, done } = producer.current({ pinned: ctx.pinned, frame });
+    let placed = result;
+    if (ctx.pinned.size > 0) {
+      const held2 = new Map(result);
+      for (const id of ctx.pinned.keys()) held2.delete(id);
+      placed = held2;
+    }
+    const poses = layoutPoses(o.scene, placed, o.geometry);
+    const { u } = progress(frame, o.frames ?? EASE_FRAMES, o.easing ?? easeInOut);
+    eased.show(o.scene, held.current ? null : u, (id) => poses.get(id) ?? ctx.pinned.get(id), o.geometry);
+    return { poses: [...poses], done };
+  }, [optsRef, eased]);
+  const run = usePoseRun({
+    scene: opts.scene,
+    step,
+    // Eased routes go once the routes are in the document, so no frame shows the old ones.
+    onCommit: (moved) => {
+      eased.drop();
+      optsRef.current.onSettle?.(moved);
+    },
+    // Routes match where the layout was going, so only a run that got there
+    // with nothing held along the way writes them.
+    commitWith: (finished) => {
+      if (!finished || held.current || routes.current === void 0) return;
+      const scene = optsRef.current.scene;
+      for (const [id, data] of routeWrites(scene, routes.current)) scene.update(id, { data });
+    },
+    ...opts.label ? { label: opts.label } : {},
+    ...opts.requestFrame ? { requestFrame: opts.requestFrame } : {},
+    ...opts.cancelFrame ? { cancelFrame: opts.cancelFrame } : {}
+  });
+  const build = useCallback(() => {
+    const graph = graphOf(optsRef.current);
+    shape.current = shapeOf(graph);
+    const plan = planFor(graph, optsRef.current);
+    if (plan === null || !isPromise(plan)) {
+      install(graph, plan);
+      return true;
+    }
+    pending.request(plan, (answer) => {
+      if (!sameGraph(graph, graphOf(optsRef.current))) return;
+      install(graph, answer);
+      run.start();
+    }, (error) => {
+      const onError = optsRef.current.onError;
+      if (onError) onError(error);
+      else console.error(error);
+    });
+    return false;
+  }, [optsRef, install, pending, run]);
+  const restart = useCallback(() => {
+    pending.drop();
+    run.cancel();
+    if (build()) run.start();
+  }, [pending, run, build]);
+  useEffect(() => {
+    if (opts.reheatOnGraphChange === false) return;
+    return opts.scene.subscribe(() => {
+      if (!run.isRunning() && !pending.isWaiting()) return;
+      if (shapeOf(graphOf(optsRef.current)) === shape.current) return;
+      if (typeof optsRef.current.algorithm === "object") restart();
+      else build();
+    });
+  }, [opts.scene, opts.reheatOnGraphChange, run, build, restart, pending, optsRef]);
+  return useMemo(() => ({
+    start() {
+      if (run.isRunning() || pending.isWaiting()) return;
+      if (build()) run.start();
+    },
+    stop: () => {
+      pending.drop();
+      run.stop();
+    },
+    cancel: () => {
+      pending.drop();
+      run.cancel();
+      eased.drop();
+    },
+    restart,
+    isRunning: () => run.isRunning() || pending.isWaiting()
+  }), [run, build, restart, eased, pending]);
+}
+var EASED_LAYOUTS = Object.freeze({
+  layered,
+  tree,
+  chain
+});
+function diagramShape(opts = {}) {
+  const geometry = opts.geometry ?? RECT_POSE_DESCRIPTOR;
+  const outlineOf = (node) => diagramNodeOf(node, opts.read)?.outline ?? laneOutlineOf(node);
+  return {
+    id: opts.id ?? "diagram:outline",
+    matches: (node) => outlineOf(node) !== void 0,
+    paint: (node, pose) => {
+      const outline = outlineOf(node);
+      if (outline === void 0) return [];
+      const d = node.data;
+      const box = geometry.getBounds(pose);
+      const declaredFill = d.fill === void 0 ? opts.defaultFill : d.fill;
+      const declaredStroke = d.stroke === void 0 ? opts.defaultStroke : d.stroke;
+      const fill = declaredFill && commandFill(declaredFill, box);
+      const stroke = declaredStroke && commandStroke(declaredStroke, box);
+      const header = headerBox(box, diagramContainerOf(node)?.header);
+      const divider = header === null || !stroke ? [] : [{ kind: "path", path: dividerPath(box, header), stroke }];
+      return [{
+        kind: "path",
+        path: outlinePath(outline, box),
+        ...fill ? { fill } : {},
+        ...stroke ? { stroke } : {}
+      }, ...divider];
+    },
+    // The drawn boundary, so picking and clipping follow the diamond rather
+    // than its bounding box.
+    silhouette: (node, pose) => {
+      const outline = outlineOf(node);
+      return outline === void 0 ? null : outlinePath(outline, geometry.getBounds(pose));
+    }
+  };
+}
+function dividerPath(box, header) {
+  return header.width < box.width ? polylineFromPoints([{ x: header.x + header.width, y: box.y }, { x: header.x + header.width, y: box.y + box.height }]) : polylineFromPoints([{ x: box.x, y: header.y + header.height }, { x: box.x + box.width, y: header.y + header.height }]);
+}
+function registerDiagramShape(opts = {}) {
+  return registerNodeShape(diagramShape(opts), { priority: "high" });
+}
+function useMirroredSelection(selection, selected, onSelect) {
+  const want = selected ?? null;
+  const pushed = useRef(void 0);
+  useEffect(() => {
+    if (pushed.current === want) return;
+    pushed.current = want;
+    if ((selection.get()[0] ?? null) !== want) selection.set(want === null ? [] : [want]);
+  }, [want]);
+  const onSelectRef = useLatest(onSelect);
+  return useCallback(() => {
+    onSelectRef.current?.(selection.get()[0] ?? null);
+  }, [selection, onSelectRef]);
+}
+
+// src/regionSync.ts
+function laneList(scene, poolId) {
+  const pool = scene.get(poolId);
+  const trait = pool === void 0 ? null : diagramContainerOf(pool);
+  if (trait === null) return [];
+  const axis = poolAxisOf(trait);
+  return lanesOf(scene, poolId).map((id) => {
+    const p = scene.get(id).pose;
+    return { id, size: axis === "y" ? p.height : p.width };
+  });
+}
+function readRegions(scene) {
+  const regions = /* @__PURE__ */ new Map();
+  const pools = /* @__PURE__ */ new Map();
+  for (const n of scene.renderOrderNodes()) {
+    const trait = diagramContainerOf(n);
+    if (trait === null) continue;
+    const { x, y, width, height } = n.pose;
+    regions.set(n.id, { box: { x, y, width, height }, parent: n.parent, fitted: trait.fitted === true });
+    if (trait.role === "pool") pools.set(n.id, laneList(scene, n.id));
+  }
+  return { regions, pools };
+}
+var sameBox = (a, b) => a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+var sameLanes = (a, b) => a.length === b.length && a.every((l, i) => l.id === b[i].id && l.size === b[i].size);
+function regionChanges(was, now) {
+  const out = [];
+  const changed = /* @__PURE__ */ new Set();
+  for (const [id, at] of now.regions) {
+    const before = was.regions.get(id);
+    if (before !== void 0 && (!sameBox(before.box, at.box) || before.parent !== at.parent)) changed.add(id);
+  }
+  const carried = (id) => {
+    for (let p = now.regions.get(id)?.parent ?? null; p !== null; p = now.regions.get(p)?.parent ?? null) {
+      if (changed.has(p)) return true;
+    }
+    return false;
+  };
+  for (const id of changed) {
+    const at = now.regions.get(id);
+    const before = was.regions.get(id);
+    if (now.pools.has(at.parent ?? "")) continue;
+    if (at.fitted && before.parent === at.parent && carried(id)) continue;
+    out.push({ kind: "box", id, box: at.box, ...before.parent !== at.parent ? { parent: at.parent } : {} });
+  }
+  for (const [pool, lanes] of now.pools) {
+    const before = was.pools.get(pool);
+    if (before !== void 0 && !sameLanes(before, lanes)) out.push({ kind: "lanes", pool, lanes });
+  }
+  return out;
+}
+
+// src/sceneSync.ts
+var NONE = [];
+var laidPort = (end) => end.laidOut !== void 0 && end.port === end.laidOut ? end.laidOut : void 0;
+function portsOf2(from, to) {
+  const f = laidPort(from);
+  const t = laidPort(to);
+  return { ...f !== void 0 ? { from: f } : {}, ...t !== void 0 ? { to: t } : {} };
+}
+var samePorts = (a, b) => a.from === b.from && a.to === b.to;
+var routeOf2 = (edge) => ({ waypoints: edge.waypoints ?? NONE, ports: portsOf2(edge.from, edge.to) });
+function readScene(scene) {
+  const nodes = /* @__PURE__ */ new Map();
+  const routes = /* @__PURE__ */ new Map();
+  for (const n of scene.renderOrderNodes()) {
+    if (n.kind === "container") {
+      if (diagramContainerOf(n) === null) nodes.set(n.id, { x: n.pose.x, y: n.pose.y, parent: n.parent });
+      continue;
+    }
+    const edge = diagramEdgeOf(n);
+    if (edge !== null) routes.set(n.id, routeOf2(edge));
+  }
+  return { nodes, routes, regions: readRegions(scene) };
+}
+function diagramLayoutOf(specs) {
+  const moves = [];
+  const routes = [];
+  const containers = [];
+  for (const s of specs) {
+    const id = s.id;
+    if (id === void 0) continue;
+    if (s.kind === "container") {
+      const region = diagramContainerOf(s);
+      const pinned = isPinned({ id, kind: s.kind, data: s.data });
+      if (region !== null) {
+        if (!pinned && region.role !== "lane" && region.fitted !== true) {
+          const { x, y, width, height } = s.pose;
+          containers.push({ kind: "box", id, box: { x, y, width, height } });
+        }
+      } else if (diagramGroupOf(s) === null && !pinned) moves.push({ id, x: s.pose.x, y: s.pose.y });
+      continue;
+    }
+    const edge = diagramEdgeOf(s);
+    if (edge === null) continue;
+    const route = routeOf2(edge);
+    const laid = edge.laidOut !== void 0 && route.waypoints.length > 0 && layoutOwnsRoute(edge);
+    if (laid || route.ports.from !== void 0 || route.ports.to !== void 0) {
+      routes.push({ id, waypoints: laid ? route.waypoints : NONE, ports: route.ports });
+    }
+  }
+  return { moves, routes, containers };
+}
+function changes(was, now) {
+  const moves = [];
+  for (const [id, { x, y, parent }] of now.nodes) {
+    const before = was.nodes.get(id);
+    if (before === void 0) continue;
+    const reparented = before.parent !== parent;
+    if (before.x !== x || before.y !== y || reparented) moves.push({ id, x, y, ...reparented ? { parent } : {} });
+  }
+  const routes = [];
+  for (const [id, after] of now.routes) {
+    const before = was.routes.get(id);
+    if (before === void 0) continue;
+    const moved = before.waypoints !== after.waypoints && !samePoints(before.waypoints, after.waypoints);
+    if (moved || !samePorts(before.ports, after.ports)) routes.push({ id, ...after });
+  }
+  return { moves, routes, containers: regionChanges(was.regions, now.regions) };
+}
+function useSceneSync(scene, specs, reports) {
+  const reportsRef = useLatest(reports);
+  const syncing = useRef(false);
+  const applied = useRef(specs);
+  useEffect(() => {
+    let known = readScene(scene);
+    return scene.subscribe(() => {
+      const now = readScene(scene);
+      const found = syncing.current ? null : changes(known, now);
+      known = now;
+      if (found === null) return;
+      if (found.moves.length > 0 || found.routes.length > 0) reportsRef.current.onMove?.(found.moves, found.routes);
+      for (const edit of found.containers) reportsRef.current.onEditContainer?.(edit);
+    });
+  }, [scene, reportsRef]);
+  useEffect(() => {
+    if (applied.current === specs) return;
+    syncing.current = true;
+    try {
+      reconcileSpecs(scene, applied.current, specs);
+    } finally {
+      syncing.current = false;
+    }
+    applied.current = specs;
+  }, [scene, specs]);
+}
+
+// src/regionEditing.ts
+function laneResizeReports(scene, resize) {
+  const pool = poolsOf(scene).find((p) => p.id === resize.poolId);
+  const index = pool?.lanes.findIndex((l) => l.id === resize.laneId) ?? -1;
+  if (pool === void 0 || index < 0) return null;
+  const lanes = laneList(scene, pool.id).map((l) => l.id === resize.laneId ? { ...l, size: resize.size } : l);
+  const moves = [];
+  const boxes = [];
+  for (const [id, pose] of laneResizeFrame(scene, pool, index, resize.size)) {
+    const node = scene.get(id);
+    if (node === void 0) continue;
+    const region = diagramContainerOf(node);
+    const { x, y, width, height } = pose;
+    if (region !== null) {
+      if (region.role === "container" && region.fitted !== true) boxes.push({ kind: "box", id, box: { x, y, width, height } });
+    } else if (node.kind === "container" && dataKeyReader(node) !== null) moves.push({ id, x, y });
+  }
+  return { lanes: { kind: "lanes", pool: pool.id, lanes }, moves, boxes };
+}
+function regionEditing(scene, selected, reports) {
+  const edit = (e) => reports.current.onEditContainer?.(e);
+  const containers = diagramContainers({
+    scene,
+    selected,
+    commitResize: (resize) => {
+      const out = laneResizeReports(scene, resize);
+      if (out === null) return;
+      edit(out.lanes);
+      for (const box of out.boxes) edit(box);
+      if (out.moves.length > 0) reports.current.onMove?.(out.moves, []);
+    },
+    commitAddLane: (poolId) => {
+      const lanes = [...laneList(scene, poolId), { id: scene.mintId(), size: DEFAULT_LANE_SIZE }];
+      edit({ kind: "lanes", pool: poolId, lanes });
+    },
+    commitRelease: (id) => edit({ kind: "release", id })
+  });
+  const title = {
+    id: "weasel-diagram-container-title",
+    eligibility: { always: true },
+    actions: [editContainerTitleAction((id) => edit({ kind: "title", id }))],
+    bindings: [editContainerTitleBinding()]
+  };
+  return { layer: containers.layer, contributions: [containers.contribution, title] };
+}
+
+// src/diagramEditing.ts
+var AMBIENT = [dragPanContribution()];
+var NO_MARQUEE = { areaSelect: null };
+function regionAndMembers(scene, id, out) {
+  out.add(id);
+  for (const child of scene.childrenOf(id)) {
+    const node = scene.get(child);
+    if (node === void 0 || child === titleIdOf(id)) continue;
+    if (diagramContainerOf(node) !== null) regionAndMembers(scene, child, out);
+    else if (dataKeyReader(node) !== null) out.add(child);
+  }
+}
+function removedData(scene, ids) {
+  const nodes = /* @__PURE__ */ new Set();
+  const edges = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    const node = scene.get(id);
+    if (node === void 0) continue;
+    if (diagramEdgeOf(node) !== null) edges.add(id);
+    else if (diagramContainerOf(node) !== null) regionAndMembers(scene, id, nodes);
+    else if (dataKeyReader(node) !== null) nodes.add(id);
+  }
+  for (const node of scene.renderOrderNodes()) {
+    const ends = node.dependsOn;
+    if (diagramEdgeOf(node) !== null && Array.isArray(ends) && ends.some((end) => nodes.has(end))) edges.add(node.id);
+  }
+  return { nodes: [...nodes], edges: [...edges] };
+}
+function reportDeleteAction(report) {
+  return createDeleteAction({
+    commit: (ids, deps) => {
+      if (deps.scene === void 0) return;
+      const removed = removedData(deps.scene, ids);
+      if (removed.nodes.length > 0 || removed.edges.length > 0) report(removed);
+    }
+  });
+}
+function reportResizeAction(report, region) {
+  return createResizeAction({
+    commit: (poses, deps) => {
+      const picked = new Set(deps.selection?.get() ?? []);
+      const resizes = [];
+      for (const [id, pose] of poses) {
+        if (!picked.has(id)) continue;
+        const { x, y, width, height } = pose;
+        const node = deps.scene?.get(id);
+        if (node !== void 0 && diagramContainerOf(node) !== null) region?.({ kind: "box", id, box: { x, y, width, height } });
+        else resizes.push({ id, x, y, width, height });
+      }
+      if (resizes.length > 0) report?.(resizes);
+    }
+  });
+}
+var reconnectChangeOf = ({ edgeId, end, target }) => ({
+  edge: edgeId,
+  end,
+  node: target.nodeId,
+  ...isBodyEnd(target) ? {} : { port: target.id }
+});
+function withPickableEdges(specs) {
+  return specs.map((s) => diagramEdgeOf(s) !== null ? { ...s, pickable: true } : s);
+}
+function useDiagramEditing(props) {
+  const { scene, source, selected, mode, canConnect, portOptions, connectBodies } = props;
+  const report = useLatest(props);
+  const reconnects = props.onReconnect !== void 0;
+  const routes = props.onEditRoute !== void 0;
+  const labels = props.onEditLabel !== void 0;
+  const labelMoves = props.onMoveLabel !== void 0;
+  const deletes = props.onDelete !== void 0;
+  const reorders = props.onReorder !== void 0;
+  const resizes = props.onResize !== void 0;
+  const regionEdits = props.onEditContainer !== void 0;
+  const ports = useMemo(() => mode === "connect" ? diagramPorts({
+    ...portOptions,
+    participants: source,
+    bodies: connectBodies === true,
+    ...canConnect ? { canConnect } : {},
+    commit: ({ from, to }) => report.current.onConnect?.({
+      from: from.nodeId,
+      ...isBodyEnd(from) ? {} : { fromPort: from.id },
+      to: to.nodeId,
+      ...isBodyEnd(to) ? {} : { toPort: to.id }
+    })
+  }) : null, [mode, source, canConnect, portOptions, connectBodies, report]);
+  const shown = useMemo(() => {
+    if (mode !== "show") return null;
+    const { hitTest: _hitTest, ...paintOnly } = portLayer(source, portOptions);
+    return paintOnly;
+  }, [mode, source, portOptions]);
+  const ends = useMemo(() => reconnects ? diagramEdgeEnds({
+    participants: source,
+    selected,
+    bodies: connectBodies === true,
+    ...canConnect ? { canConnect } : {},
+    ...portOptions?.snapRadius !== void 0 ? { snapRadius: portOptions.snapRadius } : {},
+    ...portOptions?.showsPort ? { showsPort: portOptions.showsPort } : {},
+    commit: (change) => report.current.onReconnect?.(reconnectChangeOf(change))
+  }) : null, [reconnects, source, selected, connectBodies, canConnect, portOptions, report]);
+  const route = useMemo(() => routes ? diagramWaypoints({
+    participants: source,
+    selected,
+    commit: ({ edgeId, waypoints }) => report.current.onEditRoute?.({ edge: edgeId, waypoints })
+  }) : null, [routes, source, selected, report]);
+  const labelDrag = useMemo(() => labelMoves ? diagramLabelDrag({
+    scene,
+    selected,
+    commit: ({ edgeId, placement }) => report.current.onMoveLabel?.({ edge: edgeId, placement })
+  }) : null, [labelMoves, scene, selected, report]);
+  const label = useMemo(() => labels ? {
+    id: "weasel-diagram-edge-label",
+    eligibility: { always: true },
+    actions: [editEdgeLabelAction({ commit: (edgeId) => report.current.onEditLabel?.(edgeId) })],
+    bindings: [editEdgeLabelBinding()]
+  } : null, [labels, report]);
+  const reorder = useMemo(
+    () => reorders ? groupReorderContribution((change) => report.current.onReorder?.(change)) : null,
+    [reorders, report]
+  );
+  const regions = useMemo(() => regionEdits ? regionEditing(scene, selected, report) : null, [regionEdits, scene, selected, report]);
+  const actions = useMemo(() => ({
+    ...NO_MARQUEE,
+    ...deletes ? { delete: reportDeleteAction((r) => report.current.onDelete?.(r)) } : {},
+    ...resizes || regionEdits ? { resize: reportResizeAction((r) => report.current.onResize?.(r), (e) => report.current.onEditContainer?.(e)) } : {}
+  }), [deletes, resizes, regionEdits, report]);
+  const portsLayer = ports?.layer ?? shown;
+  const layers = useMemo(
+    // Edge ends last: an edge's end sits on a port and beside a route handle, and the last layer is hit first.
+    () => [regions?.layer, labelDrag?.layer, portsLayer, route?.layer, ends?.layer].filter((l) => l != null),
+    [regions, labelDrag, portsLayer, route, ends]
+  );
+  const extra = props.ambient;
+  const ambient = useMemo(() => [
+    ...AMBIENT,
+    ...[ports?.contribution, route?.contribution, ends?.contribution, labelDrag?.contribution, label, reorder].filter((c) => c != null),
+    ...regions?.contributions ?? [],
+    ...extra ?? []
+  ], [ports, route, ends, labelDrag, label, reorder, regions, extra]);
+  return { layers, ambient, actions };
+}
+function usePagesView(pages) {
+  const placed = pages?.placed;
+  const fill = pages?.fill;
+  return useMemo(() => {
+    if (placed === void 0 || fill === void 0) return { layers: void 0, box: void 0 };
+    return {
+      layers: { pages: { layer: pagesLayer(placed, { fill }), before: "scene" } },
+      box: pagesBounds(placed) ?? void 0
+    };
+  }, [placed, fill]);
+}
+var VIEW_RULE = ':where([data-wzl-diagram]) { position: relative; width: fit-content; } :where([data-wzl-diagram~="fill-x"]) { width: 100%; } :where([data-wzl-diagram~="fill-y"]) { height: 100%; } :where([data-wzl-diagram]) > canvas { display: block; } :where([data-wzl-diagram-overlay]) { position: absolute; left: 0; top: 0; } :where([data-wzl-diagram-overlay][hidden]) { display: none; }';
+var adoptViewRule = (el) => {
+  if (el !== null) adoptCssOnce(el, VIEW_RULE);
+};
+var IDENTITY = { x: 0, y: 0, scale: { x: 1, y: 1 } };
+var sameView = (a, b) => a.x === b.x && a.y === b.y && a.scale.x === b.scale.x && a.scale.y === b.scale.y;
+var DiagramView = forwardRef(function DiagramView2(props, ref) {
+  return /* @__PURE__ */ jsx(WeaselProvider, { children: /* @__PURE__ */ jsx(Inner, { ...props, apiRef: ref }) });
+});
+function Inner({
+  specs: given,
+  router,
+  labels,
+  hops,
+  width,
+  height,
+  selected,
+  onSelect,
+  onHover,
+  onMove,
+  onResize,
+  onConnect,
+  onReconnect,
+  onEditRoute,
+  onDelete,
+  onEditLabel,
+  onMoveLabel,
+  onReorder,
+  onEditContainer,
+  connectBodies,
+  pickEdges,
+  overlays = NO_OVERLAYS,
+  ambient: extraAmbient,
+  enableKeybindings,
+  canConnect,
+  portOptions,
+  ports: portMode,
+  live: liveOpts,
+  minScale,
+  maxScale,
+  anchor,
+  fitPadding,
+  background,
+  pages,
+  view,
+  onViewChange,
+  className,
+  apiRef
+}) {
+  const edgesPick = pickEdges ?? (onReconnect !== void 0 || onEditRoute !== void 0 || onDelete !== void 0 || onEditLabel !== void 0 || onMoveLabel !== void 0);
+  const avoid2 = useMemo(() => router === "avoid" ? createSpecRouter() : null, [router]);
+  const placer = useMemo(() => labels === "dodge" ? createSpecLabelPlacer() : null, [labels]);
+  const routed = useMemo(() => {
+    const out = avoid2 === null ? given : avoid2(given);
+    return placer === null ? out : placer(out);
+  }, [avoid2, placer, given]);
+  const hopped = useMemo(() => hops === void 0 ? routed : createSpecHops(hops)(routed), [hops, routed]);
+  const specs = useMemo(() => edgesPick ? withPickableEdges(hopped) : hopped, [edgesPick, hopped]);
+  useEffect(() => {
+    const disposers = [registerDiagramShape(), registerMarkShape()];
+    return () => disposers.forEach((dispose) => dispose());
+  }, []);
+  const registry = useMemo(() => withDiagramRegistry(), []);
+  const scene = useScene({
+    systemLayers: [{ id: "main" }],
+    initial: specs,
+    registry
+  });
+  const selection = useSelection({ scene, mode: "single" });
+  const onClick = useMirroredSelection(selection, selected, onSelect);
+  useSceneSync(scene, specs, { onMove, onEditContainer });
+  const source = useMemo(() => sceneParticipants(scene), [scene]);
+  const [run, setRun] = useState(null);
+  const controlled = view !== void 0;
+  const fills = width === void 0 || height === void 0;
+  const [measured, setMeasured] = useState(null);
+  const boxWidth = width ?? measured?.width ?? 0;
+  const boxHeight = height ?? measured?.height ?? 0;
+  const unsized = boxWidth === 0 || boxHeight === 0;
+  const fitOpts = { minScale, maxScale, anchor, padding: fitPadding };
+  const { layers, box: pagesBox } = usePagesView(pages);
+  const defaultView = useMemo(
+    () => controlled || unsized ? void 0 : fitDiagram(specs, { width: boxWidth, height: boxHeight }, fitOpts, pagesBox),
+    // A later `specs` keeps the view it has.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [controlled, unsized, boxWidth, boxHeight, minScale, maxScale, anchor, fitPadding, pagesBox]
+  );
+  const [settledFit, setSettledFit] = useState(null);
+  const fit = settledFit !== null && settledFit.over === defaultView ? settledFit.view : defaultView;
+  const settled = useLatest((moved) => {
+    liveOpts?.onSettle?.(moved);
+    if (controlled || moved === 0) return;
+    const boxes = Array.from(source(), ({ node, pose }) => ({ ...node, pose }));
+    setSettledFit({ view: fitDiagram(boxes, { width: boxWidth, height: boxHeight }, fitOpts, pagesBox), over: defaultView });
+  });
+  const live = useLiveLayout({
+    ...liveOpts,
+    scene,
+    source,
+    algorithm: run?.algorithm ?? "force",
+    onSettle: (moved) => settled.current(moved)
+  });
+  useEffect(() => {
+    if (run !== null) live.restart();
+  }, [run, live]);
+  const canvasRef = useRef(null);
+  useDiagramApi(apiRef, canvasRef, scene, live, setRun);
+  const selectedIds = useCallback(() => selection.get(), [selection]);
+  const editing = useDiagramEditing({
+    scene,
+    source,
+    selected: selectedIds,
+    mode: portMode ?? (onConnect !== void 0 ? "connect" : "none"),
+    onConnect,
+    onReconnect,
+    onEditRoute,
+    onDelete,
+    onEditLabel,
+    onMoveLabel,
+    onReorder,
+    onResize,
+    onEditContainer,
+    onMove,
+    connectBodies,
+    canConnect,
+    portOptions,
+    ambient: extraAmbient
+  });
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (canvas === null) return;
+    const disposers = editing.layers.map((layer) => canvas.registerLayer(layer));
+    return () => disposers.forEach((dispose) => dispose());
+  }, [editing.layers]);
+  const moves = onMove !== void 0 || onEditContainer !== void 0;
+  const resizes = onResize !== void 0 || onEditContainer !== void 0;
+  const edits = moves || onConnect !== void 0 || onReorder !== void 0 || resizes || edgesPick;
+  const features = useMemo(() => ["view", "pick", ...moves ? ["move"] : [], ...resizes ? ["resize"] : []], [moves, resizes]);
+  const selectTool = useMemo(() => ({ resize: { resizable: diagramResizable(scene) } }), [scene]);
+  useRefit(canvasRef, fit);
+  const overlayRef = useOverlayPlacement(canvasRef, scene, overlays);
+  const fillsOn = [width === void 0 ? "fill-x" : "", height === void 0 ? "fill-y" : ""].join(" ").trim();
+  return /* @__PURE__ */ jsxs("div", { ref: adoptViewRule, "data-wzl-diagram": fillsOn, className, children: [
+    /* @__PURE__ */ jsx(
+      SceneCanvas,
+      {
+        ref: canvasRef,
+        scene,
+        selection,
+        features,
+        ...resizes ? { selectTool } : {},
+        enableKeybindings: enableKeybindings ?? edits,
+        ambient: editing.ambient,
+        actions: editing.actions,
+        onClick,
+        ...onHover ? { onHover } : {},
+        width,
+        height,
+        ...fills ? { onResize: setMeasured } : {},
+        ...defaultView ? { defaultView } : {},
+        ...view ? { view } : {},
+        ...onViewChange ? { onViewChange } : {},
+        ...background ? { backgroundFill: background } : {},
+        ...layers ? { layers } : {},
+        children: /* @__PURE__ */ jsx(DropRules, { scene })
+      }
+    ),
+    overlays.map((o) => {
+      const key = o.key ?? o.target;
+      return /* @__PURE__ */ jsx("div", { ref: overlayRef(key), "data-wzl-diagram-overlay": "", children: o.content }, key);
+    })
+  ] });
+}
+var NO_OVERLAYS = [];
+function DropRules({ scene }) {
+  const canDropInto = useMemo(() => diagramCanDropInto(scene), [scene]);
+  useDepSource("canDropInto", () => canDropInto);
+  return null;
+}
+function useDiagramApi(apiRef, canvasRef, scene, live, setRun) {
+  useImperativeHandle(apiRef, () => ({
+    layout: (algorithm = "force") => setRun({ algorithm }),
+    live,
+    worldAt: (clientX, clientY) => {
+      const [x, y] = canvasRef.current?.clientToWorld(clientX, clientY) ?? [clientX, clientY];
+      return { x, y };
+    },
+    visible: () => {
+      const canvas = canvasRef.current;
+      const r = canvas?.element?.getBoundingClientRect();
+      if (canvas == null || r === void 0 || r.width === 0 || r.height === 0) return null;
+      const [x0, y0] = canvas.clientToWorld(r.left, r.top);
+      const [x1, y1] = canvas.clientToWorld(r.right, r.bottom);
+      return { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+    },
+    rectOf: (id) => {
+      const canvas = canvasRef.current;
+      const world = worldRectOf(scene, id);
+      const r = canvas?.element?.getBoundingClientRect();
+      if (canvas == null || world === null || r === void 0) return null;
+      const rect = screenRectOf(world, canvas.getView());
+      return { ...rect, x: rect.x + r.left, y: rect.y + r.top };
+    },
+    subscribeFrame: (fn) => canvasRef.current?.subscribeFrame(() => fn()) ?? (() => {
+    })
+  }), [canvasRef, live, scene, setRun]);
+}
+function useRefit(canvasRef, fit) {
+  const fitted = useRef(fit);
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    const was = fitted.current;
+    if (canvas === null || fit === void 0 || was === fit) return;
+    if (!sameView(canvas.getView(), was ?? IDENTITY)) return;
+    fitted.current = fit;
+    canvas.setView(fit);
+  }, [canvasRef, fit]);
+}
+function fitDiagram(specs, size, fit = {}, extra) {
+  const boxes = specs.filter((s) => s.kind === "container" || diagramGroupOf(s) !== null).map((s) => s.pose);
+  if (extra !== void 0) boxes.push({ ...extra });
+  if (boxes.length === 0) return void 0;
+  const x = Math.min(...boxes.map((b) => b.x));
+  const y = Math.min(...boxes.map((b) => b.y));
+  const bounds = {
+    x,
+    y,
+    width: Math.max(...boxes.map((b) => b.x + b.width)) - x,
+    height: Math.max(...boxes.map((b) => b.y + b.height)) - y
+  };
+  return fitViewToBounds(bounds, size, { x: 0, y: 0, scale: { x: 1, y: 1 } }, {
+    maxScale: fit.maxScale ?? 1,
+    ...fit.minScale !== void 0 ? { minScale: fit.minScale } : {},
+    ...fit.anchor !== void 0 ? { anchor: fit.anchor } : {},
+    ...fit.padding !== void 0 ? { padding: fit.padding } : {}
+  });
+}
+
+export { ADD_LANE_ACTION_ID, ANYWHERE, CONNECT_ACTION_ID, CONTAINER_STENCILS, DEFAULT_EDGE_STROKE, DiagramView, EASED_LAYOUTS, EDGE_END_AFFORDANCE_KIND, EDGE_END_LAYER_ID, EDIT_CONTAINER_TITLE_ACTION_ID, GRAB_EDGE_END_ACTION_ID, GRAB_LABEL_ACTION_ID, GRAB_PORT_ACTION_ID, GRAB_WAYPOINT_ACTION_ID, LANE_AFFORDANCE_KIND, LANE_LAYER_ID, LANE_RESIZE_ACTION_ID, LAYOUTS, LAYOUT_ACTION_ID, MOVE_LABEL_ACTION_ID, PORT_AFFORDANCE_KIND, PORT_LAYER_ID, RECONNECT_ACTION_ID, RELEASE_MEMBERS_ACTION_ID, REMOVE_WAYPOINT_ACTION_ID, REORDER_ACTION_ID, RESET_LABEL_ACTION_ID, RESET_ROUTE_ACTION_ID, ROUTER_LABELS, ROUTE_EDIT_ACTION_ID, SELECT_LABEL_EDGE_ACTION_ID, SET_HOPS_ACTION_ID, SET_ROUTER_ACTION_IDS, STEP_REORDER_ACTION_ID, WAYPOINT_AFFORDANCE_KIND, WAYPOINT_HIT_PX, WAYPOINT_LAYER_ID, addLane, applyLayout, avoidSceneInput, bodyAt, commitEdgeToScene, commitLabelToScene, commitLaneResizeToScene, commitReconnectToScene, commitRouteToScene, commitRouterToScene, connectBinding, containerBuild, createAddLaneAction, createConnectAction, createDiagramContribution, createEdgeEndAffordance, createLabelDragAction, createLaneAffordance, createLaneResizeAction, createLayoutAction, createPortAffordance, createReconnectAction, createReleaseMembersAction, createRemoveWaypointAction, createReorderAction, createResetLabelAction, createResetRouteAction, createRouteEditAction, createSetHopsAction, createSetRouterAction, createSpecHops, createSpecLabelPlacer, createSpecRouter, createStepReorderAction, createWaypointAffordance, defaultCanConnect, diagramCanDropInto, diagramContainers, diagramDropParentAt, diagramEdgeEnds, diagramLabelDrag, diagramLayoutOf, diagramPorts, diagramResizable, diagramShape, diagramWaypoints, dragSegment, dragVertex, easedProducer, edgeEndLayer, edgeEndScratchOf, edgePolylines, editContainerTitleAction, editContainerTitleBinding, forceProducer, grabPortAction, grabPortBindings, groupReorderContribution, groupReorderSlots, headerIdOf, hopDataOps, inOrUnder, insertWaypoint, isBodyEnd, laneLayer, laneResizeFrame, laneScratchOf, lanesOf, layoutPoses, movedLabelData, pinSegment, poolAxisOf, poolsOf, portLayer, portScratchOf, reconnectBinding, regionHeaderAt, registerDiagramShape, releaseMembers, removeSegment, removeWaypoint, reorderBinding, reorderContribution, routeHandles, routeStateOf, routeWrites, routedData, routerActions, routesOf, sceneEdges, sceneParticipants, segmentAxis, sequenceSlots, themeWrites, unpinSegment, useLiveLayout, useMirroredSelection, waypointLayer, waypointScratchOf, withHopsData, withRouter };
+//# sourceMappingURL=chunk-CI3I3I6T.js.map
+//# sourceMappingURL=chunk-CI3I3I6T.js.map