@weasel-js/diagram 1.14.2 → 1.15.1

package/dist/{chunk-GR2DK4S2.js → chunk-EIHPPOAM.js}

@@ -1,11 +1,11 @@
-import { createAvoidRouter, placeLabels, edgeHops, radial, DEFAULT_HOP_SIZE, HOPS_DOC_KEY, simplifyStops } from './chunk-IYUU5KUY.js';
-import { edgeRouter, registerMarkShape, withDiagramRegistry, diagramLabelOf, editEdgeLabelBinding, editEdgeLabelAction, diagramGroupOf, diagramContainerOf, headerBox, labelFollowsLayout, buildGraph, LABEL_DRAG_AFFORDANCE_KIND, EDIT_EDGE_LABEL_ACTION_ID, labelDragLayer, laneOutlineOf, recordedRows, keyedIndex, boxIndex, boxesMeeting, routerOf, labelScratchOf, ROUTERS, avoid, LABEL_PLACEMENT, editableLabels, titleIdOf, orthogonal, diagramAnchorOf, MIN_LANE_SIZE, EDGE_DERIVE_PATH, titleInFrame, regionSpecs, DIAGRAM_THEME_KEY, diagramThemeOf, endAims, resolveEnd, themeLabelFamily, bodyBox, boxCenter, roleEdgeStyle, roleStyle, themeLabelFont, firstLanes, DEFAULT_LANE_SIZE } from './chunk-DE7UILJA.js';
-import { diagramEdgeOf, isPromise, diagramNodeOf, portsOf, portSitesOf, outlinePath, outlineDetail, samePoints, layoutWritesRoute, plannerPlan, planOf, layered, dataKeyReader, layoutBody, forceRelaxation, center, layoutOwnsPort, chain, force, tree, portOf, labelCenter, labelSpotAt, isPinned, layoutOwnsRoute } from './chunk-FDCODMFW.js';
-import { bodyPredicate, dragPanContribution, WeaselProvider, useScene, useSelection, useLatest, SceneCanvas, useDepSource, RIGID_POSE_COMPOSITION, registerNodeShape, reconcileSpecs, pagesBounds, pagesLayer, AUTO_POSE_DESCRIPTOR, usePoseRun, drawnBoundsScene, pointAlongPath, scenePoseAdapter, drawnAABBOf, composeWorldPose, worldPosesOf, RECT_POSE_DESCRIPTOR, resolveFill, resolveStroke, commandFill, commandStroke, nodeGates, scenePoseFrame, fitViewToBounds, clampView, rebaseLocalPose, translatePoseViaDescriptor, carriedDescendants, sceneCarrySource, composeAffordanceLayer, createResizeAction, createDeleteAction, effectivePose, polylineFromPoints, SNAP_ROLES, ActionDisabledReason, refusalOf, snapMods, documentDepOf, definesFrame, paintsLayer, viewToTransform, ellipsePath, derivedDepOf, localizeWorldPoses, PathBuilder, startCarry, createInsertOp, createSetDataOp, documentPose } from '@weasel-js/core';
+import { createAvoidRouter, placeLabels, edgeHops, DEFAULT_HOP_SIZE, HOPS_DOC_KEY, simplifyStops } from './chunk-UUMLQEMR.js';
+import { edgeRouter, registerMarkShape, withDiagramRegistry, diagramLabelOf, routesOf, layoutPoses, routeWrites, editEdgeLabelBinding, editEdgeLabelAction, diagramGroupOf, diagramContainerOf, headerBox, buildGraph, LAYOUTS, LABEL_DRAG_AFFORDANCE_KIND, EDIT_EDGE_LABEL_ACTION_ID, labelDragLayer, laneOutlineOf, recordedRows, keyedIndex, boxIndex, boxesMeeting, routerOf, labelScratchOf, ROUTERS, avoid, LABEL_PLACEMENT, editableLabels, titleIdOf, orthogonal, diagramAnchorOf, MIN_LANE_SIZE, EDGE_DERIVE_PATH, titleInFrame, regionSpecs, DIAGRAM_THEME_KEY, diagramThemeOf, endAims, resolveEnd, themeLabelFamily, diagramThemeFrom, themeFont, bodyBox, boxCenter, roleEdgeStyle, DEFAULT_FONT, withColors, roleStyle, GLYPH, themeLabelFont, firstLanes, DEFAULT_LANE_SIZE } from './chunk-NEX4QKQQ.js';
+import { diagramEdgeOf, isPromise, diagramNodeOf, portsOf, portSitesOf, outlinePath, outlineDetail, outlineSolid, samePoints, layoutWritesRoute, plannerPlan, planOf, layered, dataKeyReader, layoutBody, forceRelaxation, center, portOf, labelCenter, labelSpotAt, contentBox, boxForContent, grid, chain, tree, isPinned, layoutOwnsRoute } from './chunk-UOFQBGJY.js';
+import { bodyPredicate, dragPanContribution, WeaselProvider, useScene, useSelection, useLatest, SceneCanvas, useDepSource, RIGID_POSE_COMPOSITION, registerNodeShape, reconcileSpecs, pagesBounds, pagesLayer, usePoseRun, drawnBoundsScene, pointAlongPath, scenePoseAdapter, drawnAABBOf, composeWorldPose, worldPosesOf, RECT_POSE_DESCRIPTOR, resolveFill, resolveStroke, commandFill, commandStroke, nodeGates, scenePoseFrame, fitViewToBounds, clampView, AUTO_POSE_DESCRIPTOR, composeAffordanceLayer, createResizeAction, createDeleteAction, isTextData, effectivePose, polylineFromPoints, SNAP_ROLES, ActionDisabledReason, commitDeleteToScene, refusalOf, snapMods, documentDepOf, translatePoseViaDescriptor, definesFrame, paintsLayer, viewToTransform, ellipsePath, carriedDescendants, sceneCarrySource, derivedDepOf, localizeWorldPoses, PathBuilder, startCarry, createInsertOp, createSetDataOp, documentPose } from '@weasel-js/core';
 import { createSettledCache } from '@weasel-js/geom/nd';
 import { AUTO_POSE_DESCRIPTOR as AUTO_POSE_DESCRIPTOR$1, rotatePoint } from '@weasel-js/core/math';
 import { clampRectWithin, placeRect, pathContainsPoint } from '@weasel-js/geom';
-import { nudgeGap, moveItems, nearestGap, isNoopDrop } from '@weasel-js/headless';
+import { nudgeGap, moveItems, nearestGap, isNoopDrop } from '@weasel-js/ui-logic';
 import { forwardRef, useMemo, useEffect, useState, useRef, useCallback, useImperativeHandle, useLayoutEffect } from 'react';
 import { useLatest as useLatest$1, adoptCssOnce } from '@weasel-js/react';
 import '@weasel-js/animator';
@@ -109,10 +109,10 @@ function createPortAffordance(participants, opts = {}) {
       const built = index();
       const rx = hitRadiusPx / Math.abs(view.scale.x);
       const ry = hitRadiusPx / Math.abs(view.scale.y);
-      const near2 = built && boxesMeeting(built.boxes, wx - rx, wy - ry, wx + rx, wy + ry);
-      if (!built || !near2) return regions(state);
+      const near = built && boxesMeeting(built.boxes, wx - rx, wy - ry, wx + rx, wy + ry);
+      if (!built || !near) return regions(state);
       const out = [];
-      for (const i of near2) {
+      for (const i of near) {
         const entry = built.at[i];
         if (shown(entry.participant, state) && showsPort(entry.port)) out.push(regionAt(entry));
       }
@@ -507,8 +507,8 @@ function createReorderAction(opts) {
         if (slots === null || picked === null) return {};
         const held = { slots, ...picked };
         const { axis } = slots;
-        const region = opts.region?.(ctx.deps, held.item) ?? null;
-        const leaves = (at) => region !== null && !inside(at, region);
+        const region2 = opts.region?.(ctx.deps, held.item) ?? null;
+        const leaves = (at) => region2 !== null && !inside(at, region2);
         let by = ctx.world[axis] - start[axis];
         let open = true;
         const verdicts = /* @__PURE__ */ new Map();
@@ -920,6 +920,7 @@ function themeWrites(scene, theme, ids, from) {
     const data = node.data;
     if (data === null || typeof data !== "object") continue;
     const trait = traitOf(data);
+    if (trait !== null && ("seq" in trait || "sequence" in trait)) continue;
     if (trait !== null && "from" in trait && "to" in trait) {
       if (ids !== void 0 && !ids.has(node.id)) continue;
       const look2 = edgeLook(trait, theme);
@@ -980,7 +981,7 @@ 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 title = stencil.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, {
@@ -989,7 +990,7 @@ function containerBuild(stencil, bounds, opts) {
       parent: opts.parent ?? null,
       ...style ? { style } : {}
     }),
-    ...stencil.role === "pool" ? firstLanes(id, axis, at, opts) : []
+    ...stencil.role === "pool" ? firstLanes(id, axis, at, opts, stencil.lanes) : []
   ];
   const label = `Insert ${stencil.label}`;
   const stored = localizeWorldPoses(specs, RIGID_POSE_COMPOSITION);
@@ -1442,19 +1443,19 @@ function createLabelDragAction(opts = {}) {
         if (p === null) return {};
         let spot = null;
         let open = true;
-        const proposed = () => open ? spot : null;
+        const proposed2 = () => open ? spot : null;
         return {
           kind: "diagram-move-label",
           onMove(moveCtx) {
             spot = spotAt(p, moveCtx);
           },
-          previewIds: () => proposed() === null ? null : [p.labelId],
+          previewIds: () => proposed2() === null ? null : [p.labelId],
           previewPose: (id) => {
-            const next = proposed();
+            const next = proposed2();
             return id === p.labelId && next !== null ? poseAt(p, next) : null;
           },
           previewData: (id) => {
-            const next = proposed();
+            const next = proposed2();
             return id === p.labelId && next !== null ? movedLabelData(p.data, next) : null;
           },
           onEnd(endCtx, reason) {
@@ -1928,16 +1929,16 @@ function createRouteEditAction(opts) {
         const session = beginSnap(ctx, p, snapPx);
         let waypoints = null;
         let open = true;
-        const proposed = () => open ? waypoints : null;
+        const proposed2 = () => open ? waypoints : null;
         return {
           kind: "diagram-edit-route",
           onMove(moveCtx) {
             waypoints = waypointsAt(p, moveOf2(p, session, moveCtx));
           },
-          previewIds: () => proposed() === null ? null : [p.edgeId],
-          previewPose: (id) => id === p.edgeId && proposed() !== null ? p.pose : null,
+          previewIds: () => proposed2() === null ? null : [p.edgeId],
+          previewPose: (id) => id === p.edgeId && proposed2() !== null ? p.pose : null,
           previewData: (id) => {
-            const next = proposed();
+            const next = proposed2();
             return id === p.edgeId && next !== null ? routedData(p.data, p.trait, next) : null;
           },
           onEnd(endCtx, reason) {
@@ -2255,8 +2256,8 @@ function avoidSceneInput(scene, opts = {}, poseOf) {
     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 });
+    const region2 = container !== null || diagramGroupOf(node) !== null;
+    obstacles.push(region2 ? { 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);
@@ -2315,13 +2316,13 @@ function obstaclesOf(specs, world) {
   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 region2 = diagramContainerOf(spec);
+    if (diagramNodeOf(node) === null && region2?.role !== "lane") continue;
     const box = world.get(node.id) ?? spec.pose;
-    const header = region === null ? null : headerBox(box, region.header);
+    const header = region2 === null ? null : headerBox(box, region2.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 } : { id: node.id, kind: "region", box, members: inside2(node.id, /* @__PURE__ */ new Set()) });
+    if (region2?.role === "lane") continue;
+    out.push(region2 === null ? { id: node.id, kind: "shape", box } : { id: node.id, kind: "region", box, members: inside2(node.id, /* @__PURE__ */ new Set()) });
   }
   return out;
 }
@@ -2684,168 +2685,27 @@ function createSpecLabelPlacer(opts = {}) {
   };
 }
 
+// src/sequence/trait.ts
+var traitOf2 = (node) => {
+  const data = node.data;
+  if (data === null || typeof data !== "object") return null;
+  const trait = data.diagram;
+  return trait !== null && typeof trait === "object" ? trait : null;
+};
+function sequenceRootOf(node) {
+  const trait = traitOf2(node);
+  return trait !== null && "sequence" in trait && "geometry" in trait ? trait : null;
+}
+function sequencePartOf(node) {
+  const seq = traitOf2(node)?.seq;
+  return seq !== null && typeof seq === "object" && typeof seq.root === "string" ? seq : null;
+}
+
 // 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,
-  radial
-});
-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 sc = scene;
-  const { compose, decompose } = sc.composition;
-  const stored = scenePoseAdapter(sc);
-  const out = /* @__PURE__ */ new Map();
-  const decided = { ...stored, getPose: (id) => out.has(id) ? out.get(id) : stored.getPose(id) };
-  const depth = (id) => {
-    let d = 0;
-    for (let at = scene.get(id)?.parent; at != null; at = scene.get(at)?.parent) d++;
-    return d;
-  };
-  const ids = [...result.keys()].filter((id) => scene.get(id) !== void 0).sort((a, b) => depth(a) - depth(b));
-  for (const id of ids) {
-    const at = result.get(id);
-    const world = composeWorldPose(stored, id, compose);
-    const bounds = geometry.getBounds(world);
-    const dx = at.x - bounds.x;
-    const dy = at.y - bounds.y;
-    if (dx === 0 && dy === 0) continue;
-    const parent = scene.get(id).parent;
-    out.set(id, rebaseLocalPose(decided, translatePoseViaDescriptor(world, dx, dy, geometry), parent, compose, decompose));
-    const carried = carriedDescendants(sceneCarrySource(sc), id, (w) => translatePoseViaDescriptor(w, dx, dy, geometry));
-    for (const [d, pose] of carried) out.set(d, pose);
-  }
-  return out;
-}
-var LAYOUT_ACTION_ID = "diagram.layout";
-function layoutDiagram(scene, source, algorithm, opts = {}) {
-  const fn = typeof algorithm === "function" ? algorithm : LAYOUTS[algorithm] ?? layered;
-  const graph = buildGraph(source, {
-    ...opts.read ? { read: opts.read } : {},
-    ...opts.geometry ? { geometry: opts.geometry } : {}
-  });
-  const plan = planOf(fn, graph, opts.layout);
-  return applyLayout(scene, plan.moves, {
-    ...opts.geometry ? { geometry: opts.geometry } : {},
-    ...opts.label ? { label: opts.label } : {},
-    routes: routesOf(graph, plan)
-  });
-}
-function createLayoutAction(opts) {
-  const { read, geometry, layout, label } = opts;
-  const options = {
-    ...read ? { read } : {},
-    ...geometry ? { geometry } : {},
-    ...layout ? { layout } : {},
-    ...label ? { label } : {}
-  };
-  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) layoutDiagram(scene, opts.source, opts.algorithm ?? "layered", options);
-      }
-    },
-    enabled: () => true
+    return node === void 0 || diagramEdgeOf(node) === null && diagramLabelOf(node) === null && diagramGroupOf(node) === null && diagramContainerOf(node)?.role !== "lane" && sequencePartOf(node) === null;
   };
 }
 var EASE_FRAMES = 24;
