@weasel-js/diagram 1.11.0 → 1.12.0

package/dist/chunk-C4NAI6NV.js

@@ -1,2041 +0,0 @@
-import { grownBy, isPromise, DIAGRAM_TRAIT_KEY, insetOf, portsOf, portSitesOf, outlinePath, plannerPlan, planOf, layered, diagramNodeOf, forceRelaxation, center, expandGroupEdges, chain, force, tree, DEFAULT_GROUP_INSET, sizeToBody, measureBody, bodyTrait, authoredOver, isPinned, buildBody } from './chunk-NUMMW5BI.js';
-import { dragPanContribution, WeaselProvider, useScene, useSelection, useLatest, SceneCanvas, fitViewToBounds, AUTO_POSE_DESCRIPTOR, translatePoseViaDescriptor, polylineFromPoints, registerNodeShape, reconcileSpecs, nodeGates, effectivePose, usePoseRun, composeAffordanceLayer, pointAlongPath, RECT_POSE_DESCRIPTOR, commandFill, commandStroke, transformPath, pathFromD, paintsLayer, viewToTransform, ellipsePath, derivedDepOf } from '@weasel-js/core';
-import { forEachSegment, PATH_L, nearestOnLine, PATH_Q, nearestOnQuadratic, PATH_C, nearestOnCubic, portCurvePoints } from '@weasel-js/geom';
-import { AUTO_POSE_DESCRIPTOR as AUTO_POSE_DESCRIPTOR$1 } from '@weasel-js/core/math';
-import '@weasel-js/animator';
-import { forwardRef, useEffect, useMemo, useState, useImperativeHandle, useRef, useCallback } from 'react';
-import { jsx } from 'react/jsx-runtime';
-
-function traitOf(node) {
-  const data = node.data;
-  if (data === null || typeof data !== "object") return null;
-  const trait = data[DIAGRAM_TRAIT_KEY];
-  return trait !== null && typeof trait === "object" ? trait : null;
-}
-function diagramGroupOf(node) {
-  const group = traitOf(node)?.group;
-  return group !== null && typeof group === "object" ? group : null;
-}
-function diagramAnchorOf(node) {
-  const anchor = traitOf(node)?.anchor;
-  return anchor !== null && typeof anchor === "object" && "at" in anchor ? anchor : null;
-}
-function groupDerivePose(opts = {}) {
-  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
-  return (node, deps) => {
-    const group = diagramGroupOf(node);
-    if (group === null) return null;
-    let x0 = Infinity;
-    let y0 = Infinity;
-    let x1 = -Infinity;
-    let y1 = -Infinity;
-    for (const dep of deps) {
-      if (dep === void 0) continue;
-      const b = grownBy(geometry.getBounds(dep.pose), traitOf(dep.node)?.margin);
-      x0 = Math.min(x0, b.x);
-      y0 = Math.min(y0, b.y);
-      x1 = Math.max(x1, b.x + b.width);
-      y1 = Math.max(y1, b.y + b.height);
-    }
-    if (!Number.isFinite(x0)) return null;
-    return geometry.fromBounds(boxAround({ x: x0, y: y0, width: x1 - x0, height: y1 - y0 }, group), node.pose);
-  };
-}
-function boxAround(union, group) {
-  const inset = insetOf(group.inset);
-  const width = union.width + inset.left + inset.right;
-  const grow = Math.max(0, (group.minWidth ?? 0) - width);
-  return {
-    x: union.x - inset.left - grow / 2,
-    y: union.y - inset.top,
-    width: width + grow,
-    height: union.height + inset.top + inset.bottom
-  };
-}
-function anchorDerivePose(opts = {}) {
-  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
-  return (node, deps) => {
-    const anchor = diagramAnchorOf(node);
-    const dep = deps[0];
-    if (anchor === null || dep === void 0) return null;
-    const target = geometry.getBounds(dep.pose);
-    const own = geometry.getBounds(node.pose);
-    const self = anchor.self ?? anchor.at;
-    const x = target.x + anchor.at.u * target.width + (anchor.offset?.x ?? 0) - self.u * own.width;
-    const y = target.y + anchor.at.v * target.height + (anchor.offset?.y ?? 0) - self.v * own.height;
-    return translatePoseViaDescriptor(node.pose, x - own.x, y - own.y, geometry);
-  };
-}
-var DIAGRAM_GROUP = "diagram:group";
-var DIAGRAM_ANCHOR = "diagram:anchor";
-var GROUP_DERIVE_POSE = groupDerivePose();
-var ANCHOR_DERIVE_POSE = anchorDerivePose();
-
-// src/labelTrait.ts
-function diagramLabelOf(node) {
-  const data = node.data;
-  if (data === null || typeof data !== "object") return null;
-  const trait = data.diagram;
-  if (trait === null || typeof trait !== "object") return null;
-  const label = trait.label;
-  if (label === null || typeof label !== "object") return null;
-  return "at" in label ? label : null;
-}
-var NAMED = { start: 0, mid: 0.5, end: 1 };
-function nearestStation(path, near2) {
-  if (path.kind !== "polygon") return null;
-  const { commands, coords } = path;
-  let best = null;
-  let heading = { x: 1, y: 0 };
-  forEachSegment(commands, coords, (cmd, ci, x0, y0) => {
-    let hit;
-    let d;
-    if (cmd === PATH_L) {
-      hit = nearestOnLine(near2.x, near2.y, x0, y0, coords[ci], coords[ci + 1]);
-      d = { x: coords[ci] - x0, y: coords[ci + 1] - y0 };
-    } else if (cmd === PATH_Q) {
-      hit = nearestOnQuadratic(near2.x, near2.y, x0, y0, coords[ci], coords[ci + 1], coords[ci + 2], coords[ci + 3]);
-      const t = hit.t;
-      d = {
-        x: 2 * (1 - t) * (coords[ci] - x0) + 2 * t * (coords[ci + 2] - coords[ci]),
-        y: 2 * (1 - t) * (coords[ci + 1] - y0) + 2 * t * (coords[ci + 3] - coords[ci + 1])
-      };
-    } else if (cmd === PATH_C) {
-      hit = nearestOnCubic(
-        near2.x,
-        near2.y,
-        x0,
-        y0,
-        coords[ci],
-        coords[ci + 1],
-        coords[ci + 2],
-        coords[ci + 3],
-        coords[ci + 4],
-        coords[ci + 5]
-      );
-      const t = hit.t;
-      const u = 1 - t;
-      d = {
-        x: 3 * u * u * (coords[ci] - x0) + 6 * u * t * (coords[ci + 2] - coords[ci]) + 3 * t * t * (coords[ci + 4] - coords[ci + 2]),
-        y: 3 * u * u * (coords[ci + 1] - y0) + 6 * u * t * (coords[ci + 3] - coords[ci + 1]) + 3 * t * t * (coords[ci + 5] - coords[ci + 3])
-      };
-    } else return;
-    const len = Math.hypot(d.x, d.y);
-    if (len === 0 || best !== null && hit.dist >= best.dist) return;
-    best = hit;
-    heading = { x: d.x / len, y: d.y / len };
-  });
-  const found = best;
-  return found === null ? null : { point: { x: found.x, y: found.y }, tangent: heading };
-}
-function labelCenter(path, label, size) {
-  const station = typeof label.at === "object" ? nearestStation(path, label.at.near) ?? pointAlongPath(path, 0.5) : pointAlongPath(path, typeof label.at === "number" ? label.at : NAMED[label.at] ?? 0.5);
-  if (station === null) return null;
-  const nx = station.tangent.y;
-  const ny = -station.tangent.x;
-  const offset = label.offset ?? 0;
-  const reach = offset + Math.sign(offset) * (Math.abs(nx) * size.width + Math.abs(ny) * size.height) / 2;
-  return { x: station.point.x + nx * reach, y: station.point.y + ny * reach };
-}
-function labelDerivePose(opts = {}) {
-  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
-  return (node, deps) => {
-    const label = diagramLabelOf(node);
-    if (label === null) return null;
-    const path = deps[0]?.path ?? null;
-    if (path === null) return null;
-    const bounds = geometry.getBounds(node.pose);
-    const center2 = labelCenter(path, label, bounds);
-    if (center2 === null) return null;
-    return translatePoseViaDescriptor(
-      node.pose,
-      center2.x - (bounds.x + bounds.width / 2),
-      center2.y - (bounds.y + bounds.height / 2),
-      geometry
-    );
-  };
-}
-var DIAGRAM_LABEL = "diagram:label";
-var LABEL_DERIVE_POSE = labelDerivePose();
-
-// src/selfLoop.ts
-var dot = (a, b) => a.x * b.x + a.y * b.y;
-function selfLoop(ports, standoff) {
-  const facing2 = ports.filter((p) => p.normal !== null);
-  const most = (dir, among) => among.reduce(
-    (best, p) => best === void 0 || dot(p.normal, dir) > dot(best.normal, dir) ? p : best,
-    void 0
-  );
-  const from = most({ x: 1, y: 0 }, facing2);
-  if (from === void 0) return null;
-  const to = most({ x: 0, y: -1 }, facing2.filter((p) => Math.abs(dot(p.normal, from.normal)) < 0.5));
-  if (to === void 0) return null;
-  const out = { x: from.point.x + from.normal.x * standoff, y: from.point.y + from.normal.y * standoff };
-  const reach = dot({ x: to.point.x - out.x, y: to.point.y - out.y }, to.normal) + standoff;
-  return { from, to, via: { x: out.x + to.normal.x * reach, y: out.y + to.normal.y * reach } };
-}
-
-// src/edgeTrait.ts
-function layoutOwnsPort(end) {
-  return end.port === void 0 || end.port === end.laidOut;
-}
-function layoutOwnsRoute(edge) {
-  const points = edge.waypoints ?? [];
-  if (points.length === 0) return true;
-  return edge.laidOut !== void 0 && samePoints(points, edge.laidOut);
-}
-function samePoints(a, b) {
-  return a.length === b.length && a.every((p, i) => p.x === b[i].x && p.y === b[i].y);
-}
-function diagramEdgeOf(node) {
-  const data = node.data;
-  if (data === null || typeof data !== "object") return null;
-  const edge = data.diagram;
-  if (edge === null || typeof edge !== "object") return null;
-  return "from" in edge && "to" in edge ? edge : null;
-}
-var straight = (req) => [req.from.point, ...req.waypoints, req.to.point];
-var orthogonal = (req) => {
-  const stops = [req.from.point, ...req.waypoints, req.to.point];
-  const out = [stops[0]];
-  for (let i = 1; i < stops.length; i++) {
-    const a = out[out.length - 1];
-    const b = stops[i];
-    if (a.x === b.x || a.y === b.y) {
-      out.push(b);
-      continue;
-    }
-    const leaveHorizontal = i === 1 ? isHorizontal(req.from.normal) : out.length > 1 && out[out.length - 2].y === a.y;
-    const arriving = i === stops.length - 1 ? req.to.normal : null;
-    const arriveHorizontal = arriving == null ? !leaveHorizontal : isHorizontal(arriving);
-    if (leaveHorizontal !== arriveHorizontal) {
-      out.push(leaveHorizontal ? { x: b.x, y: a.y } : { x: a.x, y: b.y });
-      out.push(b);
-      continue;
-    }
-    const prev = out.length > 1 ? out[out.length - 2] : null;
-    if (leaveHorizontal) {
-      const mid = (a.x + b.x) / 2;
-      if (prev !== null && (mid - a.x) * (a.x - prev.x) < 0) out.push({ x: a.x, y: b.y }, b);
-      else out.push({ x: mid, y: a.y }, { x: mid, y: b.y }, b);
-    } else {
-      const mid = (a.y + b.y) / 2;
-      if (prev !== null && (mid - a.y) * (a.y - prev.y) < 0) out.push({ x: b.x, y: a.y }, b);
-      else out.push({ x: a.x, y: mid }, { x: b.x, y: mid }, b);
-    }
-  }
-  return out;
-};
-function isHorizontal(normal) {
-  return Math.abs(normal?.x ?? 1) >= Math.abs(normal?.y ?? 0);
-}
-var bezier = (req) => {
-  const stops = [req.from.point, ...req.waypoints, req.to.point];
-  const out = [stops[0]];
-  for (let i = 1; i < stops.length; i++) {
-    const a = stops[i - 1];
-    const b = stops[i];
-    const outN = i === 1 ? req.from.normal : through(stops, i - 1);
-    const inN = i === stops.length - 1 ? req.to.normal : negated(through(stops, i));
-    const leg = portCurvePoints(
-      a.x,
-      a.y,
-      b.x,
-      b.y,
-      outN == null ? null : [outN.x, outN.y],
-      inN == null ? null : [inN.x, inN.y],
-      BEZIER_SAMPLES
-    );
-    for (const [x, y] of leg) out.push({ x, y });
-  }
-  return out;
-};
-var BEZIER_SAMPLES = 16;
-function through(stops, i) {
-  const last = stops.length - 1;
-  const run = (a, b) => a >= 1 && b <= last - 1 && (stops[a].x === stops[b].x || stops[a].y === stops[b].y);
-  const [from, to] = run(i, i + 1) ? [i, i + 1] : run(i - 1, i) ? [i - 1, i] : [i - 1, i + 1];
-  const dx = stops[to].x - stops[from].x;
-  const dy = stops[to].y - stops[from].y;
-  const len = Math.hypot(dx, dy);
-  return len === 0 ? null : { x: dx / len, y: dy / len };
-}
-var negated = (v) => v === null ? null : { x: -v.x, y: -v.y };
-var ROUTERS = Object.freeze({
-  straight,
-  orthogonal,
-  bezier
-});
-function resolveEnd(end, dep, toward, opts, allPorts) {
-  if (end.port !== void 0) {
-    const sites = portSitesOf(dep.node, dep.pose, end.port, opts);
-    const ahead = sites.filter((p) => p.normal !== null && p.normal.x * (toward.x - p.point.x) + p.normal.y * (toward.y - p.point.y) > 0);
-    if (sites.length > 0) return ahead.length > 0 ? facing(ahead, toward) : sites[0];
-  }
-  return facing(allPorts(dep), toward);
-}
-function facing(ports, toward) {
-  let best;
-  let bestScore = -Infinity;
-  for (const port of ports) {
-    const dx = toward.x - port.point.x;
-    const dy = toward.y - port.point.y;
-    const len = Math.hypot(dx, dy) || 1;
-    const aim = port.normal === null ? 0 : (port.normal.x * dx + port.normal.y * dy) / len;
-    const score = aim - len / 1e6;
-    if (score > bestScore) {
-      bestScore = score;
-      best = port;
-    }
-  }
-  return best;
-}
-function edgeDerivePath(opts = {}) {
-  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
-  const portOpts = { geometry, ...opts.read ? { read: opts.read } : {} };
-  const allPorts = (d) => portsOf(d.node, d.pose, portOpts);
-  const centerOf = (d) => {
-    const b = geometry.getBounds(d.pose);
-    return { x: b.x + b.width / 2, y: b.y + b.height / 2 };
-  };
-  const standoffOf = (d) => {
-    const b = geometry.getBounds(d.pose);
-    return Math.min(b.width, b.height) / 2;
-  };
-  return (node, deps) => {
-    const edge = diagramEdgeOf(node);
-    if (edge === null) return null;
-    const [fromDep, toDep] = deps;
-    if (fromDep === void 0 || toDep === void 0) return null;
-    const loop = fromDep.node.id === toDep.node.id && edge.from.port === void 0 && edge.to.port === void 0 ? selfLoop(allPorts(fromDep), opts.selfLoopStandoff ?? standoffOf(fromDep)) : null;
-    const authored = edge.waypoints ?? [];
-    const from = loop?.from ?? resolveEnd(edge.from, fromDep, authored[0] ?? centerOf(toDep), portOpts, allPorts);
-    const to = loop?.to ?? resolveEnd(edge.to, toDep, authored[authored.length - 1] ?? centerOf(fromDep), portOpts, allPorts);
-    if (from === void 0 || to === void 0) return null;
-    const waypoints = loop !== null && authored.length === 0 ? [loop.via] : authored;
-    const routers = opts.routers ?? ROUTERS;
-    const router = edge.router !== void 0 && routers[edge.router] || straight;
-    const points = router({ from, to, waypoints });
-    return points.length < 2 ? null : polylineFromPoints(points);
-  };
-}
-var DIAGRAM_EDGE = "diagram:edge";
-var EDGE_DERIVE_PATH = edgeDerivePath();
-function withDiagramRegistry(registry = {}) {
-  return {
-    ...registry,
-    derivePath: {
-      [DIAGRAM_EDGE]: EDGE_DERIVE_PATH,
-      ...registry.derivePath
-    },
-    derivePose: {
-      [DIAGRAM_LABEL]: LABEL_DERIVE_POSE,
-      [DIAGRAM_GROUP]: GROUP_DERIVE_POSE,
-      [DIAGRAM_ANCHOR]: ANCHOR_DERIVE_POSE,
-      ...registry.derivePose
-    }
-  };
-}
-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 paintOf = (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(paintOf(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;
-    }
-  };
-}
-var CONNECT_ACTION_ID = "diagram.connect";
-var defaultCanConnect = (from, to) => {
-  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) {
-  return [
-    { spec: { kind: "pointerDown", target: `affordance:${PORT_AFFORDANCE_KIND}` }, actionId },
-    { spec: { kind: "click", target: `affordance:${PORT_AFFORDANCE_KIND}` }, actionId }
-  ];
-}
-function commitEdgeToScene(edge, ctx) {
-  const scene = ctx.deps.scene;
-  if (scene === void 0) return;
-  const trait = {
-    from: { port: edge.from.id },
-    to: { port: edge.to.id },
-    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: 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 createConnectAction(opts) {
-  const {
-    id = CONNECT_ACTION_ID,
-    canConnect = defaultCanConnect,
-    snapRadius = DEFAULT_SNAP,
-    router: routerKey = DEFAULT_ROUTER,
-    commit = commitEdgeToScene
-  } = opts;
-  const routers = opts.routers ?? ROUTERS;
-  const portOpts = {
-    ...opts.geometry ? { geometry: opts.geometry } : {},
-    ...opts.read ? { read: opts.read } : {}
-  };
-  const route = routers[routerKey] ?? routers["straight"] ?? ROUTERS["straight"];
-  function targetPort(from, at, view) {
-    let best = null;
-    let bestD2 = snapRadius * 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 (!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 endAt(scratch, at) {
-    const port = targetPort(scratch.from, at, scratch.deps.view);
-    return {
-      port,
-      end: port ?? { id: "", nodeId: "", point: at, normal: null }
-    };
-  }
-  return {
-    id,
-    label: "Connect",
-    group: "diagram",
-    requires: ["scene"],
-    invoker: {
-      timing: "ongoing",
-      start(ctx) {
-        const pressed = portScratchOf(ctx.drag?.affordance);
-        if (pressed === null) return {};
-        const scratch = {
-          from: pressed.port,
-          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 { end } = endAt(scratch, scratch.current);
-            const points = route({ from: scratch.from, to: end, waypoints: [] });
-            if (points.length < 2) return null;
-            return { kind: "polyline", points, role: "connector" };
-          },
-          onEnd(endCtx, reason) {
-            scratch.open = false;
-            if (reason === "cancel") return;
-            const { port } = endAt(scratch, { x: endCtx.world.x, y: endCtx.world.y });
-            if (port === null) return;
-            commit(
-              { from: scratch.from, to: port, router: routerKey },
-              { ...endCtx, deps: scratch.deps }
-            );
-          }
-        };
-      }
-    },
-    enabled: () => true
-  };
-}
-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)]
-  );
-}
-
-// src/contribution.ts
-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)
-  };
-}
-
-// src/groupTree.ts
-function nestGroups(declared, isNode) {
-  const groupIds = new Set(declared.map((g) => g.id));
-  const parentOf = /* @__PURE__ */ new Map();
-  const claimedNodes = /* @__PURE__ */ new Set();
-  const direct = /* @__PURE__ */ new Map();
-  const isAncestorOrSelf = (candidate, of) => {
-    for (let at = of; at !== void 0; at = parentOf.get(at)) {
-      if (at === candidate) return true;
-    }
-    return false;
-  };
-  for (const group of declared) {
-    const own = [];
-    for (const id of group.members) {
-      if (isNode(id)) {
-        if (claimedNodes.has(id)) continue;
-        claimedNodes.add(id);
-        own.push(id);
-      } else if (groupIds.has(id) && !parentOf.has(id) && !isAncestorOrSelf(id, group.id)) {
-        parentOf.set(id, group.id);
-        own.push(id);
-      }
-    }
-    direct.set(group.id, own);
-  }
-  const flat = /* @__PURE__ */ new Map();
-  const flatten = (id) => {
-    const known = flat.get(id);
-    if (known !== void 0) return known;
-    const out = [];
-    for (const member of direct.get(id)) {
-      if (groupIds.has(member)) out.push(...flatten(member));
-      else out.push(member);
-    }
-    flat.set(id, out);
-    return out;
-  };
-  const live = new Set(declared.filter((g) => flatten(g.id).length > 0).map((g) => g.id));
-  return declared.filter((g) => live.has(g.id)).map((g) => {
-    const parent = parentOf.get(g.id);
-    return {
-      id: g.id,
-      direct: direct.get(g.id).filter((id) => !groupIds.has(id) || live.has(id)),
-      members: flat.get(g.id),
-      ...parent !== void 0 ? { parent } : {}
-    };
-  });
-}
-
-// src/graph.ts
-function buildGraph(source, opts = {}) {
-  const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR$1;
-  const nodes = [];
-  const byId = /* @__PURE__ */ new Map();
-  const candidates = [];
-  const groupNodes = [];
-  const routed = /* @__PURE__ */ new Set();
-  const rooms = /* @__PURE__ */ new Map();
-  for (const { node, pose } of source()) {
-    const edge = diagramEdgeOf(node);
-    if (edge !== null) {
-      const deps = node.dependsOn;
-      if (Array.isArray(deps) && deps.length === 2) {
-        candidates.push({
-          id: node.id,
-          from: deps[0],
-          to: deps[1],
-          ...edge.from.port !== void 0 ? { fromPort: edge.from.port } : {},
-          ...edge.to.port !== void 0 ? { toPort: edge.to.port } : {},
-          ...edge.waypoints !== void 0 && edge.waypoints.length > 0 ? { waypoints: edge.waypoints } : {},
-          ...layoutOwnsRoute(edge) ? {} : { authored: true }
-        });
-        if (layoutOwnsRoute(edge)) routed.add(node.id);
-      }
-      continue;
-    }
-    const label = diagramLabelOf(node);
-    if (label !== null) {
-      const deps = node.dependsOn;
-      if (Array.isArray(deps) && deps.length === 1 && labelFollowsLayout(label.at) && !rooms.has(deps[0])) {
-        const { width, height } = geometry.getBounds(pose);
-        rooms.set(deps[0], { width, height, ...label.offset ? { offset: label.offset } : {} });
-      }
-      continue;
-    }
-    const trait = diagramNodeOf(node, opts.read);
-    if (trait === null) continue;
-    if (trait.group !== void 0) {
-      const deps = node.dependsOn;
-      groupNodes.push({
-        id: node.id,
-        members: Array.isArray(deps) ? deps : [],
-        inset: insetOf(trait.group.inset),
-        ...trait.group.minWidth !== void 0 ? { minWidth: trait.group.minWidth } : {}
-      });
-      continue;
-    }
-    const entry = {
-      id: node.id,
-      bounds: geometry.getBounds(pose),
-      pinned: trait.pinned === true,
-      ...trait.ports !== void 0 ? { ports: trait.ports } : {},
-      ...trait.outline !== void 0 ? { outline: trait.outline } : {},
-      ...trait.margin !== void 0 ? { margin: trait.margin } : {}
-    };
-    nodes.push(entry);
-    byId.set(entry.id, entry);
-  }
-  const declared = new Map(groupNodes.map((g) => [g.id, g]));
-  const live = nestGroups(groupNodes, (id) => byId.has(id)).map((g) => {
-    for (const id of g.direct) {
-      const node = byId.get(id);
-      if (node !== void 0) node.group = g.id;
-    }
-    return {
-      id: g.id,
-      members: g.members,
-      inset: declared.get(g.id).inset,
-      ...declared.get(g.id).minWidth !== void 0 ? { minWidth: declared.get(g.id).minWidth } : {},
-      ...g.parent !== void 0 ? { parent: g.parent } : {}
-    };
-  });
-  const known = (id) => byId.has(id) || live.some((g) => g.id === id);
-  const roomed = candidates.map((e) => {
-    const room = rooms.get(e.id);
-    return room !== void 0 && routed.has(e.id) ? { ...e, label: room } : e;
-  });
-  const edges = expandGroupEdges(roomed.filter((e) => known(e.from) && known(e.to)), live);
-  const out = /* @__PURE__ */ new Map();
-  const into = /* @__PURE__ */ new Map();
-  for (const edge of edges) {
-    push(out, edge.from, edge);
-    push(into, edge.to, edge);
-  }
-  const NONE2 = Object.freeze([]);
-  return {
-    nodes,
-    edges,
-    groups: live,
-    node: (id) => byId.get(id),
-    outgoing: (id) => out.get(id) ?? NONE2,
-    incoming: (id) => into.get(id) ?? NONE2
-  };
-}
-function labelFollowsLayout(at) {
-  return at === "mid" || typeof at === "object";
-}
-function push(index, key, edge) {
-  const list = index.get(key);
-  if (list === void 0) index.set(key, [edge]);
-  else list.push(edge);
-}
-function diagramMarkOf(node) {
-  const data = node.data;
-  if (data === null || typeof data !== "object") return null;
-  const trait = data[DIAGRAM_TRAIT_KEY];
-  if (trait === null || typeof trait !== "object" || !("mark" in trait)) return null;
-  const mark = trait.mark;
-  return mark !== null && typeof mark === "object" && typeof mark.d === "string" ? mark : null;
-}
-var PARSED = /* @__PURE__ */ new Map();
-var PARSED_MAX = 256;
-function unitPath(d, onWarn) {
-  let path = PARSED.get(d);
-  if (path === void 0) {
-    let warned = false;
-    path = pathFromD(d, (message) => {
-      warned = true;
-      onWarn?.(message);
-    });
-    if (path.kind === "polygon" && path.commands.length === 0) onWarn?.("it draws nothing");
-    else if (!warned) {
-      if (PARSED.size >= PARSED_MAX) PARSED.clear();
-      PARSED.set(d, path);
-    }
-  }
-  return path;
-}
-function checkMarkPath(nodeId, index, d) {
-  unitPath(d, (message) => {
-    throw new Error(`diagramScene: node "${nodeId}", mark ${index}: path data ${JSON.stringify(d)} does not parse: ${message}`);
-  });
-}
-function markShape(opts = {}) {
-  const geometry = opts.geometry ?? RECT_POSE_DESCRIPTOR;
-  return {
-    id: "diagram:mark",
-    matches: (node) => diagramMarkOf(node) !== null,
-    paint: (node, pose) => {
-      const mark = diagramMarkOf(node);
-      if (mark === null) return [];
-      const box = geometry.getBounds(pose);
-      const d = node.data;
-      const fill = d.fill && commandFill(d.fill, box);
-      const stroke = d.stroke && commandStroke(d.stroke, box);
-      return [{
-        kind: "path",
-        path: transformPath(unitPath(mark.d), [box.width, 0, 0, box.height, box.x, box.y]),
-        ...fill ? { fill } : {},
-        ...stroke ? { stroke } : {}
-      }];
-    }
-  };
-}
-function registerMarkShape(opts = {}) {
-  return registerNodeShape(markShape(opts), { priority: "high" });
-}
-function markSpecs(nodeId, marks, box, ctx) {
-  return marks.map((mark, i) => {
-    const id = `${nodeId}/mark:${i}`;
-    if ("d" in mark) {
-      checkMarkPath(nodeId, i, mark.d);
-      const paint = (color) => ({ color, ...mark.opacity !== void 0 ? { opacity: mark.opacity } : {} });
-      const stroke = mark.stroke ?? (mark.fill === void 0 ? ctx.style.stroke : void 0);
-      return {
-        id,
-        kind: "leaf",
-        layer: "main",
-        parent: nodeId,
-        pickable: false,
-        pose: { x: box.x, y: box.y, width: box.width, height: box.height },
-        data: {
-          diagram: { mark: { d: mark.d } },
-          ...mark.fill !== void 0 ? { fill: { paint: paint(mark.fill) } } : {},
-          ...stroke !== void 0 ? { stroke: { paint: paint(stroke), width: mark.strokeWidth ?? 1.5, ...mark.dash ? { dash: mark.dash } : {} } } : {}
-        }
-      };
-    }
-    const size = ctx.measure(mark.text, mark.style ?? {});
-    const self = mark.self ?? mark.at;
-    return {
-      id,
-      kind: "leaf",
-      layer: "main",
-      pickable: false,
-      pose: {
-        x: box.x + mark.at.u * box.width + (mark.offset?.x ?? 0) - self.u * size.width,
-        y: box.y + mark.at.v * box.height + (mark.offset?.y ?? 0) - self.v * size.height,
-        width: size.width,
-        height: size.height
-      },
-      data: {
-        diagram: { anchor: { at: mark.at, self, ...mark.offset ? { offset: mark.offset } : {} } },
-        text: mark.text,
-        style: ctx.textStyle(mark.style),
-        fill: { paint: { color: mark.color ?? ctx.style.text } }
-      },
-      dependsOn: [nodeId],
-      derivePose: ANCHOR_DERIVE_POSE
-    };
-  });
-}
-
-// src/dataGroups.ts
-function resolveGroups(groups, ids, nodeIds, opts) {
-  for (const group of groups) {
-    if (ids.has(group.id)) throw new Error(`diagramScene: group id "${group.id}" is already a node or group id`);
-    ids.add(group.id);
-  }
-  const declared = new Map(groups.map((g) => [g.id, g]));
-  const nested = nestGroups(groups, (id) => nodeIds.has(id));
-  const depthOf = /* @__PURE__ */ new Map();
-  const byId = new Map(nested.map((g) => [g.id, g]));
-  const depth = (id) => {
-    const parent = byId.get(id).parent;
-    let d = depthOf.get(id);
-    if (d === void 0) depthOf.set(id, d = parent === void 0 ? 0 : depth(parent) + 1);
-    return d;
-  };
-  return nested.map((g, i) => ({ g, i })).sort((a, b) => depth(a.g.id) - depth(b.g.id) || a.i - b.i).map(({ g }) => {
-    const group = declared.get(g.id);
-    const pad = group.padding ?? opts.padding;
-    const title = group.label ? opts.title(group.label) : null;
-    const inset = { top: pad + (title ? title.height + pad / 2 : 0), right: pad, bottom: pad, left: pad };
-    return {
-      group,
-      direct: g.direct,
-      members: g.members,
-      inset,
-      pad,
-      title,
-      ...title ? { minWidth: title.width + 2 * pad } : {},
-      ...g.parent !== void 0 ? { parent: g.parent } : {}
-    };
-  });
-}
-function labelsByGroup(groups, labels) {
-  const byId = new Map(groups.map((g) => [g.group.id, g]));
-  const holder = /* @__PURE__ */ new Map();
-  for (const g of groups) for (const m of g.direct) holder.set(m, g.group.id);
-  const ancestry = (id) => {
-    const out2 = [];
-    for (let at = byId.has(id) ? byId.get(id).parent : holder.get(id); at !== void 0; at = byId.get(at)?.parent) out2.push(at);
-    return out2;
-  };
-  const out = /* @__PURE__ */ new Map();
-  for (const label of labels) {
-    const up = new Set(ancestry(label.to));
-    const shared = ancestry(label.from).find((g) => up.has(g));
-    if (shared !== void 0) out.set(shared, [...out.get(shared) ?? [], label]);
-  }
-  return out;
-}
-function groupBoxes(groups, placedAt, labels = /* @__PURE__ */ new Map()) {
-  const byId = new Map(groups.map((g) => [g.group.id, g]));
-  const boxes = /* @__PURE__ */ new Map();
-  const boxOf = (id) => {
-    const known = boxes.get(id);
-    if (known !== void 0) return known;
-    const g = byId.get(id);
-    const rs = g.direct.map((m) => byId.has(m) ? boxOf(m) : placedAt.get(m));
-    for (const label of labels.get(id) ?? []) if (label.at !== null) rs.push(label.at);
-    const x = Math.min(...rs.map((r) => r.x));
-    const y = Math.min(...rs.map((r) => r.y));
-    const box = boxAround({
-      x,
-      y,
-      width: Math.max(...rs.map((r) => r.x + r.width)) - x,
-      height: Math.max(...rs.map((r) => r.y + r.height)) - y
-    }, g);
-    boxes.set(id, box);
-    return box;
-  };
-  for (const g of groups) boxOf(g.group.id);
-  return boxes;
-}
-function groupSpecs(groups, placedAt, styleOf, wireLabels2 = []) {
-  const labels = labelsByGroup(groups, wireLabels2);
-  const boxes = groupBoxes(groups, placedAt, labels);
-  const specs = [];
-  for (const g of groups) {
-    const { style, text } = styleOf(g.group);
-    const { x, y, width, height } = boxes.get(g.group.id);
-    specs.push({
-      id: g.group.id,
-      kind: "leaf",
-      layer: "main",
-      pose: { x, y, width, height },
-      data: {
-        diagram: { outline: "rect", group: { inset: g.inset, ...g.minWidth !== void 0 ? { minWidth: g.minWidth } : {} } },
-        fill: { paint: { color: style.fill } },
-        stroke: {
-          paint: { color: style.stroke },
-          width: style.strokeWidth ?? 1,
-          ...style.dash ? { dash: style.dash } : {}
-        }
-      },
-      dependsOn: [...g.direct, ...(labels.get(g.group.id) ?? []).map((l) => l.id)],
-      derivePose: GROUP_DERIVE_POSE
-    });
-    if (g.title === null || !g.group.label) continue;
-    const anchor = { at: { u: 0, v: 0 }, offset: { x: g.pad, y: g.pad } };
-    specs.push({
-      id: `${g.group.id}/label`,
-      kind: "leaf",
-      layer: "main",
-      pickable: false,
-      pose: { x: x + g.pad, y: y + g.pad, width: g.title.width, height: g.title.height },
-      data: { diagram: { anchor }, text: g.group.label, style: text, fill: { paint: { color: style.text } } },
-      dependsOn: [g.group.id],
-      derivePose: ANCHOR_DERIVE_POSE
-    });
-  }
-  return specs;
-}
-var labelStyleOf = (font) => ({ ...font, fontSize: font.fontSize - 2 });
-function placementOf(e, route, ctx) {
-  const placement = e.labelPlacement ?? ctx.opts.labelPlacement ?? ctx.labelPlacement;
-  return route?.labelAt === void 0 ? placement : { ...placement, at: { near: route.labelAt } };
-}
-function labelSizeOf(text, ctx) {
-  const style = labelStyleOf(ctx.font);
-  return { width: ctx.measure(text, style).width, height: style.fontSize };
-}
-function wireLabels(edges, ctx) {
-  const out = [];
-  for (const e of edges) {
-    if (!e.label) continue;
-    const id = ctx.idOf(e);
-    const route = ctx.routes?.get(id);
-    const size = labelSizeOf(e.label, ctx);
-    const placement = placementOf(e, route, ctx);
-    const center2 = route?.waypoints !== void 0 && typeof placement.at === "object" ? labelCenter(polylineFromPoints([...route.waypoints]), placement, size) : null;
-    out.push({
-      id: `${id}/label`,
-      from: e.from,
-      to: e.to,
-      at: center2 === null ? null : { x: center2.x - size.width / 2, y: center2.y - size.height / 2, ...size }
-    });
-  }
-  return out;
-}
-var endOf = (own, port) => !port ? {} : own === void 0 ? { port, laidOut: port } : { port };
-function edgeSpecs(edges, ctx) {
-  const specs = [];
-  for (const e of edges) {
-    const id = ctx.idOf(e);
-    const route = ctx.routes?.get(id);
-    const { fromPort, toPort, waypoints } = route ?? {
-      fromPort: e.fromPort ?? e.routedPorts?.from,
-      toPort: e.toPort ?? e.routedPorts?.to,
-      waypoints: e.waypoints ?? e.routed
-    };
-    const laidOut = e.waypoints === void 0 && waypoints !== void 0;
-    const style = ctx.opts.edgeStyle?.(e) ?? ctx.fallback;
-    const markerStart = style.markerStart ?? null;
-    const markerEnd = style.markerEnd === void 0 ? "arrow" : style.markerEnd;
-    specs.push({
-      id,
-      kind: "leaf",
-      layer: "main",
-      pickable: false,
-      pose: { x: 0, y: 0, width: 0, height: 0 },
-      data: {
-        diagram: {
-          from: endOf(e.fromPort, fromPort),
-          to: endOf(e.toPort, toPort),
-          router: e.router ?? ctx.opts.router ?? "bezier",
-          ...waypoints ? { waypoints } : {},
-          ...laidOut ? { laidOut: waypoints } : {}
-        },
-        stroke: {
-          paint: { color: style.stroke },
-          width: style.width ?? 1.5,
-          ...style.dash ? { dash: style.dash } : {},
-          ...markerStart !== null ? { markerStart } : {},
-          ...markerEnd !== null ? { markerEnd } : {}
-        }
-      },
-      dependsOn: [e.from, e.to],
-      derivePath: EDGE_DERIVE_PATH
-    });
-    if (!e.label) continue;
-    const labelStyle = labelStyleOf(ctx.font);
-    specs.push({
-      id: `${id}/label`,
-      kind: "leaf",
-      layer: "main",
-      pickable: false,
-      pose: { x: 0, y: 0, ...labelSizeOf(e.label, ctx) },
-      data: {
-        diagram: { label: placementOf(e, route, ctx) },
-        text: e.label,
-        style: labelStyle,
-        fill: { paint: { color: style.label ?? style.stroke } }
-      },
-      dependsOn: [id],
-      derivePose: LABEL_DERIVE_POSE
-    });
-  }
-  return specs;
-}
-
-// src/fromData.ts
-var SLOT_FRAME = "M0 0H1V1H0Z";
-var FONT = { fontFamily: "sans-serif", fontSize: 12 };
-var NODE = { fill: "#16222c", stroke: "#7ba7c7", text: "#dbe7f2" };
-var EDGE = { stroke: "#7ba7c7" };
-var GROUP = { fill: "rgba(123, 167, 199, 0.08)", stroke: "#7ba7c7", text: "#9fbdd6", strokeWidth: 1, dash: [4, 3] };
-var LABEL_PLACEMENT = { at: "mid", offset: 9 };
-var LINE = 1.4;
-var GLYPH = 0.6;
-var MIN_WIDTH = 64;
-var LAYOUTS = { layered, tree, force, chain };
-var idPart = (s) => s.replace(/[\\.>:/]/g, "\\$&");
-var edgeIdOf = (e) => {
-  const part = (mark, p) => p === void 0 ? "" : `${mark}${idPart(p)}`;
-  return `edge:${idPart(e.from)}${part(".", e.fromPort)}->${idPart(e.to)}${part(".", e.toPort)}${part(":", e.label)}`;
-};
-function graphOf(nodes, edges, groups = []) {
-  const byId = new Map(nodes.map((n) => [n.id, n]));
-  const out = /* @__PURE__ */ new Map();
-  const inc = /* @__PURE__ */ new Map();
-  for (const e of edges) {
-    out.set(e.from, [...out.get(e.from) ?? [], e]);
-    inc.set(e.to, [...inc.get(e.to) ?? [], e]);
-  }
-  return {
-    nodes,
-    edges,
-    groups,
-    node: (id) => byId.get(id),
-    outgoing: (id) => out.get(id) ?? [],
-    incoming: (id) => inc.get(id) ?? []
-  };
-}
-function labelRoomOf(e, opts, font, measure) {
-  if (!e.label || e.waypoints !== void 0) return null;
-  if (e.labelPlacement !== void 0 && !labelFollowsLayout(e.labelPlacement.at)) return null;
-  const style = labelStyleOf(font);
-  const offset = (e.labelPlacement ?? opts.labelPlacement ?? LABEL_PLACEMENT).offset;
-  return { width: measure(e.label, style).width, height: style.fontSize, ...offset !== void 0 ? { offset } : {} };
-}
-function graphEdgeOf(e, room) {
-  return {
-    id: edgeIdOf(e),
-    from: e.from,
-    to: e.to,
-    ...e.fromPort ? { fromPort: e.fromPort } : {},
-    ...e.toPort ? { toPort: e.toPort } : {},
-    ...room !== null ? { label: room } : {}
-  };
-}
-function placed(data, seeds, moved) {
-  return new Map(data.nodes.map((n, i) => {
-    const seed = seeds[i].bounds;
-    const at = moved.get(n.id) ?? seed;
-    return [n.id, { x: at.x, y: at.y, width: seed.width, height: seed.height }];
-  }));
-}
-function nodeSpecs(n, body, box, look) {
-  const { style } = look;
-  const textData = (text, s) => ({ text, style: look.text(s), fill: { paint: { color: style.text } } });
-  const built = buildBody(body, box, {
-    id: n.id,
-    layer: "main",
-    measure: look.measure,
-    body: (trait) => ({
-      diagram: n.pinned === true ? { ...trait, pinned: true } : trait,
-      fill: { paint: { color: style.fill } },
-      stroke: { paint: { color: style.stroke }, width: style.strokeWidth ?? 2, ...style.dash ? { dash: style.dash } : {} }
-    }),
-    row: (text, at) => at.row.kind === "slot" ? at.row.id === void 0 ? null : { diagram: { mark: { d: SLOT_FRAME } }, stroke: { paint: { color: style.stroke }, width: 1 } } : text === "" ? null : textData(text, at.row.kind === "label" || at.row.kind === "field" ? at.row.style : void 0),
-    portLabel: (text) => textData(text, void 0)
-  });
-  return built.specs.map((s, k) => ({ ...s, ...s.id !== void 0 ? {} : { id: `${n.id}/${k}` } }));
-}
-function diagramScene(data, opts = {}) {
-  const font = opts.font ?? FONT;
-  const styleOf = (s) => ({
-    fontFamily: s?.fontFamily ?? font.fontFamily,
-    fontSize: s?.fontSize ?? font.fontSize,
-    ...s?.bold === true ? { fontWeight: 700 } : {}
-  });
-  const measure = opts.measure ? (text, s) => opts.measure(text, { ...s, fontFamily: s.fontFamily ?? font.fontFamily, fontSize: s.fontSize ?? font.fontSize }) : (text, s) => {
-    const size = s.fontSize ?? font.fontSize;
-    return { width: text.length * GLYPH * size, height: Math.ceil(LINE * size) };
-  };
-  const ids = /* @__PURE__ */ new Set();
-  for (const n of data.nodes) {
-    if (ids.has(n.id)) throw new Error(`diagramScene: node id "${n.id}" appears more than once`);
-    ids.add(n.id);
-  }
-  const nodeIds = new Set(ids);
-  const titleStyle = { ...font, fontSize: font.fontSize - 1 };
-  const groups = resolveGroups(data.groups ?? [], ids, nodeIds, {
-    padding: opts.groupPadding ?? DEFAULT_GROUP_INSET,
-    title: (text) => measure(text, titleStyle)
-  });
-  const seen = /* @__PURE__ */ new Set();
-  const edges = data.edges.filter((e) => {
-    const id = edgeIdOf(e);
-    if (seen.has(id) || !ids.has(e.from) || !ids.has(e.to)) return false;
-    seen.add(id);
-    return true;
-  });
-  const bodies = data.nodes.map((n) => ({
-    outline: n.outline ?? opts.outline ?? "rect",
-    rows: n.rows ?? (n.lines ?? []).map((text) => ({ kind: "label", text })),
-    padding: n.padding ?? opts.padding ?? 8,
-    gap: n.gap ?? opts.gap ?? 4,
-    verticalAlign: n.verticalAlign ?? opts.verticalAlign ?? "center",
-    ...n.ports ? { ports: n.ports } : {},
-    ...n.portLabels ? { portLabels: n.portLabels } : {}
-  }));
-  const seeds = data.nodes.map((n, i) => {
-    const pose = sizeToBody(
-      { ...n.at ?? { x: i, y: i }, width: n.width ?? opts.minWidth ?? MIN_WIDTH, height: n.height ?? 0 },
-      measureBody(bodies[i], measure)
-    );
-    const { ports, outline, margin } = bodyTrait(bodies[i], pose, measure);
-    return {
-      id: n.id,
-      bounds: pose,
-      pinned: n.pinned === true,
-      ...ports !== void 0 ? { ports } : {},
-      ...outline !== void 0 ? { outline } : {},
-      ...margin !== void 0 ? { margin } : {}
-    };
-  });
-  const graphGroups = groups.map((g) => ({
-    id: g.group.id,
-    members: g.members,
-    inset: g.inset,
-    ...g.minWidth !== void 0 ? { minWidth: g.minWidth } : {},
-    ...g.parent !== void 0 ? { parent: g.parent } : {}
-  }));
-  const seedOf = new Map(seeds.map((n) => [n.id, n]));
-  for (const g of groups) {
-    for (const m of g.direct) {
-      const seed = seedOf.get(m);
-      if (seed !== void 0) seed.group = g.group.id;
-    }
-  }
-  const graph = graphOf(
-    seeds,
-    expandGroupEdges(edges.map((e) => graphEdgeOf(e, labelRoomOf(e, opts, font, measure))), graphGroups),
-    graphGroups
-  );
-  const layout = typeof opts.layout === "function" ? opts.layout : opts.layout === "none" ? null : LAYOUTS[opts.layout ?? "layered"];
-  const layoutOptions = { order: "barycenter", ...opts.layoutOptions };
-  const plan = layout === null ? null : planOf(layout, graph, layoutOptions);
-  const moved = plan?.moves ?? /* @__PURE__ */ new Map();
-  const specs = [];
-  const placedAt = placed(data, seeds, moved);
-  const routes = plan === null || layout?.plan === void 0 ? null : authoredOver(edges.map((e) => ({ ...e, id: edgeIdOf(e) })), plan);
-  const edgeCtx = { idOf: edgeIdOf, font, measure, fallback: EDGE, labelPlacement: LABEL_PLACEMENT, routes, opts };
-  const groupLook = (g) => ({ style: opts.groupStyle?.(g) ?? GROUP, text: styleOf(titleStyle) });
-  const footprints = new Map(seeds.map((s) => [s.id, grownBy(placedAt.get(s.id), s.margin)]));
-  specs.push(...groupSpecs(groups, footprints, groupLook, wireLabels(edges, edgeCtx)));
-  for (const [i, n] of data.nodes.entries()) {
-    const seed = seeds[i].bounds;
-    const at = placedAt.get(n.id);
-    const style = opts.nodeStyle?.(n) ?? NODE;
-    specs.push(...nodeSpecs(n, bodies[i], { x: at.x, y: at.y, width: seed.width, height: seed.height }, { style, text: styleOf, measure }));
-    if (n.marks) specs.push(...markSpecs(n.id, n.marks, at, { style, textStyle: styleOf, measure }));
-  }
-  specs.push(...edgeSpecs(edges, edgeCtx));
-  return specs;
-}
-
-// 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 && layoutOwnsRoute(edge)) owned.add(id);
-      continue;
-    }
-    let next = edge;
-    if (layoutOwnsRoute(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 LAYOUTS2 = 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 : LAYOUTS2[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 (!layoutOwnsRoute(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 graphOf2(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 : LAYOUTS2[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 placed2 = result;
-    if (ctx.pinned.size > 0) {
-      const held2 = new Map(result);
-      for (const id of ctx.pinned.keys()) held2.delete(id);
-      placed2 = held2;
-    }
-    const poses = layoutPoses(o.scene, placed2, 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 = graphOf2(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, graphOf2(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(graphOf2(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;
-  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);
-      return [{
-        kind: "path",
-        path: outlinePath(outline, box),
-        ...fill ? { fill } : {},
-        ...stroke ? { stroke } : {}
-      }];
-    },
-    // 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 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]);
-}
-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 routeOf = (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") {
-      nodes.set(n.id, { x: n.pose.x, y: n.pose.y });
-      continue;
-    }
-    const edge = diagramEdgeOf(n);
-    if (edge !== null) routes.set(n.id, routeOf(edge));
-  }
-  return { nodes, routes };
-}
-function diagramLayoutOf(specs) {
-  const moves = [];
-  const routes = [];
-  for (const s of specs) {
-    const id = s.id;
-    if (id === void 0) continue;
-    if (s.kind === "container") {
-      if (diagramGroupOf(s) === null && !isPinned({ id, kind: s.kind, data: s.data })) moves.push({ id, x: s.pose.x, y: s.pose.y });
-      continue;
-    }
-    const edge = diagramEdgeOf(s);
-    if (edge === null) continue;
-    const route = routeOf(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 };
-}
-function changes(was, now) {
-  const moves = [];
-  for (const [id, at] of now.nodes) {
-    const before = was.nodes.get(id);
-    if (before !== void 0 && (before.x !== at.x || before.y !== at.y)) moves.push({ id, ...at });
-  }
-  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 };
-}
-function useSceneSync(scene, specs, onMove) {
-  const onMoveRef = useLatest(onMove);
-  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 && (found.moves.length > 0 || found.routes.length > 0)) {
-        onMoveRef.current?.(found.moves, found.routes);
-      }
-    });
-  }, [scene, onMoveRef]);
-  useEffect(() => {
-    if (applied.current === specs) return;
-    syncing.current = true;
-    try {
-      reconcileSpecs(scene, applied.current, specs);
-    } finally {
-      syncing.current = false;
-    }
-    applied.current = specs;
-  }, [scene, specs]);
-}
-var AMBIENT = [dragPanContribution()];
-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 NO_MARQUEE = { areaSelect: null };
-var DiagramView = forwardRef(function DiagramView2(props, ref) {
-  return /* @__PURE__ */ jsx(WeaselProvider, { children: /* @__PURE__ */ jsx(Inner, { ...props, apiRef: ref }) });
-});
-function Inner({
-  specs,
-  width,
-  height,
-  selected,
-  onSelect,
-  onMove,
-  onConnect,
-  enableKeybindings,
-  canConnect,
-  portOptions,
-  ports: portMode,
-  live: liveOpts,
-  minScale,
-  maxScale,
-  anchor,
-  fitPadding,
-  background,
-  view,
-  onViewChange,
-  className,
-  apiRef
-}) {
-  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);
-  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 defaultView = useMemo(
-    () => controlled || unsized ? void 0 : fitDiagram(specs, { width: boxWidth, height: boxHeight }, fitOpts),
-    // A later `specs` keeps the view it has.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [controlled, unsized, boxWidth, boxHeight, minScale, maxScale, anchor, fitPadding]
-  );
-  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), 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]);
-  useImperativeHandle(apiRef, () => ({
-    layout: (algorithm = "force") => setRun({ algorithm }),
-    live
-  }), [live]);
-  const onConnectRef = useLatest(onConnect);
-  const mode = portMode ?? (onConnect !== void 0 ? "connect" : "none");
-  const ports = useMemo(() => mode === "connect" ? diagramPorts({
-    ...portOptions,
-    participants: source,
-    ...canConnect ? { canConnect } : {},
-    commit: ({ from, to }) => onConnectRef.current?.({
-      from: from.nodeId,
-      fromPort: from.id,
-      to: to.nodeId,
-      toPort: to.id
-    })
-  }) : null, [mode, source, canConnect, portOptions, onConnectRef]);
-  const shown = useMemo(() => {
-    if (mode !== "show") return null;
-    const { hitTest: _hitTest, ...paintOnly } = portLayer(source, portOptions);
-    return paintOnly;
-  }, [mode, source, portOptions]);
-  const canvasRef = useRef(null);
-  const layer = ports?.layer ?? shown;
-  useEffect(() => layer ? canvasRef.current?.registerLayer(layer) : void 0, [layer]);
-  const ambient = useMemo(() => ports ? [...AMBIENT, ports.contribution] : AMBIENT, [ports]);
-  useRefit(canvasRef, fit);
-  return /* @__PURE__ */ jsx(
-    SceneCanvas,
-    {
-      ref: canvasRef,
-      scene,
-      selection,
-      features: onMove ? ["view", "pick", "move"] : ["view", "pick"],
-      enableKeybindings: enableKeybindings ?? (onMove !== void 0 || onConnect !== void 0),
-      ambient,
-      actions: NO_MARQUEE,
-      onClick,
-      width,
-      height,
-      ...fills ? { onResize: setMeasured } : {},
-      className,
-      ...defaultView ? { defaultView } : {},
-      ...view ? { view } : {},
-      ...onViewChange ? { onViewChange } : {},
-      ...background ? { backgroundFill: background } : {}
-    }
-  );
-}
-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 = {}) {
-  const boxes = specs.filter((s) => s.kind === "container" || diagramGroupOf(s) !== null).map((s) => s.pose);
-  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 { ANCHOR_DERIVE_POSE, CONNECT_ACTION_ID, DEFAULT_EDGE_STROKE, DIAGRAM_ANCHOR, DIAGRAM_EDGE, DIAGRAM_GROUP, DIAGRAM_LABEL, DiagramView, EASED_LAYOUTS, EDGE_DERIVE_PATH, GRAB_PORT_ACTION_ID, GROUP_DERIVE_POSE, LABEL_DERIVE_POSE, LABEL_PLACEMENT, LAYOUTS2 as LAYOUTS, LAYOUT_ACTION_ID, PORT_AFFORDANCE_KIND, PORT_LAYER_ID, ROUTERS, anchorDerivePose, applyLayout, bezier, boxAround, buildGraph, commitEdgeToScene, connectBinding, createConnectAction, createDiagramContribution, createLayoutAction, createPortAffordance, defaultCanConnect, diagramAnchorOf, diagramEdgeOf, diagramGroupOf, diagramLabelOf, diagramLayoutOf, diagramMarkOf, diagramPorts, diagramScene, diagramShape, easedProducer, edgeDerivePath, edgeIdOf, forceProducer, grabPortAction, grabPortBindings, groupDerivePose, labelCenter, labelDerivePose, layoutOwnsPort, layoutOwnsRoute, layoutPoses, markShape, orthogonal, portLayer, portScratchOf, registerDiagramShape, registerMarkShape, resolveEnd, routeWrites, routesOf, sceneParticipants, selfLoop, straight, useLiveLayout, useMirroredSelection, withDiagramRegistry };
-//# sourceMappingURL=chunk-C4NAI6NV.js.map
-//# sourceMappingURL=chunk-C4NAI6NV.js.map