@@ -2880,14 +2740,14 @@ function forceProducer(graph, opts = {}) {
     }
     relaxation.sim.alphaTarget(pinned.size > 0 ? dragAlpha : 0);
     relaxation.sim.tick();
-    let moved = 0;
+    let moved2 = 0;
     relaxation.bodies.forEach((body, i) => {
       const at = was[i];
-      moved = Math.max(moved, Math.hypot(body.x - at.x, body.y - at.y));
+      moved2 = Math.max(moved2, 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;
+    still = pinned.size === 0 && moved2 < restDistance ? still + 1 : 0;
     const done = still >= restTicks || relaxation.sim.isSettled();
     return { result: relaxation.placed(), done };
   };
@@ -3143,7 +3003,7 @@ function useLiveLayout(opts) {
     const o = optsRef.current;
     producerFrame.current = 0;
     held.current = false;
-    routes.current = routesOf(graph, plan ?? { });
+    routes.current = routesOf(graph, plan ?? { moves: /* @__PURE__ */ new Map() });
     eased.set(routeEasings(o.scene, graph, routes.current));
     producer.current = producerFor(graph, plan, o);
   }, [optsRef, eased]);
@@ -3168,9 +3028,9 @@ function useLiveLayout(opts) {
     scene: opts.scene,
     step,
     // Eased routes go once the routes are in the document, so no frame shows the old ones.
-    onCommit: (moved) => {
+    onCommit: (moved2) => {
       eased.drop();
-      optsRef.current.onSettle?.(moved);
+      optsRef.current.onSettle?.(moved2);
     },
     // Routes match where the layout was going, so only a run that got there
     // with nothing held along the way writes them.
@@ -3237,7 +3097,8 @@ function useLiveLayout(opts) {
 var EASED_LAYOUTS = Object.freeze({
   layered,
   tree,
-  chain
+  chain,
+  grid
 });
 function bodyRules(trait, box) {
   const layout = trait.body;
@@ -3254,7 +3115,7 @@ function bodyRules(trait, box) {
 // src/shape.ts
 function diagramShape(opts = {}) {
   const geometry = opts.geometry ?? RECT_POSE_DESCRIPTOR;
-  const outlineOf2 = (node) => diagramNodeOf(node, opts.read)?.outline ?? laneOutlineOf(node);
+  const outlineOf2 = (node) => diagramNodeOf(node, opts.read)?.outline ?? laneOutlineOf(node) ?? sequenceOutlineOf(node);
   return {
     id: opts.id ?? "diagram:outline",
     matches: (node) => outlineOf2(node) !== void 0,
@@ -3271,6 +3132,9 @@ function diagramShape(opts = {}) {
       const divider = header === null || !stroke ? [] : [{ kind: "path", path: dividerPath(box, header), stroke }];
       const detailPath = stroke ? outlineDetail(outline, box) : null;
       const detail = stroke && detailPath ? [{ kind: "path", path: detailPath, stroke }] : [];
+      const solidPath = declaredStroke ? outlineSolid(outline, box) : null;
+      const solidFill = declaredStroke && solidPath ? commandFill({ paint: declaredStroke.paint }, box) : null;
+      const solid = solidPath && solidFill ? [{ kind: "path", path: solidPath, fill: solidFill }] : [];
       const trait = diagramNodeOf(node, opts.read);
       const rules = stroke && trait !== null ? bodyRules(trait, box).map((path) => ({ kind: "path", path, stroke })) : [];
       return [{
@@ -3278,7 +3142,7 @@ function diagramShape(opts = {}) {
         path: outlinePath(outline, box),
         ...fill ? { fill } : {},
         ...stroke ? { stroke } : {}
-      }, ...detail, ...rules, ...divider];
+      }, ...solid, ...detail, ...rules, ...divider];
     },
     // The drawn boundary, so picking and clipping follow the diamond rather
     // than its bounding box.
@@ -3288,6 +3152,10 @@ function diagramShape(opts = {}) {
     }
   };
 }
+function sequenceOutlineOf(node) {
+  if (sequencePartOf(node) === null) return void 0;
+  return node.data.diagram?.outline;
+}
 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 }]);
 }
@@ -3298,6 +3166,1348 @@ function registerDiagramShape(opts = {}) {
 // src/bodyNode.ts
 var isDiagramBody = (node) => diagramContainerOf(node) === null && diagramGroupOf(node) === null && dataKeyReader(node) !== null;
 var isBodyOrRegion = (node) => diagramContainerOf(node) !== null || isDiagramBody(node);
+
+// src/sequence/edit.ts
+var hasId = (s) => "id" in s;
+function stepListOf(steps, parent) {
+  if (parent === null) return steps;
+  const frag = findStep(steps, parent.fragment);
+  return frag?.kind === "fragment" ? frag.sections[parent.section]?.steps ?? null : null;
+}
+function findStep(steps, id) {
+  for (const s of steps) {
+    if (hasId(s) && s.id === id) return s;
+    if (s.kind === "fragment") {
+      for (const section of s.sections) {
+        const found = findStep(section.steps, id);
+        if (found !== null) return found;
+      }
+    }
+  }
+  return null;
+}
+function placeOf(steps, id, parent = null) {
+  for (const [index, s] of steps.entries()) {
+    if (hasId(s) && s.id === id) return { parent, index };
+    if (s.kind === "fragment") {
+      for (const [k, section] of s.sections.entries()) {
+        const found = placeOf(section.steps, id, { fragment: s.id, section: k });
+        if (found !== null) return found;
+      }
+    }
+  }
+  return null;
+}
+function mapSteps(steps, fn) {
+  let changed = false;
+  const out = steps.map((s) => {
+    let next = fn(s);
+    if (next.kind === "fragment") {
+      const frag = next;
+      const sections = frag.sections.map((section) => {
+        const inner = mapSteps(section.steps, fn);
+        return inner === section.steps ? section : { ...section, steps: inner };
+      });
+      if (sections.some((sec, k) => sec !== frag.sections[k])) next = { ...frag, sections };
+    }
+    if (next !== s) changed = true;
+    return next;
+  });
+  return changed ? out : steps;
+}
+function pruneSteps(steps, fn) {
+  let changed = false;
+  const out = [];
+  for (const s of steps) {
+    let step = s;
+    if (s.kind === "fragment") {
+      const sections = s.sections.map((sec) => {
+        const inner = pruneSteps(sec.steps, fn);
+        return inner === sec.steps ? sec : { ...sec, steps: inner };
+      });
+      if (sections.some((sec, k) => sec !== s.sections[k])) step = { ...s, sections };
+    }
+    const next = fn(step);
+    if (next !== s) changed = true;
+    if (next !== null) out.push(next);
+  }
+  return changed ? out : steps;
+}
+function withList(steps, parent, fn) {
+  if (parent === null) return fn(steps);
+  return mapSteps(steps, (s) => {
+    if (s.kind !== "fragment" || s.id !== parent.fragment) return s;
+    const sections = s.sections.map((sec, k) => k === parent.section ? { ...sec, steps: fn(sec.steps) } : sec);
+    return { ...s, sections };
+  });
+}
+var contains = (step, id) => step.kind === "fragment" && step.sections.some((sec) => sec.steps.some((s) => hasId(s) && s.id === id || contains(s, id)));
+function moveStep(data, id, to) {
+  const from = placeOf(data.steps, id);
+  const step = findStep(data.steps, id);
+  if (from === null || step === null) return data;
+  if (to.parent !== null && (to.parent.fragment === id || contains(step, to.parent.fragment))) return data;
+  if (stepListOf(data.steps, to.parent) === null) return data;
+  const sameList = JSON.stringify(from.parent) === JSON.stringify(to.parent);
+  if (sameList && (to.index === from.index || to.index === from.index + 1)) return data;
+  const removed = withList(data.steps, from.parent, (list) => list.filter((_, i) => i !== from.index));
+  const index = sameList && to.index > from.index ? to.index - 1 : to.index;
+  const steps = withList(removed, to.parent, (list) => [...list.slice(0, index), step, ...list.slice(index)]);
+  return { ...data, steps };
+}
+function moveParticipant(data, id, index) {
+  const from = data.participants.findIndex((p2) => p2.id === id);
+  if (from < 0 || index === from || index === from + 1) return data;
+  const p = data.participants[from];
+  const rest = data.participants.filter((_, i) => i !== from);
+  const at = index > from ? index - 1 : index;
+  return { ...data, participants: [...rest.slice(0, at), p, ...rest.slice(at)] };
+}
+function reconnectMessage(data, id, end, participant) {
+  const step = findStep(data.steps, id);
+  if (step?.kind !== "message" || step[end] === participant || !data.participants.some((p) => p.id === participant)) return data;
+  return { ...data, steps: mapSteps(data.steps, (s) => s === step ? { ...step, [end]: participant } : s) };
+}
+function setSequenceText(data, target, text) {
+  if ("participant" in target) {
+    const at = data.participants.findIndex((p2) => p2.id === target.participant);
+    const p = data.participants[at];
+    if (p === void 0 || (p.label ?? p.id) === text) return data;
+    const { label: _label, ...rest } = p;
+    const next = text === "" || text === p.id ? rest : { ...rest, label: text };
+    return { ...data, participants: data.participants.map((q, i) => i === at ? next : q) };
+  }
+  if ("box" in target) {
+    const boxes = data.boxes?.map((b) => {
+      if (b.id !== target.box || (b.label ?? "") === text) return b;
+      const { label: _label, ...rest } = b;
+      return text === "" ? rest : { ...rest, label: text };
+    });
+    return boxes === void 0 || boxes.every((b, i) => b === data.boxes[i]) ? data : { ...data, boxes };
+  }
+  if ("fragment" in target) {
+    const steps2 = mapSteps(data.steps, (s) => {
+      if (s.kind !== "fragment" || s.id !== target.fragment) return s;
+      const section = s.sections[target.section];
+      if (section === void 0 || (section.label ?? "") === text) return s;
+      const { label: _label, ...rest } = section;
+      const next = text === "" ? rest : { ...rest, label: text };
+      return { ...s, sections: s.sections.map((sec, k) => k === target.section ? next : sec) };
+    });
+    return steps2 === data.steps ? data : { ...data, steps: steps2 };
+  }
+  const steps = mapSteps(data.steps, (s) => {
+    if (s.kind === "note" && s.id === target.step && s.text !== text) return { ...s, text };
+    if (s.kind !== "message" || s.id !== target.step || (s.text ?? "") === text) return s;
+    const { text: _text, ...rest } = s;
+    return text === "" ? rest : { ...rest, text };
+  });
+  return steps === data.steps ? data : { ...data, steps };
+}
+function sequenceTextOf(data, target) {
+  if ("participant" in target) {
+    const p = data.participants.find((q) => q.id === target.participant);
+    return p === void 0 ? null : p.label ?? p.id;
+  }
+  if ("box" in target) {
+    const b = data.boxes?.find((q) => q.id === target.box);
+    return b === void 0 ? null : b.label ?? "";
+  }
+  if ("fragment" in target) {
+    const f = findStep(data.steps, target.fragment);
+    const section = f?.kind === "fragment" ? f.sections[target.section] : void 0;
+    return section === void 0 ? null : section.label ?? "";
+  }
+  const s = findStep(data.steps, target.step);
+  return s?.kind === "message" ? s.text ?? "" : s?.kind === "note" ? s.text : null;
+}
+
+// src/sequence/metrics.ts
+var SEQ = {
+  /** Around the whole diagram. */
+  margin: 12,
+  /** Between a head's outline and its text. */
+  headPad: 10,
+  headMinWidth: 80,
+  headMinHeight: 36,
+  /** The least room between two heads. */
+  columnGap: 32,
+  /** Either side of a message's text along its line. */
+  textPad: 10,
+  /** Above every row. */
+  rowGap: 14,
+  /** Between a message's text and its line. */
+  textGap: 3,
+  /** A self-message's loop: how far it reaches right, and how tall it is. */
+  loopWidth: 32,
+  loopHeight: 20,
+  /** An activation bar's width, and how far each nested one steps right. */
+  barWidth: 10,
+  barStep: 5,
+  notePad: 6,
+  noteMinWidth: 60,
+  /** Between a lifeline and a note beside it. */
+  noteGap: 10,
+  /** How far a note over two lifelines reaches past them. */
+  noteOverhang: 16,
+  /** Between a fragment's box and the lifelines it holds, and between nested boxes. */
+  fragmentPad: 14,
+  fragmentNest: 8,
+  /** Around a fragment's type label in its tab. */
+  tabPad: 6,
+  /** Between a box's border and the heads it holds. */
+  boxPad: 10,
+  /** Below the last row. */
+  footer: 16,
+  /** The X at a destroyed lifeline's end. */
+  cross: 12
+};
+function seqMeasure(measure, font = DEFAULT_FONT) {
+  const line = measure ?? ((text, s) => {
+    const size = s.fontSize ?? font.fontSize;
+    return { width: text.length * GLYPH * size, height: Math.ceil(1.4 * size) };
+  });
+  return {
+    font,
+    text: (text, style = {}) => {
+      const s = { ...style, fontFamily: style.fontFamily ?? font.fontFamily, fontSize: style.fontSize ?? font.fontSize };
+      const sizes = text.split("\n").map((l) => line(l, s));
+      return { width: Math.max(0, ...sizes.map((z) => z.width)), height: sizes.reduce((h, z) => h + z.height, 0) };
+    }
+  };
+}
+function headSize(p, m) {
+  const t = m.text(p.label ?? p.id);
+  const outline = p.outline ?? "rect";
+  const box = boxForContent(outline, { width: t.width + SEQ.headPad * 2, height: t.height + SEQ.headPad * 2 });
+  return { width: Math.max(SEQ.headMinWidth, Math.ceil(box.width)), height: Math.max(SEQ.headMinHeight, Math.ceil(box.height)) };
+}
+
+// src/sequence/columns.ts
+function* flatSteps(steps) {
+  for (const s of steps) {
+    yield s;
+    if (s.kind === "fragment") for (const section of s.sections) yield* flatSteps(section.steps);
+  }
+}
+function noteNeeds(over, side, width, half) {
+  const [a, b] = [Math.min(...over), Math.max(...over)];
+  const room = width + SEQ.noteGap * 2;
+  if (side === "right") return [{ a, b: a + 1, room: room + half(a + 1) }];
+  if (side === "left") return [{ a: a - 1, b: a, room: room + half(a - 1) }];
+  if (a === b) return [{ a: a - 1, b: a, room: width / 2 + half(a - 1) + SEQ.noteGap }, { a, b: a + 1, room: width / 2 + half(a + 1) + SEQ.noteGap }];
+  return [{ a, b, room: width - SEQ.noteOverhang * 2 }];
+}
+function needsOf(data, m, index, half) {
+  const out = [];
+  const numbered = data.autonumber !== void 0;
+  for (const s of flatSteps(data.steps)) {
+    if (s.kind === "message") {
+      const a = index.get(s.from);
+      const b = index.get(s.to);
+      if (a === void 0 || b === void 0) continue;
+      const text = (s.text ?? "") === "" ? 0 : m.text(s.text).width;
+      const room = text + SEQ.textPad * 2 + SEQ.barWidth * 2 + (numbered ? SEQ.textPad * 2 : 0);
+      if (a === b) out.push({ a, b: a + 1, room: SEQ.loopWidth + room + half(a + 1) });
+      else out.push({ a: Math.min(a, b), b: Math.max(a, b), room });
+    } else if (s.kind === "note") {
+      const over = s.over.map((id) => index.get(id)).filter((i) => i !== void 0);
+      if (over.length > 0) out.push(...noteNeeds(over, s.side, Math.max(SEQ.noteMinWidth, m.text(s.text).width + SEQ.notePad * 2), half));
+    }
+  }
+  return out;
+}
+function columnsOf(data, m, left) {
+  const ps = data.participants;
+  const heads = ps.map((p) => headSize(p, m));
+  const index = new Map(ps.map((p, i) => [p.id, i]));
+  const boxOf = /* @__PURE__ */ new Map();
+  for (const b of data.boxes ?? []) for (const id of b.members) if (!boxOf.has(id)) boxOf.set(id, b.id);
+  const half = (i) => (heads[i]?.width ?? 0) / 2;
+  const boxPad = (i) => i >= 0 && i < ps.length && boxOf.has(ps[i].id) ? SEQ.boxPad : 0;
+  const gaps = Array.from({ length: ps.length + 1 }, (_, i) => {
+    if (i === 0) return half(0) + boxPad(0);
+    if (i === ps.length) return half(i - 1) + boxPad(i - 1);
+    const split = boxOf.get(ps[i - 1].id) !== boxOf.get(ps[i].id);
+    return half(i - 1) + half(i) + SEQ.columnGap + (split ? boxPad(i - 1) + boxPad(i) : 0);
+  });
+  const needs = needsOf(data, m, index, half).sort((p, q) => p.b - p.a - (q.b - q.a));
+  for (const { a, b, room } of needs) {
+    const lo = Math.max(a, -1) + 1;
+    const hi = Math.min(b, ps.length) + 1;
+    let have = 0;
+    for (let i = lo; i < hi; i++) have += gaps[i];
+    const lack = room - have;
+    if (lack > 0) for (let i = lo; i < hi; i++) gaps[i] += lack / (hi - lo);
+  }
+  const x = [];
+  let at = left;
+  for (let i = 0; i < ps.length; i++) {
+    at += gaps[i];
+    x.push(at);
+  }
+  return { x, heads, right: at + gaps[ps.length] };
+}
+
+// src/sequence/rows.ts
+var spanOf = (rects) => {
+  const x0 = Math.min(...rects.map((r) => r.x));
+  return { x0, x1: Math.max(...rects.map((r) => r.x + r.width)) };
+};
+var RowWalk = class {
+  constructor(data, m, cols, top) {
+    this.data = data;
+    this.m = m;
+    this.cols = cols;
+    this.index = new Map(data.participants.map((p, i) => [p.id, i]));
+    this.created = new Set(flatMarks(data.steps, "create"));
+    this.number = data.autonumber;
+    const shown = data.participants.filter((p) => !this.created.has(p.id));
+    const tall = Math.max(SEQ.headMinHeight, ...shown.map((p) => cols.heads[this.index.get(p.id)].height));
+    for (const p of shown) this.placeHead(p.id, top + tall - cols.heads[this.index.get(p.id)].height, false);
+    for (const l of this.lifeline.values()) l.y0 = top + tall;
+    this.y = top + tall;
+  }
+  data;
+  m;
+  cols;
+  out = { heads: [], lifelines: [], messages: [], activations: [], notes: [], fragments: [], slots: [], bottom: 0 };
+  index;
+  created;
+  lifeline = /* @__PURE__ */ new Map();
+  bars = /* @__PURE__ */ new Map();
+  /** Lifelines a `destroy` ends at the next message to them, each with where it ends if none comes. */
+  destroying = /* @__PURE__ */ new Map();
+  frames = [];
+  last = null;
+  number;
+  y;
+  cx(id) {
+    return this.cols.x[this.index.get(id)];
+  }
+  headRect(id) {
+    const size = this.cols.heads[this.index.get(id)];
+    return { x: this.cx(id) - size.width / 2, y: 0, width: size.width, height: 0 };
+  }
+  placeHead(id, y, created) {
+    const size = this.cols.heads[this.index.get(id)];
+    this.out.heads.push({ id, box: { x: this.cx(id) - size.width / 2, y, width: size.width, height: size.height }, created });
+    const line = { id, x: this.cx(id), y0: y + size.height, y1: null };
+    this.lifeline.set(id, line);
+    this.out.lifelines.push(line);
+    return y + size.height;
+  }
+  /** Into every open fragment's reach. */
+  touch(rect) {
+    for (const f of this.frames) f.push(rect);
+  }
+  /** Where a line meets `id`'s lifeline from `side`: the edge of its innermost open activation. */
+  endX(id, side) {
+    const depth = this.bars.get(id)?.length ?? 0;
+    if (depth === 0) return this.cx(id);
+    return this.cx(id) + side * (SEQ.barWidth / 2) + (depth - 1) * SEQ.barStep;
+  }
+  open(id, y, opener) {
+    const stack = this.bars.get(id) ?? [];
+    stack.push({ y, opener });
+    this.bars.set(id, stack);
+  }
+  close(id, y, closer) {
+    const stack = this.bars.get(id);
+    const bar = stack?.pop();
+    if (bar === void 0) return;
+    const start = bar.y;
+    const depth = stack.length;
+    const x = this.cx(id) - SEQ.barWidth / 2 + depth * SEQ.barStep;
+    const box = { x, y: start, width: SEQ.barWidth, height: Math.max(y, start + 8) - start };
+    this.out.activations.push({ participant: id, depth, box, opener: bar.opener, ...closer ? { closer } : {} });
+  }
+  steps(list, parent) {
+    list.forEach((step, index) => {
+      this.out.slots.push({ y: this.y, place: { parent, index } });
+      if (step.kind === "message") this.message(step);
+      else if (step.kind === "note") this.note(step);
+      else if (step.kind === "fragment") this.fragment(step);
+      else this.mark(step, { parent, index });
+    });
+    this.out.slots.push({ y: this.y, place: { parent, index: list.length } });
+  }
+  message(s) {
+    if (!this.index.has(s.from) || !this.index.has(s.to)) return;
+    this.y += SEQ.rowGap;
+    const text = (s.text ?? "") === "" ? null : this.m.text(s.text);
+    const lineY = this.y + Math.max(text === null ? 0 : text.height + SEQ.textGap, 6);
+    if (s.activate !== void 0) this.open(s[s.activate], lineY, { message: s.id, flag: "activate" });
+    const self = s.from === s.to;
+    const dir = self ? 1 : Math.sign(this.cx(s.to) - this.cx(s.from));
+    const x1 = this.endX(s.from, dir);
+    const x2 = self ? x1 : this.endX(s.to, -dir);
+    const place2 = { id: s.id, y: lineY, x1, x2 };
+    if (self) place2.loopY = lineY + SEQ.loopHeight;
+    if (text !== null) {
+      const x = self ? x1 + SEQ.textGap + 2 : (x1 + x2) / 2 - text.width / 2;
+      place2.text = { x, y: lineY - SEQ.textGap - text.height, ...text };
+      this.touch(place2.text);
+    }
+    if (this.number !== void 0) {
+      const n = this.m.text(String(this.number), { fontSize: Math.max(8, this.m.font.fontSize - 2) });
+      const d = Math.max(16, n.width + 6);
+      place2.number = { n: this.number++, box: { x: x1 - d / 2, y: lineY - d / 2, width: d, height: d } };
+    }
+    this.out.messages.push(place2);
+    this.touch(this.headRect(s.from));
+    this.touch(this.headRect(s.to));
+    if (self) this.touch({ x: x1, y: lineY, width: SEQ.loopWidth, height: 0 });
+    if (s.deactivate !== void 0) this.close(s[s.deactivate], self ? place2.loopY : lineY, { message: s.id, flag: "deactivate" });
+    for (const id of /* @__PURE__ */ new Set([s.from, s.to])) {
+      if (!this.destroying.delete(id)) continue;
+      const line = this.lifeline.get(id);
+      if (line !== void 0) line.y1 = self ? place2.loopY : lineY;
+    }
+    this.y = place2.loopY ?? lineY;
+    this.last = { y: this.y, ends: [s.from, s.to] };
+  }
+  note(s) {
+    const over = s.over.filter((id) => this.index.has(id));
+    if (over.length === 0) return;
+    this.y += SEQ.rowGap;
+    const t = this.m.text(s.text);
+    const width = Math.max(SEQ.noteMinWidth, t.width + SEQ.notePad * 2);
+    const height = t.height + SEQ.notePad * 2;
+    const xs = over.map((id) => this.cx(id));
+    const [lo, hi] = [Math.min(...xs), Math.max(...xs)];
+    const x = s.side === "right" ? lo + SEQ.barWidth / 2 + SEQ.noteGap : s.side === "left" ? lo - SEQ.barWidth / 2 - SEQ.noteGap - width : lo === hi ? lo - width / 2 : Math.min(lo - SEQ.noteOverhang, (lo + hi) / 2 - width / 2);
+    const box = { x, y: this.y, width: s.side === void 0 && lo !== hi ? Math.max(width, hi - lo + SEQ.noteOverhang * 2) : width, height };
+    this.out.notes.push({ id: s.id, box });
+    this.touch(box);
+    for (const id of over) this.touch(this.headRect(id));
+    this.y += height;
+    this.last = null;
+  }
+  mark(s, at) {
+    if (!this.index.has(s.participant)) return;
+    this.touch(this.headRect(s.participant));
+    const y = this.last?.ends.includes(s.participant) ? this.last.y : this.y + SEQ.rowGap / 2;
+    if (s.kind === "activate") this.open(s.participant, y, { place: at });
+    else if (s.kind === "deactivate") this.close(s.participant, y, { place: at });
+    else if (s.kind === "destroy") {
+      this.destroying.set(s.participant, this.last?.ends.includes(s.participant) ? this.last.y : null);
+      const line = this.lifeline.get(s.participant);
+      if (line !== void 0) line.destroyedBy = at;
+    } else if (this.out.heads.every((h) => h.id !== s.participant)) {
+      this.y = this.placeHead(s.participant, this.y + SEQ.rowGap, true);
+      this.last = null;
+    }
+  }
+  fragment(s) {
+    this.y += SEQ.rowGap;
+    const top = this.y;
+    const tabText = s.type === "region" ? null : this.m.text(s.type, { bold: true });
+    const tab = tabText === null ? null : { width: tabText.width + SEQ.tabPad * 2, height: tabText.height + SEQ.tabPad };
+    const labels = s.sections.map((sec) => (sec.label ?? "") === "" ? null : this.m.text(sec.label));
+    this.y += Math.max(tab?.height ?? 0, (labels[0]?.height ?? 0) + 4, 8);
+    const frame = [];
+    this.frames.push(frame);
+    const sections = [];
+    s.sections.forEach((sec, k) => {
+      if (k > 0) {
+        this.y += SEQ.rowGap / 2;
+        sections.push({ y: this.y, height: 0 });
+        this.y += (labels[k]?.height ?? 0) + 4;
+      } else sections.push({ y: top, height: 0 });
+      this.steps(sec.steps, { fragment: s.id, section: k });
+      this.last = null;
+    });
+    this.frames.pop();
+    this.y += SEQ.rowGap / 2;
+    const reach = frame.length > 0 ? spanOf(frame) : { x0: this.cols.x[0] ?? 0, x1: this.cols.x.at(-1) ?? 0 };
+    const minWidth = (tab?.width ?? 0) + (labels[0]?.width ?? 0) + SEQ.tabPad * 4;
+    const x0 = reach.x0 - SEQ.fragmentPad / 2;
+    const width = Math.max(reach.x1 - reach.x0 + SEQ.fragmentPad, minWidth);
+    const box = { x: x0, y: top, width, height: this.y - top };
+    const place2 = {
+      id: s.id,
+      type: s.type,
+      box,
+      sections: sections.map((sec, k) => {
+        const l = labels[k];
+        if (l === null || l === void 0) return { y: sec.y };
+        const label = k === 0 ? { x: x0 + (tab?.width ?? 0) + SEQ.tabPad * 2, y: top + 2, ...l } : { x: x0 + width / 2 - l.width / 2, y: sec.y + 2, ...l };
+        return { y: sec.y, label };
+      })
+    };
+    if (tab !== null) place2.tab = { x: x0, y: top, ...tab };
+    this.out.fragments.push(place2);
+    this.touch({ x: box.x - SEQ.fragmentNest, y: top, width: box.width + SEQ.fragmentNest * 2, height: 0 });
+  }
+};
+function flatMarks(steps, kind) {
+  const out = [];
+  for (const s of steps) {
+    if (s.kind === kind) out.push(s.participant);
+    if (s.kind === "fragment") for (const sec of s.sections) out.push(...flatMarks(sec.steps, kind));
+  }
+  return out;
+}
+function walkRows(data, m, cols, top) {
+  const walk = new RowWalk(data, m, cols, top);
+  walk.steps(data.steps, null);
+  const bottom = walk.y + SEQ.rowGap;
+  for (const [id, fallback] of walk.destroying) {
+    const line = walk.lifeline.get(id);
+    if (line !== void 0) line.y1 = fallback ?? bottom;
+  }
+  for (const [id, stack] of walk.bars) while (stack.length > 0) walk.close(id, bottom + SEQ.footer);
+  walk.out.bottom = bottom;
+  return walk.out;
+}
+
+// src/sequence/layout.ts
+function unionRect(rects) {
+  if (rects.length === 0) return null;
+  const x = Math.min(...rects.map((r) => r.x));
+  const y = Math.min(...rects.map((r) => r.y));
+  return {
+    x,
+    y,
+    width: Math.max(...rects.map((r) => r.x + r.width)) - x,
+    height: Math.max(...rects.map((r) => r.y + r.height)) - y
+  };
+}
+function sequenceLayout(data, opts = {}) {
+  const m = seqMeasure(opts.measure, opts.font);
+  const boxLabelHeight = Math.max(0, ...(data.boxes ?? []).map((b) => (b.label ?? "") === "" ? 0 : m.text(b.label).height + 4));
+  const cols = columnsOf(data, m, SEQ.margin);
+  const top = SEQ.margin + (data.boxes?.length ? SEQ.boxPad : 0) + boxLabelHeight;
+  const rows = walkRows(data, m, cols, top);
+  const columns = data.participants.map((p, i) => ({ id: p.id, x: cols.x[i] }));
+  const foot = rows.bottom + SEQ.footer;
+  const lifelines = rows.lifelines.map((l) => ({ ...l, y1: l.y1 ?? foot, destroyed: l.y1 !== null }));
+  const boxes = (data.boxes ?? []).flatMap((b) => {
+    const heads = rows.heads.filter((h) => b.members.includes(h.id)).map((h) => h.box);
+    const around = unionRect(heads);
+    if (around === null) return [];
+    const label = (b.label ?? "") === "" ? null : m.text(b.label);
+    const x = around.x - SEQ.boxPad;
+    const width = around.width + SEQ.boxPad * 2;
+    const y = SEQ.margin;
+    const box = { x, y, width, height: foot + SEQ.boxPad - y };
+    return [{ id: b.id, box, ...label ? { label: { x: x + (width - label.width) / 2, y: y + 2, ...label } } : {} }];
+  });
+  const all = unionRect([
+    ...rows.heads.map((h) => h.box),
+    ...rows.notes.map((n) => n.box),
+    ...rows.fragments.map((f) => f.box),
+    ...boxes.map((b) => b.box),
+    ...rows.messages.flatMap((msg) => msg.text ? [msg.text] : []),
+    { x: 0, y: 0, width: cols.right, height: foot }
+  ]);
+  return {
+    width: Math.ceil(all.x + all.width + SEQ.margin),
+    height: Math.ceil(Math.max(foot, all.y + all.height) + SEQ.margin),
+    columns,
+    heads: rows.heads,
+    lifelines,
+    messages: rows.messages,
+    activations: rows.activations,
+    notes: rows.notes,
+    fragments: rows.fragments,
+    boxes,
+    slots: rows.slots
+  };
+}
+var SEQUENCE_ROLES = { note: "warning", number: "accent" };
+var DASH = [6, 4];
+var LIFELINE_DASH = [4, 4];
+var MARKERS = { arrow: "arrow", open: "arrow-open", cross: null, none: null };
+var PartSpecs = class {
+  constructor(root, at, font) {
+    this.root = root;
+    this.at = at;
+    this.font = font;
+  }
+  root;
+  at;
+  font;
+  specs = [];
+  place(r) {
+    return { x: this.at.x + r.x, y: this.at.y + r.y, width: r.width, height: r.height };
+  }
+  push(id, seq, r, data) {
+    this.specs.push({
+      id: `${this.root}/${id}`,
+      kind: "mark",
+      layer: "main",
+      parent: this.root,
+      pickable: false,
+      pose: this.place(r),
+      data: { ...data, diagram: { ...data.diagram, seq: { root: this.root, ...seq } } }
+    });
+  }
+  body(id, part, of, r, outline, style, dash) {
+    const lines = dash ?? style.dash;
+    this.push(id, { part, ...of !== void 0 ? { id: of } : {} }, r, {
+      diagram: { outline },
+      fill: { paint: { color: style.fill } },
+      stroke: { paint: { color: style.stroke }, width: style.strokeWidth ?? 1.5, ...lines !== void 0 && lines.length > 0 ? { dash: lines } : {} }
+    });
+  }
+  line(id, part, of, r, d, stroke, fill) {
+    this.push(id, { part, ...of !== void 0 ? { id: of } : {} }, r, {
+      diagram: { mark: { d } },
+      stroke,
+      ...fill !== void 0 ? { fill: { paint: { color: fill } } } : {}
+    });
+  }
+  /** The marks the part just pushed draws, onto its trait. */
+  marks(refs) {
+    const seq = this.specs.at(-1).data.diagram.seq;
+    seq.marks = refs;
+  }
+  text(id, r, text, color, target, face = {}, centered = true) {
+    const box = { ...r, x: r.x - 1, width: r.width + 2 };
+    this.push(id, { part: "text", ...target ? { target } : {} }, box, {
+      text,
+      style: { ...this.font, ...centered ? { align: "center" } : {}, ...face },
+      verticalAlign: "center",
+      fill: { paint: { color } }
+    });
+  }
+};
+function participantSpecs(out, data, layout, theme) {
+  for (const l of layout.lifelines) {
+    const p = data.participants.find((q) => q.id === l.id);
+    const style = withColors(roleStyle(theme, p.style), p.colors);
+    out.line(
+      `life:${l.id}`,
+      "lifeline",
+      l.id,
+      { x: l.x - 1, y: l.y0, width: 2, height: Math.max(l.y1 - l.y0, 0) },
+      "M0.5 0V1",
+      { paint: { color: style.stroke }, width: 1, dash: LIFELINE_DASH }
+    );
+    if (l.destroyed) {
+      const c = SEQ.cross;
+      out.line(
+        `destroy:${l.id}`,
+        "destroy",
+        l.id,
+        { x: l.x - c / 2, y: l.y1 - c / 2, width: c, height: c },
+        "M0 0L1 1M1 0L0 1",
+        { paint: { color: style.stroke }, width: 2 }
+      );
+      if (l.destroyedBy) out.marks([{ place: l.destroyedBy }]);
+    }
+  }
+  for (const [i, a] of layout.activations.entries()) {
+    const p = data.participants.find((q) => q.id === a.participant);
+    out.body(`act:${i}`, "activation", a.participant, a.box, "rect", withColors(roleStyle(theme, p.style), p.colors));
+    out.marks(a.closer ? [a.opener, a.closer] : [a.opener]);
+  }
+}
+function headSpecs(out, data, layout, theme) {
+  for (const h of layout.heads) {
+    const p = data.participants.find((q) => q.id === h.id);
+    const style = withColors(roleStyle(theme, p.style), p.colors);
+    const outline = p.outline ?? "rect";
+    out.body(`head:${p.id}`, "head", p.id, h.box, outline, style);
+    out.text(`head:${p.id}/text`, contentBox(outline, h.box), p.label ?? p.id, style.text, { participant: p.id });
+  }
+}
+function messageSpecs(out, steps, layout, theme) {
+  const byId = new Map(layout.messages.map((m) => [m.id, m]));
+  const edge = roleEdgeStyle(theme);
+  const width = edge.width ?? 1.5;
+  for (const msg of flatSteps(steps)) {
+    const at = msg.kind === "message" ? byId.get(msg.id) : void 0;
+    if (at === void 0 || msg.kind !== "message") continue;
+    const s = msg;
+    const marker = MARKERS[msg.head];
+    const stroke = {
+      paint: { color: edge.stroke },
+      width,
+      ...msg.line === "dashed" ? { dash: DASH } : {},
+      ...marker !== null ? { markerEnd: marker } : {},
+      ...marker !== null && msg.both ? { markerStart: marker } : {}
+    };
+    if (at.loopY !== void 0) {
+      out.line(`msg:${s.id}`, "message", s.id, { x: at.x1, y: at.y, width: SEQ.loopWidth, height: at.loopY - at.y }, "M0 0H1V1H0", stroke);
+    } else {
+      const d = at.x2 >= at.x1 ? "M0 0H1" : "M1 0H0";
+      out.line(`msg:${s.id}`, "message", s.id, { x: Math.min(at.x1, at.x2), y: at.y, width: Math.abs(at.x2 - at.x1), height: 0 }, d, stroke);
+    }
+    if (msg.head === "cross") {
+      const c = SEQ.cross * 0.8;
+      const end = { x: at.x2, y: at.loopY ?? at.y };
+      out.line(
+        `msg:${s.id}/cross`,
+        "message",
+        s.id,
+        { x: end.x - c / 2, y: end.y - c / 2, width: c, height: c },
+        "M0 0L1 1M1 0L0 1",
+        { paint: { color: edge.stroke }, width }
+      );
+    }
+    if (at.text) out.text(`msg:${s.id}/text`, at.text, msg.text ?? "", edge.label ?? edge.stroke, { step: s.id }, {}, msg.from !== msg.to);
+    if (at.number) {
+      const style = roleStyle(theme, SEQUENCE_ROLES.number);
+      out.body(`msg:${s.id}/number`, "number", s.id, at.number.box, "ellipse", style);
+      out.text(`msg:${s.id}/number/text`, at.number.box, String(at.number.n), style.text, void 0, { fontSize: Math.max(8, out.font.fontSize - 2) });
+    }
+  }
+}
+function noteSpecs(out, steps, layout, theme) {
+  const byId = new Map(layout.notes.map((n) => [n.id, n]));
+  const style = roleStyle(theme, SEQUENCE_ROLES.note);
+  for (const s of flatSteps(steps)) {
+    const at = s.kind === "note" ? byId.get(s.id) : void 0;
+    if (at === void 0 || s.kind !== "note") continue;
+    out.body(`note:${s.id}`, "note", s.id, at.box, "note", style);
+    out.text(`note:${s.id}/text`, contentBox("note", at.box), s.text, style.text, { step: s.id });
+  }
+}
+function fragmentSpecs(out, steps, layout, theme, boxesOnly) {
+  const byId = new Map(layout.fragments.map((f) => [f.id, f]));
+  for (const s of flatSteps(steps)) {
+    const at = s.kind === "fragment" ? byId.get(s.id) : void 0;
+    if (at === void 0 || s.kind !== "fragment") continue;
+    const style = withColors({ ...theme.container, ...s.type === "region" ? {} : { fill: "transparent" } }, s.colors);
+    if (boxesOnly) {
+      out.body(`frag:${s.id}`, "fragment", s.id, at.box, "rect", { ...style, strokeWidth: 1 }, []);
+      continue;
+    }
+    at.sections.forEach((sec, k) => {
+      if (k > 0) {
+        out.line(
+          `frag:${s.id}/divider:${k}`,
+          "divider",
+          s.id,
+          { x: at.box.x, y: sec.y, width: at.box.width, height: 0 },
+          "M0 0H1",
+          { paint: { color: style.stroke }, width: 1, dash: DASH }
+        );
+      }
+      if (sec.label) out.text(`frag:${s.id}/label:${k}`, sec.label, s.sections[k].label ?? "", style.text, { fragment: s.id, section: k });
+    });
+    if (at.tab) {
+      out.line(`frag:${s.id}/tab`, "fragment", s.id, at.tab, "M0 0H1V0.6L0.85 1H0Z", { paint: { color: style.stroke }, width: 1 }, theme.container.fill);
+      out.text(`frag:${s.id}/type`, at.tab, s.type, style.text, void 0, { fontWeight: 700 });
+    }
+  }
+}
+function boxSpecs(out, data, layout, theme) {
+  for (const b of layout.boxes) {
+    const own = data.boxes?.find((q) => q.id === b.id);
+    const style = withColors(theme.container, own?.colors);
+    out.body(`box:${b.id}`, "box", b.id, b.box, "rect", { ...style, strokeWidth: 1 }, []);
+    if (b.label) out.text(`box:${b.id}/text`, b.label, own?.label ?? "", style.text, { box: b.id });
+  }
+}
+var geometryOf = (layout) => ({
+  columns: layout.columns,
+  slots: layout.slots,
+  messages: layout.messages,
+  notes: layout.notes,
+  heads: layout.heads.map(({ id, box }) => ({ id, box })),
+  fragments: layout.fragments.map(({ id, box, tab }) => ({ id, grip: tab ?? { ...box, height: Math.min(box.height, SEQ.rowGap) } })),
+  boxes: layout.boxes.map(({ id, box, label }) => ({ id, grip: { ...box, height: (label?.height ?? 0) + SEQ.boxPad } })),
+  marks: [
+    ...layout.activations.map((a, i) => ({ id: `act:${i}`, grip: a.box })),
+    ...layout.lifelines.flatMap((l) => l.destroyedBy === void 0 ? [] : [{ id: `destroy:${l.id}`, grip: crossGrip(l.x, l.y1) }])
+  ]
+});
+var crossGrip = (x, y) => {
+  const c = Math.max(SEQ.cross, 12);
+  return { x: x - c / 2, y: y - c / 2, width: c, height: c };
+};
+function sequenceSpecs(data, opts) {
+  const theme = opts.theme ?? diagramThemeFrom(void 0);
+  const font = opts.font ?? themeFont(theme);
+  const layout = sequenceLayout(data, { font, ...opts.measure ? { measure: opts.measure } : {} });
+  const at = opts.at ?? { x: 0, y: 0 };
+  const out = new PartSpecs(opts.id, at, font);
+  out.specs.push({
+    id: opts.id,
+    kind: "mark",
+    layer: "main",
+    pose: out.place({ x: 0, y: 0, width: layout.width, height: layout.height }),
+    data: { diagram: { sequence: data, geometry: geometryOf(layout) } }
+  });
+  boxSpecs(out, data, layout, theme);
+  fragmentSpecs(out, data.steps, layout, theme, true);
+  participantSpecs(out, data, layout, theme);
+  messageSpecs(out, data.steps, layout, theme);
+  noteSpecs(out, data.steps, layout, theme);
+  headSpecs(out, data, layout, theme);
+  fragmentSpecs(out, data.steps, layout, theme, false);
+  const layer = opts.layer ?? "main";
+  return localizeWorldPoses(out.specs, opts.composition ?? RIGID_POSE_COMPOSITION).map((s) => ({ ...s, layer }));
+}
+var worldPose = (scene, id) => composeWorldPose(scenePoseAdapter(scene), id, scene.composition.compose);
+function rebuild(scene, id, data, opts) {
+  const root = scene.get(id);
+  const at = worldPose(scene, id);
+  const [own, ...parts] = sequenceSpecs(data, {
+    id,
+    at,
+    theme: opts.theme ?? diagramThemeOf(scene),
+    layer: root.layer,
+    composition: scene.composition,
+    ...opts.measure ? { measure: opts.measure } : {}
+  });
+  const selected = scene.getSelection();
+  scene.removeMany([...scene.childrenOf(id)]);
+  const pose = root.pose;
+  scene.update(id, { data: own.data });
+  scene.setPose(id, { ...pose, width: own.pose.width, height: own.pose.height });
+  for (const part of parts) scene.add(part);
+  const kept = selected.filter((s) => scene.get(s) !== void 0);
+  if (kept.length !== scene.getSelection().length) scene.setSelection(kept);
+}
+function commitSequence(scene, id, data, label, opts = {}) {
+  const node = scene.get(id);
+  if (node === void 0 || sequenceRootOf(node) === null) return;
+  scene.batch(label, () => rebuild(scene, id, data, opts));
+}
+function startSequence(scene, at, data, label, opts = {}) {
+  const id = scene.mintId();
+  const layer = opts.layer ?? scene.layers[0]?.id ?? "main";
+  const specs = sequenceSpecs(data, {
+    id,
+    at,
+    theme: opts.theme ?? diagramThemeOf(scene),
+    layer,
+    composition: scene.composition,
+    ...opts.measure ? { measure: opts.measure } : {}
+  });
+  scene.batch(label, () => {
+    for (const spec of specs) scene.add(spec);
+  });
+  return id;
+}
+function redrawSequences(scene, opts = {}) {
+  for (const node of scene.renderOrderNodes()) {
+    const root = sequenceRootOf(node);
+    if (root !== null) rebuild(scene, node.id, root.sequence, opts);
+  }
+}
+function foldSequenceText(scene, textId, commit) {
+  const node = scene.get(textId);
+  const part = node === void 0 ? null : sequencePartOf(node);
+  const root = part === null ? void 0 : scene.get(part.root);
+  const held = root === void 0 ? null : sequenceRootOf(root);
+  if (part === null || held === null || part.target === void 0) return;
+  const text = node.data.text;
+  if (typeof text !== "string") return;
+  const next = setSequenceText(held.sequence, part.target, text);
+  if (next === held.sequence) return;
+  scene.undo();
+  commit({ id: part.root, data: next, label: "Edit text" });
+}
+function sequenceCommitOf(opts) {
+  return opts.commit ?? ((edit, ctx) => {
+    const scene = ctx.deps.scene;
+    if (scene !== void 0) commitSequence(scene, edit.id, edit.data, edit.label, opts);
+  });
+}
+
+// src/sequence/author.ts
+function idsOf(data) {
+  const ids = new Set(data.participants.map((p) => p.id));
+  for (const s of flatSteps(data.steps)) if (hasId(s)) ids.add(s.id);
+  for (const b of data.boxes ?? []) ids.add(b.id);
+  return ids;
+}
+var seqIdTaken = (data, id) => idsOf(data).has(id);
+function freshSeqId(data, prefix) {
+  const ids = idsOf(data);
+  let n = 1;
+  while (ids.has(`${prefix}${n}`)) n++;
+  return `${prefix}${n}`;
+}
+function newParticipant(data, kind = "participant") {
+  const id = freshSeqId(data, kind === "actor" ? "A" : "P");
+  const label = `${kind === "actor" ? "Actor" : "Participant"} ${id.slice(1)}`;
+  return { id, label, ...kind === "actor" ? { outline: "actor" } : {} };
+}
+function addParticipant(data, p, index = data.participants.length) {
+  if (seqIdTaken(data, p.id)) return data;
+  const at = Math.max(0, Math.min(index, data.participants.length));
+  return { ...data, participants: [...data.participants.slice(0, at), p, ...data.participants.slice(at)] };
+}
+function removeParticipant(data, id) {
+  if (!data.participants.some((p) => p.id === id)) return data;
+  const steps = pruneSteps(data.steps, (s) => {
+    if (s.kind === "message") return s.from === id || s.to === id ? null : s;
+    if (s.kind === "note") {
+      if (!s.over.includes(id)) return s;
+      const over = s.over.filter((q) => q !== id);
+      return over.length === 0 ? null : { ...s, over };
+    }
+    if (s.kind === "fragment") return s;
+    return s.participant === id ? null : s;
+  });
+  const boxes = data.boxes?.flatMap((b) => {
+    if (!b.members.includes(id)) return [b];
+    const members2 = b.members.filter((m) => m !== id);
+    return members2.length === 0 ? [] : [{ ...b, members: members2 }];
+  });
+  const { boxes: _boxes, ...rest } = data;
+  return {
+    ...rest,
+    participants: data.participants.filter((p) => p.id !== id),
+    steps,
+    ...boxes !== void 0 && boxes.length > 0 ? { boxes } : {}
+  };
+}
+function setParticipantOutline(data, id, outline) {
+  const at = data.participants.findIndex((p2) => p2.id === id);
+  const p = data.participants[at];
+  const next = outline === "rect" ? void 0 : outline;
+  if (p === void 0 || p.outline === next) return data;
+  const { outline: _outline, ...rest } = p;
+  const q = next === void 0 ? rest : { ...rest, outline: next };
+  return { ...data, participants: data.participants.map((r, i) => i === at ? q : r) };
+}
+function addBox(data, box) {
+  const members2 = data.participants.filter((p) => box.members.includes(p.id));
+  if (members2.length === 0 || seqIdTaken(data, box.id)) return data;
+  const taken = new Set(members2.map((p) => p.id));
+  const first = data.participants.findIndex((p) => taken.has(p.id));
+  const before = data.participants.slice(0, first).filter((p) => !taken.has(p.id));
+  const after = data.participants.slice(first).filter((p) => !taken.has(p.id));
+  const others = (data.boxes ?? []).flatMap((b) => {
+    const left = b.members.filter((m) => !taken.has(m));
+    return left.length === 0 ? [] : [left.length === b.members.length ? b : { ...b, members: left }];
+  });
+  return {
+    ...data,
+    participants: [...before, ...members2, ...after],
+    boxes: [...others, { ...box, members: members2.map((p) => p.id) }]
+  };
+}
+function removeBox(data, id) {
+  if (!data.boxes?.some((b) => b.id === id)) return data;
+  const boxes = data.boxes.filter((b) => b.id !== id);
+  const { boxes: _boxes, ...rest } = data;
+  return boxes.length === 0 ? rest : { ...rest, boxes };
+}
+function setAutonumber(data, from) {
+  if (data.autonumber === from) return data;
+  const { autonumber: _n, ...rest } = data;
+  return from === void 0 ? rest : { ...rest, autonumber: from };
+}
+
+// src/sequence/authorSteps.ts
+var SEQ_ARROWS = {
+  /** A call: a solid line, a filled head. */
+  sync: { line: "solid", head: "arrow" },
+  /** An answer: a dashed line, a filled head. */
+  reply: { line: "dashed", head: "arrow" },
+  /** Sent without waiting: a solid line, an open head. */
+  async: { line: "solid", head: "open", async: true },
+  /** Lost or refused: a solid line ending in a cross. */
+  lost: { line: "solid", head: "cross" },
+  /** A plain solid line. */
+  line: { line: "solid", head: "none" },
+  /** A plain dashed line. */
+  dashed: { line: "dashed", head: "none" },
+  /** Both ways: a solid line, filled heads at both ends. */
+  both: { line: "solid", head: "arrow", both: true }
+};
+var SEQ_MULTI_SECTION = /* @__PURE__ */ new Set(["alt", "par", "critical"]);
+function insertStep(data, step, at) {
+  const list = stepListOf(data.steps, at.parent);
+  if (list === null || hasId(step) && seqIdTaken(data, step.id)) return data;
+  const index = Math.max(0, Math.min(at.index, list.length));
+  return { ...data, steps: withList(data.steps, at.parent, (l) => [...l.slice(0, index), step, ...l.slice(index)]) };
+}
+var known = (data, ...ids) => ids.every((id) => data.participants.some((p) => p.id === id));
+function insertMessage(data, m) {
+  if (!known(data, m.from, m.to)) return data;
+  const arrow = typeof m.arrow === "object" ? m.arrow : SEQ_ARROWS[m.arrow ?? "sync"];
+  const step = {
+    kind: "message",
+    id: m.id ?? freshSeqId(data, "m"),
+    from: m.from,
+    to: m.to,
+    ...arrow,
+    ...m.text ? { text: m.text } : {}
+  };
+  return insertStep(data, step, m.at);
+}
+function insertNote(data, n) {
+  if (n.over.length === 0 || !known(data, ...n.over)) return data;
+  const step = {
+    kind: "note",
+    id: n.id ?? freshSeqId(data, "n"),
+    over: n.side === void 0 ? [...n.over] : [n.over[0]],
+    ...n.side ? { side: n.side } : {},
+    text: n.text ?? "Note"
+  };
+  return insertStep(data, step, n.at);
+}
+function insertMark(data, mark, at) {
+  if (!known(data, mark.participant)) return data;
+  if (mark.kind === "create" && hasMark(data.steps, "create", mark.participant)) return data;
+  return insertStep(data, { kind: mark.kind, participant: mark.participant }, at);
+}
+function hasMark(steps, kind, participant) {
+  return steps.some((s) => s.kind === kind && s.participant === participant || s.kind === "fragment" && s.sections.some((sec) => hasMark(sec.steps, kind, participant)));
+}
+function removeStep(data, id) {
+  if (findStep(data.steps, id) === null) return data;
+  return { ...data, steps: pruneSteps(data.steps, (s) => hasId(s) && s.id === id ? null : s) };
+}
+function removeStepAt(data, at) {
+  const list = stepListOf(data.steps, at.parent);
+  if (list === null || at.index < 0 || at.index >= list.length) return data;
+  return { ...data, steps: withList(data.steps, at.parent, (l) => l.filter((_, i) => i !== at.index)) };
+}
+function removeMarks(data, refs) {
+  const key = (p) => p === null ? "" : `${p.fragment}/${p.section}`;
+  const places = refs.flatMap((r) => "place" in r ? [r.place] : []).filter((p) => {
+    const s = stepListOf(data.steps, p.parent)?.[p.index];
+    return s !== void 0 && !hasId(s);
+  }).sort((a, b) => key(a.parent) === key(b.parent) ? b.index - a.index : key(a.parent) < key(b.parent) ? -1 : 1);
+  let next = places.reduce((d, p) => removeStepAt(d, p), data);
+  for (const r of refs) if ("message" in r) next = setMessageActivation(next, r.message, { [r.flag]: void 0 });
+  return next;
+}
+function removeMarksOf(data, kind, participant) {
+  const steps = pruneSteps(data.steps, (s) => s.kind === kind && s.participant === participant ? null : s);
+  return steps === data.steps ? data : { ...data, steps };
+}
+function wrapSteps(data, parent, start, end, f) {
+  const list = stepListOf(data.steps, parent);
+  const id = f.id ?? freshSeqId(data, "f");
+  if (list === null || seqIdTaken(data, id)) return data;
+  const lo = Math.max(0, Math.min(start, end, list.length));
+  const hi = Math.max(lo, Math.min(Math.max(start, end), list.length));
+  const frag = {
+    kind: "fragment",
+    id,
+    type: f.type,
+    sections: [{ ...f.label ? { label: f.label } : {}, steps: list.slice(lo, hi) }]
+  };
+  return { ...data, steps: withList(data.steps, parent, (l) => [...l.slice(0, lo), frag, ...l.slice(hi)]) };
+}
+function unwrapFragment(data, id) {
+  const place2 = placeOf(data.steps, id);
+  const frag = findStep(data.steps, id);
+  if (place2 === null || frag?.kind !== "fragment") return data;
+  const inner = frag.sections.flatMap((sec) => sec.steps);
+  return { ...data, steps: withList(data.steps, place2.parent, (l) => [...l.slice(0, place2.index), ...inner, ...l.slice(place2.index + 1)]) };
+}
+function withFragment(data, id, fn) {
+  const steps = mapSteps(data.steps, (s) => s.kind === "fragment" && s.id === id ? fn(s) : s);
+  return steps === data.steps ? data : { ...data, steps };
+}
+function addSection(data, id, label, index) {
+  return withFragment(data, id, (f) => {
+    if (!SEQ_MULTI_SECTION.has(f.type)) return f;
+    const at = Math.max(1, Math.min(index ?? f.sections.length, f.sections.length));
+    const section = { ...label ? { label } : {}, steps: [] };
+    return { ...f, sections: [...f.sections.slice(0, at), section, ...f.sections.slice(at)] };
+  });
+}
+function removeSection(data, id, index) {
+  return withFragment(data, id, (f) => f.sections.length < 2 || f.sections[index] === void 0 ? f : { ...f, sections: f.sections.filter((_, k) => k !== index) });
+}
+function setFragmentType(data, id, type) {
+  return withFragment(data, id, (f) => f.type === type || f.sections.length > 1 && !SEQ_MULTI_SECTION.has(type) ? f : { ...f, type });
+}
+function withMessage(data, id, fn) {
+  const steps = mapSteps(data.steps, (s) => s.kind === "message" && s.id === id ? fn(s) : s);
+  return steps === data.steps ? data : { ...data, steps };
+}
+function setMessageArrow(data, id, arrow) {
+  const next = typeof arrow === "object" ? arrow : SEQ_ARROWS[arrow];
+  return withMessage(data, id, (m) => {
+    if (m.line === next.line && m.head === next.head && m.both === next.both && m.async === next.async) return m;
+    const { both: _both, async: _async, ...rest } = m;
+    return { ...rest, line: next.line, head: next.head, ...next.both ? { both: true } : {}, ...next.async ? { async: true } : {} };
+  });
+}
+function setMessageActivation(data, id, flags) {
+  return withMessage(data, id, (m) => {
+    const activate = "activate" in flags ? flags.activate : m.activate;
+    const deactivate = "deactivate" in flags ? flags.deactivate : m.deactivate;
+    if (activate === m.activate && deactivate === m.deactivate) return m;
+    const { activate: _a, deactivate: _d, ...rest } = m;
+    return { ...rest, ...activate ? { activate } : {}, ...deactivate ? { deactivate } : {} };
+  });
+}
+var SEQUENCE_LAYER_ID = "diagram-sequence";
+var SEQUENCE_AFFORDANCE_KIND = `layer:${SEQUENCE_LAYER_ID}`;
+function sequenceScratchOf(hit) {
+  const p = hit?.payload;
+  return p !== void 0 && typeof p.root === "string" && typeof p.id === "string" && typeof p.part === "string" ? p : null;
+}
+function placedSequences(scene) {
+  const out = [];
+  const poses = scenePoseAdapter(scene);
+  for (const node of scene.renderOrderNodes()) {
+    const root = sequenceRootOf(node);
+    if (root === null || scene.isLocked(node.id) || scene.isHidden(node.id)) continue;
+    const at = composeWorldPose(poses, node.id, scene.composition.compose);
+    out.push({ id: node.id, origin: { x: at.x, y: at.y }, width: at.width, height: at.height, geometry: root.geometry });
+  }
+  return out;
+}
+var REACH = 6;
+var END = 7;
+var moved = (r, o) => ({ x: r.x + o.x, y: r.y + o.y, width: r.width, height: r.height });
+function messageReach(m) {
+  const x0 = Math.min(m.x1, m.x2);
+  const x1 = m.loopY !== void 0 ? m.x1 + 32 : Math.max(m.x1, m.x2);
+  const y1 = (m.loopY ?? m.y) + REACH;
+  const top = Math.min(m.y - REACH, m.text?.y ?? Infinity);
+  const left = Math.min(x0, m.text?.x ?? Infinity);
+  const right = Math.max(x1, m.text ? m.text.x + m.text.width : -Infinity);
+  return { x: left, y: top, width: right - left, height: y1 - top };
+}
+function region(id, r, scratch, cursor) {
+  return {
+    id,
+    targetId: null,
+    shape: { kind: "rect", x: r.x, y: r.y, width: r.width, height: r.height },
+    cursor,
+    strength: "exclusive",
+    claimedKinds: ["pointer"],
+    bind: () => ({ initialScratch: scratch })
+  };
+}
+function regionsOf(all) {
+  const parts = [];
+  const ends = [];
+  for (const { id: root, origin, geometry } of all) {
+    const base = { targetId: root, root };
+    for (const h of geometry.heads) parts.push(region(`${root}/head:${h.id}`, moved(h.box, origin), { ...base, part: "head", id: h.id }, "ew-resize"));
+    for (const m of geometry.marks ?? []) parts.push(region(`${root}/${m.id}`, moved(m.grip, origin), { ...base, part: "mark", id: m.id }, "default"));
+    for (const b of geometry.boxes ?? []) parts.push(region(`${root}/box:${b.id}`, moved(b.grip, origin), { ...base, part: "box", id: b.id }, "default"));
+    for (const f of geometry.fragments ?? []) parts.push(region(`${root}/frag:${f.id}`, moved(f.grip, origin), { ...base, part: "step", id: f.id }, "ns-resize"));
+    for (const n of geometry.notes) parts.push(region(`${root}/note:${n.id}`, moved(n.box, origin), { ...base, part: "step", id: n.id }, "ns-resize"));
+    for (const m of geometry.messages) {
+      parts.push(region(`${root}/msg:${m.id}`, moved(messageReach(m), origin), { ...base, part: "step", id: m.id }, "ns-resize"));
+      const at = [["from", m.x1, m.y], ["to", m.x2, m.loopY ?? m.y]];
+      for (const [end, x, y] of at) {
+        const r = { x: x - END + origin.x, y: y - END + origin.y, width: END * 2, height: END * 2 };
+        ends.push(region(`${root}/msg:${m.id}/${end}`, r, { ...base, part: "end", id: m.id, end }, "crosshair"));
+      }
+    }
+  }
+  return { parts, ends };
+}
+var INDEXES = /* @__PURE__ */ new WeakMap();
+function regionsIn(scene) {
+  let index = INDEXES.get(scene);
+  if (index === void 0) {
+    index = keyedIndex(
+      () => typeof scene.getVersion === "function" ? [scene.getVersion()] : void 0,
+      () => regionsOf(placedSequences(scene))
+    );
+    INDEXES.set(scene, index);
+  }
+  return index() ?? regionsOf(placedSequences(scene));
+}
+function sequenceLayer(scene) {
+  const parts = { id: SEQUENCE_LAYER_ID, regions: () => regionsIn(scene).parts };
+  const ends = { id: `${SEQUENCE_LAYER_ID}-ends`, regions: () => regionsIn(scene).ends };
+  return composeAffordanceLayer(SEQUENCE_LAYER_ID, "Sequence diagram parts", [parts, ends]);
+}
+var SELECT_SEQUENCE_PART_ACTION_ID = "diagram.sequence.select";
+function sequencePartNodeOf(scene, s) {
+  if (s.part === "mark") return scene.get(`${s.root}/${s.id}`) === void 0 ? null : `${s.root}/${s.id}`;
+  const names = s.part === "head" ? [`head:${s.id}`] : s.part === "box" ? [`box:${s.id}`] : s.part === "end" ? [`msg:${s.id}`] : [`msg:${s.id}`, `note:${s.id}`, `frag:${s.id}`];
+  return names.map((n) => `${s.root}/${n}`).find((id) => scene.get(id) !== void 0) ?? null;
+}
+var selectSequencePartAction = {
+  id: SELECT_SEQUENCE_PART_ACTION_ID,
+  label: "Select sequence part",
+  group: "diagram",
+  requires: ["scene", "selection"],
+  invoker: {
+    timing: "immediate",
+    run(deps, params) {
+      const scene = deps.scene;
+      const selection = deps.selection;
+      const scratch = sequenceScratchOf(params?.affordance);
+      const id = scene === void 0 || scratch === null ? null : sequencePartNodeOf(scene, scratch);
+      if (id === null || selection === void 0) return;
+      const held = selection.get();
+      const shift = params?.mods?.shift === true;
+      selection.set(!shift ? [id] : held.includes(id) ? held.filter((h) => h !== id) : [...held, id]);
+    }
+  },
+  enabled: () => true
+};
+function removing(data, part) {
+  if (part.part === "head" || part.part === "lifeline") return removeParticipant(data, part.id);
+  if (part.part === "box") return removeBox(data, part.id);
+  if (part.part === "message" || part.part === "note" || part.part === "fragment" || part.part === "divider") return removeStep(data, part.id);
+  return data;
+}
+function sequenceDeletes(scene, ids) {
+  const byRoot = /* @__PURE__ */ new Map();
+  const rest = [];
+  for (const id of ids) {
+    const node = scene.get(id);
+    const part = node === void 0 ? null : sequencePartOf(node);
+    if (part === null) {
+      rest.push(id);
+      continue;
+    }
+    const root = scene.get(part.root);
+    const held = root === void 0 ? null : sequenceRootOf(root);
+    if (held === null) continue;
+    const at = byRoot.get(part.root) ?? { was: held.sequence, marks: [], parts: [] };
+    byRoot.set(part.root, at);
+    if (part.marks !== void 0) at.marks.push(...part.marks);
+    else if (part.id !== void 0) at.parts.push({ part: part.part, id: part.id });
+  }
+  const edits = [...byRoot].flatMap(([id, { was, marks, parts }]) => {
+    const data = parts.reduce(removing, removeMarks(was, marks));
+    return data === was ? [] : [{ id, data }];
+  });
+  return { edits, rest };
+}
+function createSequenceDeleteAction(opts = {}) {
+  const commit = sequenceCommitOf(opts);
+  const others = opts.others ?? commitDeleteToScene;
+  return createDeleteAction({
+    commit: (ids, deps) => {
+      const scene = deps.scene;
+      if (scene === void 0) return;
+      const { edits, rest } = sequenceDeletes(scene, ids);
+      for (const edit of edits) commit({ ...edit, label: "Delete" }, { deps });
+      if (rest.length > 0) others(rest, deps);
+      else deps.selection?.set([]);
+    }
+  });
+}
+
+// src/sequence/actions.ts
+var SEQUENCE_DRAG_ACTION_ID = "diagram.sequence.drag";
+var GRAB_SEQUENCE_ACTION_ID = "diagram.sequence.grab";
+function carries(s, part) {
+  if (s.part === "head") {
+    if (part.target !== void 0) return "participant" in part.target && part.target.participant === s.id;
+    return part.id === s.id && ["head", "lifeline", "destroy", "activation"].includes(part.part);
+  }
+  if (s.part === "step") {
+    return part.id === s.id || part.target !== void 0 && ("step" in part.target && part.target.step === s.id || "fragment" in part.target && part.target.fragment === s.id);
+  }
+  return s.part === "end" && part.part === "message" && part.id === s.id;
+}
+function pressOf2(ctx) {
+  const scratch = sequenceScratchOf(ctx.drag?.affordance);
+  const scene = ctx.deps.scene;
+  const node = scratch === null ? void 0 : scene?.get(scratch.root);
+  const held = node === void 0 ? null : sequenceRootOf(node);
+  const root = scene === void 0 || held === null ? void 0 : placedSequences(scene).find((p) => p.id === scratch.root);
+  if (scratch === null || scene === void 0 || held === null || root === void 0) return null;
+  const carried = /* @__PURE__ */ new Map();
+  for (const id of scene.childrenOf(scratch.root)) {
+    const child = scene.get(id);
+    const part = sequencePartOf(child);
+    if (part !== null && carries(scratch, part)) carried.set(id, child.pose);
+  }
+  return { scratch, scene, root, data: held.sequence, start: ctx.drag?.start ?? { x: ctx.world.x, y: ctx.world.y }, carried };
+}
+var nearest = (xs, x) => xs.reduce((best, v, i) => Math.abs(v - x) < Math.abs(xs[best] - x) ? i : best, 0);
+function proposed(p, at) {
+  const { geometry, origin } = p.root;
+  const local = { x: at.x - origin.x, y: at.y - origin.y };
+  const { scratch } = p;
+  if (scratch.part === "box" || scratch.part === "mark") return { data: p.data, label: "" };
+  if (scratch.part === "head") {
+    const index = geometry.columns.filter((c) => c.x < local.x).length;
+    return { data: moveParticipant(p.data, scratch.id, index), label: "Move participant" };
+  }
+  if (scratch.part === "end") {
+    const column = geometry.columns[nearest(geometry.columns.map((c) => c.x), local.x)];
+    if (column === void 0) return { data: p.data, label: "" };
+    return { data: reconnectMessage(p.data, scratch.id, scratch.end, column.id), label: "Reconnect message" };
+  }
+  const slot = geometry.slots[nearest(geometry.slots.map((s) => s.y), local.y)];
+  if (slot === void 0) return { data: p.data, label: "" };
+  return { data: moveStep(p.data, scratch.id, slot.place), label: "Move step" };
+}
+function previewOf(p, id, pose, at) {
+  const dx = at.x - p.start.x;
+  const dy = at.y - p.start.y;
+  if (p.scratch.part === "head") return { ...pose, x: pose.x + dx };
+  if (p.scratch.part === "step") return { ...pose, y: pose.y + dy };
+  const m = p.root.geometry.messages.find((q) => q.id === p.scratch.id);
+  if (m === void 0 || id !== `${p.scratch.root}/msg:${p.scratch.id}` || m.loopY !== void 0) return pose;
+  const shift = pose.x - Math.min(m.x1, m.x2);
+  const still = (p.scratch.end === "from" ? m.x2 : m.x1) + shift;
+  const moving = (p.scratch.end === "from" ? m.x1 : m.x2) + shift + dx;
+  return { ...pose, x: Math.min(still, moving), width: Math.abs(moving - still) };
+}
+function createSequenceDragAction(opts = {}) {
+  const commit = sequenceCommitOf(opts);
+  return {
+    id: opts.id ?? SEQUENCE_DRAG_ACTION_ID,
+    label: "Move sequence part",
+    group: "diagram",
+    requires: ["scene"],
+    eligible: { mode: "normal" },
+    invoker: {
+      timing: "ongoing",
+      start(ctx) {
+        const p = pressOf2(ctx);
+        if (p === null) return {};
+        let at = null;
+        let open = true;
+        return {
+          kind: "diagram-sequence-drag",
+          onMove(move) {
+            at = { x: move.world.x, y: move.world.y };
+          },
+          previewIds: () => open && at !== null ? [...p.carried.keys()] : null,
+          previewPose: (id) => {
+            const pose = p.carried.get(id);
+            return open && at !== null && pose !== void 0 ? previewOf(p, id, pose, at) : null;
+          },
+          onEnd(end, reason) {
+            open = false;
+            if (reason !== "commit" || at === null) return;
+            const next = proposed(p, { x: end.world.x, y: end.world.y });
+            if (next.data !== p.data) commit({ id: p.scratch.root, data: next.data, label: next.label }, { ...end, deps: { ...end.deps, scene: p.scene } });
+          }
+        };
+      }
+    },
+    enabled: () => true
+  };
+}
+var grab = {
+  id: GRAB_SEQUENCE_ACTION_ID,
+  label: "Grab sequence part",
+  group: "diagram",
+  invoker: { timing: "immediate", run: () => {
+  } },
+  enabled: () => true
+};
+function diagramSequence(opts) {
+  const actionId = opts.id ?? SEQUENCE_DRAG_ACTION_ID;
+  const target = `affordance:${SEQUENCE_AFFORDANCE_KIND}`;
+  return {
+    layer: sequenceLayer(opts.scene),
+    contribution: {
+      id: "weasel-diagram-sequence",
+      eligibility: { claimed: true },
+      actions: [createSequenceDragAction({ ...opts, id: actionId }), grab, selectSequencePartAction],
+      bindings: [
+        { spec: { kind: "drag", target }, actionId, opts: { id: "weasel-diagram-sequence.drag" } },
+        { spec: { kind: "pointerDown", target }, actionId: GRAB_SEQUENCE_ACTION_ID, opts: { id: "weasel-diagram-sequence.pointerDown" } },
+        { spec: { kind: "click", target, mods: { shift: "optional" } }, actionId: SELECT_SEQUENCE_PART_ACTION_ID, opts: { id: "weasel-diagram-sequence.click" } }
+      ]
+    }
+  };
+}
 function agrees(selection, want) {
   if (typeof want === "string" || want === null) return (selection.at(-1) ?? null) === want;
   return selection.length === want.length && want.every((id) => selection.includes(id));
@@ -3407,11 +4617,11 @@ function diagramLayoutOf(specs) {
     const id = s.id;
     if (id === void 0) continue;
     if (isBodyOrRegion(s)) {
-      const region = diagramContainerOf(s);
+      const region2 = diagramContainerOf(s);
       const pinned = isPinned({ id, kind: s.kind, data: s.data });
       const { x, y, width, height } = world.get(id);
-      if (region !== null) {
-        if (!pinned && region.role !== "lane" && region.fitted !== true) {
+      if (region2 !== null) {
+        if (!pinned && region2.role !== "lane" && region2.fitted !== true) {
           containers.push({ kind: "box", id, box: { x, y, width, height } });
         }
       } else if (!pinned) moves.push({ id, x, y });
@@ -3439,8 +4649,8 @@ function changes(was, now) {
   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 });
+    const moved2 = before.waypoints !== after.waypoints && !samePoints(before.waypoints, after.waypoints);
+    if (moved2 || !samePorts(before.ports, after.ports)) routes.push({ id, ...after });
   }
   return { moves, routes, containers: regionChanges(was.regions, now.regions) };
 }
@@ -3449,11 +4659,11 @@ function useSceneSync(scene, specs, reports) {
   const syncing = useRef(false);
   const applied = useRef(specs);
   useEffect(() => {
-    let known = readScene(scene);
+    let known2 = readScene(scene);
     return scene.subscribe(() => {
       const now = readScene(scene);
-      const found = syncing.current ? null : changes(known, now);
-      known = now;
+      const found = syncing.current ? null : changes(known2, now);
+      known2 = 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);
@@ -3470,6 +4680,15 @@ function useSceneSync(scene, specs, reports) {
     applied.current = specs;
   }, [scene, specs]);
 }
+var isSequenceText = (data) => isTextData(data) && sequencePartOf({ data })?.target !== void 0;
+function useSequenceTextEdit(scene, report) {
+  const latest = useLatest(report);
+  const on = report !== void 0;
+  return useMemo(() => on ? {
+    isText: isSequenceText,
+    onEnd: (id) => foldSequenceText(scene, id, (edit) => latest.current?.(edit))
+  } : void 0, [on, scene, latest]);
+}
 
 // src/regionEditing.ts
 function laneResizeReports(scene, resize) {
@@ -3488,9 +4707,9 @@ function laneResizeReports(scene, resize) {
       const { x, y, width, height } = after(id);
       const was = before(id);
       if (x === was.x && y === was.y) continue;
-      const region = diagramContainerOf(node);
-      if (region !== null) {
-        if (region.role === "container" && region.fitted !== true) boxes.push({ kind: "box", id, box: { x, y, width, height } });
+      const region2 = diagramContainerOf(node);
+      if (region2 !== null) {
+        if (region2.role === "container" && region2.fitted !== true) boxes.push({ kind: "box", id, box: { x, y, width, height } });
       } else if (isDiagramBody(node)) moves.push({ id, x, y });
     }
   }
@@ -3565,7 +4784,16 @@ function reportDeleteAction(report) {
     }
   });
 }
-function reportResizeAction(report, region) {
+function sequenceDeleteAction(scene, edit, report) {
+  return createSequenceDeleteAction({
+    commit: edit,
+    others: (ids) => {
+      const removed = removedData(scene, ids);
+      if (report !== null && (removed.nodes.length > 0 || removed.edges.length > 0)) report(removed);
+    }
+  });
+}
+function reportResizeAction(report, region2) {
   return createResizeAction({
     commit: (poses, deps) => {
       const picked = new Set(deps.selection?.get() ?? []);
@@ -3574,7 +4802,7 @@ function reportResizeAction(report, region) {
         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 } });
+        if (node !== void 0 && diagramContainerOf(node) !== null) region2?.({ kind: "box", id, box: { x, y, width, height } });
         else resizes.push({ id, x, y, width, height });
       }
       if (resizes.length > 0) report?.(resizes);
@@ -3601,6 +4829,7 @@ function useDiagramEditing(props) {
   const reorders = props.onReorder !== void 0;
   const resizes = props.onResize !== void 0;
   const regionEdits = props.onEditContainer !== void 0;
+  const sequences = props.onEditSequence !== void 0;
   const ports = useMemo(() => mode === "connect" ? diagramPorts({
     ...portOptions,
     participants: source,
@@ -3648,24 +4877,28 @@ function useDiagramEditing(props) {
     [reorders, report]
   );
   const regions = useMemo(() => regionEdits ? regionEditing(scene, selected, report) : null, [regionEdits, scene, selected, report]);
+  const sequence = useMemo(
+    () => sequences ? diagramSequence({ scene, commit: (edit) => report.current.onEditSequence?.(edit) }) : null,
+    [sequences, scene, report]
+  );
   const actions = useMemo(() => ({
     ...NO_MARQUEE,
-    ...deletes ? { delete: reportDeleteAction((r) => report.current.onDelete?.(r)) } : {},
+    ...sequences ? { delete: sequenceDeleteAction(scene, (edit) => report.current.onEditSequence?.(edit), deletes ? (r) => report.current.onDelete?.(r) : null) } : 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]);
+  }), [deletes, sequences, scene, 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]
+    // Edge ends after ports and routes: 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, sequence?.layer].filter((l) => l != null),
+    [regions, labelDrag, portsLayer, route, ends, sequence]
   );
   const extra = props.ambient;
   const ambient = useMemo(() => [
     ...AMBIENT,
-    ...[ports?.contribution, route?.contribution, ends?.contribution, labelDrag?.contribution, label, reorder].filter((c) => c != null),
+    ...[ports?.contribution, route?.contribution, ends?.contribution, labelDrag?.contribution, label, reorder, sequence?.contribution].filter((c) => c != null),
     ...regions?.contributions ?? [],
     ...extra ?? []
-  ], [ports, route, ends, labelDrag, label, reorder, regions, extra]);
+  ], [ports, route, ends, labelDrag, label, reorder, sequence, regions, extra]);
   return { layers, ambient, actions };
 }
 function usePagesView(pages) {
@@ -3801,6 +5034,7 @@ function Inner({
   onDelete,
   onEditLabel,
   onMoveLabel,
+  onEditSequence,
   onReorder,
   onEditContainer,
   connectBodies,
@@ -3810,6 +5044,8 @@ function Inner({
   pickEdges,
   overlays = NO_OVERLAYS,
   ambient: extraAmbient,
+  tools,
+  onToolsCreated,
   enableKeybindings,
   canConnect,
   portOptions,
@@ -3873,16 +5109,16 @@ function Inner({
     ...refit ? { refit } : {}
   });
   const { defaultView } = fitting;
-  const settled = useLatest((moved) => {
-    liveOpts?.onSettle?.(moved);
-    if (moved !== 0) fitting.settle();
+  const settled = useLatest((moved2) => {
+    liveOpts?.onSettle?.(moved2);
+    if (moved2 !== 0) fitting.settle();
   });
   const live = useLiveLayout({
     ...liveOpts,
     scene,
     source,
     algorithm: run?.algorithm ?? "force",
-    onSettle: (moved) => settled.current(moved)
+    onSettle: (moved2) => settled.current(moved2)
   });
   useEffect(() => {
     if (run !== null) live.restart();
@@ -3904,6 +5140,7 @@ function Inner({
     onResize,
     onEditContainer,
     onMove,
+    onEditSequence,
     connectBodies,
     canConnect,
     portOptions,
@@ -3911,16 +5148,19 @@ function Inner({
   });
   const itemDrop = useItemDrop(source, { onDropItem, canDropItem });
   const ambient = useMemo(() => itemDrop === null ? editing.ambient : [...editing.ambient, itemDrop], [editing.ambient, itemDrop]);
-  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]);
+  useRegisteredLayers(canvasRef, 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 sequences = onEditSequence !== void 0;
+  const edits = moves || onConnect !== void 0 || onReorder !== void 0 || resizes || edgesPick || sequences;
+  const features = useMemo(() => [
+    "view",
+    "pick",
+    ...moves ? ["move"] : [],
+    ...resizes ? ["resize"] : [],
+    ...sequences ? ["edit"] : []
+  ], [moves, resizes, sequences]);
+  const textEditor = useSequenceTextEdit(scene, onEditSequence);
   const selectTool = useMemo(() => ({ resize: { resizable: diagramResizable(scene) } }), [scene]);
   const overlayRef = useOverlayPlacement(canvasRef, scene, overlays);
   const fillsOn = [width === void 0 ? "fill-x" : "", height === void 0 ? "fill-y" : ""].join(" ").trim();
@@ -3933,9 +5173,12 @@ function Inner({
         selection,
         features,
         ...resizes ? { selectTool } : {},
+        ...textEditor ? { textEditor } : {},
         enableKeybindings: enableKeybindings ?? edits,
         ambient,
         actions: editing.actions,
+        ...tools ? { tools } : {},
+        ...onToolsCreated ? { onToolsCreated } : {},
         onClick,
         ...onHover ? { onHover } : {},
         width,
@@ -3957,6 +5200,14 @@ function Inner({
   ] });
 }
 var NO_OVERLAYS = [];
+function useRegisteredLayers(canvasRef, layers) {
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (canvas === null) return;
+    const disposers = layers.map((layer) => canvas.registerLayer(layer));
+    return () => disposers.forEach((dispose) => dispose());
+  }, [canvasRef, layers]);
+}
 function DropRules({ scene, canReparent }) {
   const latest = useLatest(canReparent);
   const asks = canReparent !== void 0;
@@ -3997,6 +5248,6 @@ function useDiagramApi(apiRef, canvasRef, scene, live, setRun, fitNow) {
   }), [canvasRef, live, scene, setRun, fitNow]);
 }
 
-export { ADD_LANE_ACTION_ID, ANYWHERE, CONNECT_ACTION_ID, CONTAINERS_GROUP, CONTAINER_STENCILS, DEFAULT_EDGE_STROKE, DIAGRAM_ITEM_CARRY, 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, ITEM_DROP_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, createItemDropAction, 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, dragItemProps, dragSegment, dragVertex, easedProducer, edgeEndLayer, edgeEndScratchOf, edgePolylines, editContainerTitleAction, editContainerTitleBinding, forceProducer, grabPortAction, grabPortBindings, groupReorderContribution, groupReorderSlots, headerIdOf, hopDataOps, inOrUnder, insertWaypoint, isBodyEnd, isBodyOrRegion, isDiagramBody, itemDropContribution, laneLayer, laneResizeFrame, laneScratchOf, lanesOf, layoutDiagram, 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, startItemDrag, themeWrites, unpinSegment, useLiveLayout, useMirroredSelection, waypointLayer, waypointScratchOf, withHopsData, withRouter, worldWith };
-//# sourceMappingURL=chunk-GR2DK4S2.js.map
-//# sourceMappingURL=chunk-GR2DK4S2.js.map
+export { ADD_LANE_ACTION_ID, ANYWHERE, CONNECT_ACTION_ID, CONTAINERS_GROUP, CONTAINER_STENCILS, DEFAULT_EDGE_STROKE, DIAGRAM_ITEM_CARRY, 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_SEQUENCE_ACTION_ID, GRAB_WAYPOINT_ACTION_ID, ITEM_DROP_ACTION_ID, LANE_AFFORDANCE_KIND, LANE_LAYER_ID, LANE_RESIZE_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, SELECT_SEQUENCE_PART_ACTION_ID, SEQ, SEQUENCE_AFFORDANCE_KIND, SEQUENCE_DRAG_ACTION_ID, SEQUENCE_LAYER_ID, SEQUENCE_ROLES, SEQ_ARROWS, SEQ_MULTI_SECTION, SET_HOPS_ACTION_ID, SET_ROUTER_ACTION_IDS, STEP_REORDER_ACTION_ID, WAYPOINT_AFFORDANCE_KIND, WAYPOINT_HIT_PX, WAYPOINT_LAYER_ID, addBox, addLane, addParticipant, addSection, avoidSceneInput, bodyAt, commitEdgeToScene, commitLabelToScene, commitLaneResizeToScene, commitReconnectToScene, commitRouteToScene, commitRouterToScene, commitSequence, connectBinding, containerBuild, createAddLaneAction, createConnectAction, createDiagramContribution, createEdgeEndAffordance, createItemDropAction, createLabelDragAction, createLaneAffordance, createLaneResizeAction, createPortAffordance, createReconnectAction, createReleaseMembersAction, createRemoveWaypointAction, createReorderAction, createResetLabelAction, createResetRouteAction, createRouteEditAction, createSequenceDeleteAction, createSequenceDragAction, createSetHopsAction, createSetRouterAction, createSpecHops, createSpecLabelPlacer, createSpecRouter, createStepReorderAction, createWaypointAffordance, defaultCanConnect, diagramCanDropInto, diagramContainers, diagramDropParentAt, diagramEdgeEnds, diagramLabelDrag, diagramLayoutOf, diagramPorts, diagramResizable, diagramSequence, diagramShape, diagramWaypoints, dragItemProps, dragSegment, dragVertex, easedProducer, edgeEndLayer, edgeEndScratchOf, edgePolylines, editContainerTitleAction, editContainerTitleBinding, findStep, foldSequenceText, forceProducer, freshSeqId, grabPortAction, grabPortBindings, groupReorderContribution, groupReorderSlots, headerIdOf, hopDataOps, inOrUnder, insertMark, insertMessage, insertNote, insertStep, insertWaypoint, isBodyEnd, isBodyOrRegion, isDiagramBody, isSequenceText, itemDropContribution, laneLayer, laneResizeFrame, laneScratchOf, lanesOf, moveParticipant, moveStep, movedLabelData, newParticipant, pinSegment, placeOf, placedSequences, poolAxisOf, poolsOf, portLayer, portScratchOf, reconnectBinding, reconnectMessage, redrawSequences, regionHeaderAt, registerDiagramShape, releaseMembers, removeBox, removeMarks, removeMarksOf, removeParticipant, removeSection, removeSegment, removeStep, removeStepAt, removeWaypoint, reorderBinding, reorderContribution, routeHandles, routeStateOf, routedData, routerActions, sceneEdges, sceneParticipants, segmentAxis, selectSequencePartAction, seqIdTaken, sequenceCommitOf, sequenceDeletes, sequenceLayout, sequencePartNodeOf, sequencePartOf, sequenceRootOf, sequenceScratchOf, sequenceSlots, sequenceSpecs, sequenceTextOf, setAutonumber, setFragmentType, setMessageActivation, setMessageArrow, setParticipantOutline, setSequenceText, startItemDrag, startSequence, stepListOf, themeWrites, unpinSegment, unwrapFragment, useLiveLayout, useMirroredSelection, useSequenceTextEdit, waypointLayer, waypointScratchOf, withHopsData, withRouter, worldWith, wrapSteps };
+//# sourceMappingURL=chunk-EIHPPOAM.js.map
+//# sourceMappingURL=chunk-EIHPPOAM.js.map