@weasel-js/diagram 1.9.4 → 1.10.1

package/dist/layout.d.ts

@@ -1,3 +1,4 @@
-export { j as BodyFloor, k as BodyNodeSpec, B as BodySpec, l as Bounds, m as BuildBodyOptions, C as COMPASS, p as DEFAULT_NODE_GAP, q as DEFAULT_PORTS, r as DEFAULT_RANK_GAP, f as DiagramNode, u as ForceBody, F as ForceOptions, v as ForceRelaxation, i as Graph, w as GraphEdge, y as GraphNode, E as LayoutAxes, H as LayoutDirection, L as LayoutFn, g as LayoutOptions, h as LayoutResult, M as MeasureRowText, O as Outline, P as Port, c as PortAnchor, e as PortSpec, a as PortsOptions, R as Row, I as RowBox, J as RowNodeData, K as RowPort, N as RowPortBox, Q as RowTextStyle, S as Slot, T as axesFor, U as backEdges, V as bodyOutline, X as boxForContent, Y as buildBody, _ as canvasMeasure, $ as contentBox, av as extent, a4 as force, a5 as forceRelaxation, a6 as forestOf, a7 as graphOrder, aa as layered, ab as layoutBody, ac as layoutRowPorts, ad as measureBody, ae as outlinePath, af as outlinePolyline, ag as packAcross, ai as pinnedSet, aj as portOf, ak as portsOf, al as portsOnOutline, an as ranksOf, ao as rayHit, ap as seededOrder, aq as settle, ar as sizeToBody, as as translated, at as tree, au as untilSettled } from './layout.entry-DyKFfHG5.js';
+export { k as BodyFloor, l as BodyNodeSpec, B as BodySpec, m as Bounds, n as BuildBodyOptions, C as COMPASS, q as DEFAULT_NODE_GAP, r as DEFAULT_PORTS, s as DEFAULT_RANK_GAP, f as DiagramNode, v as ForceBody, F as ForceOptions, w as ForceRelaxation, i as Graph, y as GraphEdge, A as GraphNode, I as LayoutAxes, j as LayoutDirection, L as LayoutFn, g as LayoutOptions, h as LayoutResult, M as MeasureRowText, O as Outline, P as Port, c as PortAnchor, e as PortSpec, a as PortsOptions, R as Row, J as RowBox, K as RowNodeData, N as RowPort, Q as RowPortBox, S as RowTextStyle, T as Slot, U as axesFor, V as backEdges, W as bodyOutline, Y as boxForContent, Z as buildBody, $ as canvasMeasure, a0 as contentBox, aw as extent, a5 as force, a6 as forceRelaxation, a7 as forestOf, a8 as graphOrder, ab as layered, ac as layoutBody, ad as layoutRowPorts, ae as measureBody, af as outlinePath, ag as outlinePolyline, ah as packAcross, aj as pinnedSet, ak as portOf, al as portsOf, am as portsOnOutline, ao as ranksOf, ap as rayHit, aq as seededOrder, ar as settle, as as sizeToBody, at as translated, au as tree, av as untilSettled } from './layout.entry-BUkiRKuX.js';
 import '@weasel-js/geom';
 import '@weasel-js/core/math';
+import '@weasel-js/simulation';

package/dist/{layout.entry-DyKFfHG5.d.ts → layout.entry-BUkiRKuX.d.ts}

@@ -1,5 +1,6 @@
 import * as _weasel_js_geom from '@weasel-js/geom';
-import { Path, PoseDescriptor, Vec2, SimulationNode, createSimulation } from '@weasel-js/core/math';
+import { Path, PoseDescriptor, Vec2 } from '@weasel-js/core/math';
+import { SimulationNode, createSimulation } from '@weasel-js/simulation';
 
 /**
  * The shapes a built body can wear, as paths in the node's bounds.
@@ -56,18 +57,15 @@ declare function boxForContent(outline: Outline, content: {
 /**
  * Reading the `DiagramNode` trait off a scene node.
  *
- * Two ways to attach it, both of which this module's default reader answers:
+ * Two ways to attach it:
  *
- *   - **On the node.** `data.diagram` holds the trait. One node, one answer;
- *     what a connect gesture writes when the author drags a new edge.
+ *   - **On the node.** `data.diagram` holds the trait.
  *   - **By kind.** A consumer declares once which data shapes take part, and
- *     every matching node gets the trait without being stamped. This mirrors
- *     `createNodeRouting` in the kit — a predicate over `data`, first match
- *     wins — and is the shape to reach for when the participants are a class
- *     of node rather than a hand-picked set.
+ *     every matching node gets the trait without being stamped — a predicate
+ *     over `data`, first match wins.
  *
  * A reader is a plain function, so a consumer whose data lives somewhere else
- * entirely passes their own and never touches either form.
+ * passes their own.
  */
 
 /** The key on a node's `data` the default reader looks under. */
@@ -98,17 +96,13 @@ interface DiagramNodeEntry {
  *  An edge's trait lives under the same key, so `from` and `to` are what tells
  *  the two apart. Without that test an edge reads as a participant declaring
  *  no ports, and collects the four defaults on the degenerate pose an edge
- *  carries — four grabbable ports in the middle of nowhere. An edge label's
- *  `label` trait and an anchored node's `anchor` are the same story, and would
- *  also take a slot in every layout. */
+ *  carries. An edge label's `label` trait and an anchored node's `anchor` are
+ *  excluded the same way. */
 declare const dataKeyReader: DiagramNodeReader;
 /**
  * A reader over declared kinds. A trait on the node's own data still wins, so
- * a single node can opt out of, or override, whatever its kind says.
- *
- * Throws on a duplicate `name`, for the reason `mergeContributions` does: a
- * class of node silently losing its ports is what this registry exists to make
- * loud.
+ * a single node can opt out of, or override, whatever its kind says. Throws on
+ * a duplicate `name`.
  */
 declare function createDiagramNodes(entries: readonly DiagramNodeEntry[]): DiagramNodeReader;
 /** The trait `node` carries, through `read` (default: its own `data.diagram`). */
@@ -119,15 +113,10 @@ declare function isPinned(node: DiagramNodeLike, read?: DiagramNodeReader): bool
 /**
  * `Graph` — the adjacency index a layout runs over.
  *
- * The scene is the document, so there is no second graph kept in sync with it:
- * this one is built from the scene on demand, used, and thrown away. Rebuilding
- * per layout invocation is deliberate — a maintained index is a cache to
- * invalidate on every add, delete, reparent and `dependsOn` edit, and layout is
- * not on the hot path. Measure before changing that.
- *
- * A node's *identity* is its id and its *size* is its bounds; where it currently
- * sits is here too, because a re-layout that ignores where things already are
- * scrambles a diagram the author has arranged.
+ * Built from the scene on demand, used, and thrown away. Rebuilding per layout
+ * invocation is deliberate — a maintained index is a cache to invalidate on
+ * every add, delete, reparent, and `dependsOn` edit, and layout is not on the
+ * hot path.
  */
 
 /** A scene node as the graph reads it. `dependsOn` is what an edge's two
@@ -161,6 +150,9 @@ interface GraphGroup {
     members: readonly string[];
     /** Room the box keeps around what it holds, in world units. */
     inset: GroupInset;
+    /** The narrowest its box may be across the world x axis, which a layout
+     *  leaves room for. */
+    minWidth?: number;
     /** The group this one is directly inside. */
     parent?: string;
 }
@@ -175,8 +167,7 @@ interface GraphEdge {
  * Nodes, edges, and the two adjacency reads a layout needs.
  *
  * Every list is in source order — render order, when the source is a scene —
- * which is what a layout's tiebreaks resolve against. There is no RNG anywhere
- * downstream of this, and this is where that starts.
+ * which is what a layout's tiebreaks resolve against.
  */
 interface Graph {
     readonly nodes: readonly GraphNode[];
@@ -202,9 +193,8 @@ interface BuildGraphOptions<TPose> {
  * dependencies; a group if its trait carries `group`, with its dependencies as
  * its members, which may be groups themselves (see `nestGroups`); a participant if the reader hands back any other
  * `DiagramNode`; and otherwise not in the diagram at all. An edge whose
- * endpoints are not both participants or groups is dropped — a dangling edge
- * should not be ranking anything — and an edge to a group ranks against its
- * members (see `expandGroupEdges`).
+ * endpoints are not both participants or groups is dropped, and an edge to a
+ * group ranks against its members (see `expandGroupEdges`).
  */
 declare function buildGraph<TPose>(source: GraphSource<TPose>, opts?: BuildGraphOptions<TPose>): Graph;
 
@@ -213,24 +203,19 @@ declare function buildGraph<TPose>(source: GraphSource<TPose>, opts?: BuildGraph
  *
  * A layout is a pure function of the graph — no scene, no ops, no history. It
  * hands back the new top-left for every node that **moves**, and a node already
- * standing where the layout wants it is simply absent from the answer. That is
- * what makes re-running a layout free rather than destructive, and it is the
- * property the idempotence test asserts.
+ * standing where the layout wants it is absent from the answer.
  *
- * Three rules keep re-layout non-destructive, and all three live here rather
- * than in each algorithm:
+ * Three rules keep re-layout non-destructive:
  *
  *   - **No RNG anywhere.** Every tiebreak falls back to the graph's own node
- *     order, which is the source's order — render order, for a scene.
+ *     order.
  *   - **Within-rank order is seeded from where the nodes already are**, read
- *     off the cross axis, rather than from crossing-minimization. An author who
- *     dragged two boxes into an order gets that order back.
+ *     off the cross axis, rather than from crossing-minimization.
  *   - **A pin set nothing moves.** Pinned nodes are never in the result, and
  *     the rest of the layout is translated to sit around them.
  *
- * `layered` and `tree` are idempotent by construction: the second run reads the
- * order the first run produced and computes the same slots. `force` is an
- * iterative relaxation and makes no such claim — re-running it keeps relaxing.
+ * `layered` and `tree` are idempotent; `force` is an iterative relaxation and
+ * re-running it keeps relaxing.
  */
 
 /** Which way the ranks stack. `force` ignores it. */
@@ -287,18 +272,13 @@ interface Slot {
     rank: number;
 }
 /**
- * Turn canonical slots into the positions to write.
- *
- * Three steps, in order: map the canonical frame onto the world axes the
- * direction names; translate the whole layout so it lands where the graph
- * already is; drop everything that is pinned or that would not move.
+ * Turn canonical slots into the positions to write: map the canonical frame
+ * onto the world axes, translate the whole layout so it lands where the graph
+ * already is, and drop everything that is pinned or that would not move.
  *
- * The translation is what makes the layout non-destructive, and it is chosen so
- * that a second run lands on the same answer. With a pin, it is whatever keeps
- * the first pinned node exactly where it is. Without one, it is whatever puts
- * the layout's own bounding box where the graph's bounding box already starts —
- * which the first run then makes true, so the second run computes the same
- * translation and writes nothing.
+ * With a pin, the translation keeps the first pinned node exactly where it is.
+ * Without one, it puts the layout's bounding box where the graph's already
+ * starts, so a second run computes the same translation and writes nothing.
  */
 declare function settle(graph: Graph, slots: ReadonlyMap<string, Slot>, opts?: LayoutOptions): LayoutResult;
 /**
@@ -306,24 +286,18 @@ declare function settle(graph: Graph, slots: ReadonlyMap<string, Slot>, opts?: L
  * each node.
  *
  * A layout that keeps groups together can move an outsider out of a group's
- * column, which changes the order the next run would start from. Its answer
- * has to be the arrangement a re-run keeps, so it re-runs here rather than
- * leaving the second pass to the caller. `passes` bounds an arrangement that
- * never comes to rest.
+ * column, which changes the order the next run would start from. `passes`
+ * bounds an arrangement that never comes to rest.
  */
 declare function untilSettled(once: LayoutFn, graph: Graph, opts?: LayoutOptions, passes?: number): LayoutResult;
 /**
  * {@link settle}'s second half, for a layout that already works in world
- * coordinates — `force` does, since the integrator moves points around rather
- * than filling slots.
+ * coordinates.
  */
 declare function translated(graph: Graph, placed: ReadonlyMap<string, Vec2>, pinned: ReadonlySet<string>, tolerance?: number): LayoutResult;
 /**
  * Lay a list of nodes out along the cross axis, in the order given, and hand
  * back each one's low corner plus the total span.
- *
- * Shared by `layered`'s ranks and `tree`'s sibling rows, which pack a row the
- * same way and differ only in what decides the order.
  */
 declare function packAcross(nodes: readonly GraphNode[], axis: 'x' | 'y', gap: number): {
     at: Map<string, number>;
@@ -345,7 +319,7 @@ declare function graphOrder(graph: Graph): (id: string) => number;
  * to its last — including a rank in between that holds none of its members, or
  * an outsider would land inside the box there. Groups keep one cross position
  * across every rank, so two groups' columns never cross and their boxes never
- * overlap. Ungrouped nodes pack around the columns rank by rank, as before.
+ * overlap. Ungrouped nodes pack around the columns rank by rank.
  *
  * A group may be a member of another: its column then sits inside its parent's.
  */
@@ -440,6 +414,9 @@ interface DiagramGroup {
     /** Room the box keeps around its members, in world units: one number for
      *  every side, or per side. Default 12 on each. */
     inset?: number | Partial<GroupInset>;
+    /** The narrowest the box may be, in world units, as room for its label.
+     *  A box its members leave narrower grows evenly on both sides. */
+    minWidth?: number;
 }
 /** A port resolved against a node's current pose: where it is in world
  *  coordinates, and which way an edge leaves it. */
@@ -468,9 +445,7 @@ type Row =
     value: string;
     style?: RowTextStyle;
 }
-/** A row that carries ports on its own left and right edges — the
- *  visual-programming shape, where an operator's inputs line up with the
- *  rows they feed. */
+/** A row that carries ports on its own left and right edges. */
  | {
     kind: 'ports';
     left?: readonly RowPort[];
@@ -566,8 +541,7 @@ declare function canvasMeasure(ctx: {
 declare function measureBody(spec: BodySpec, measure?: MeasureRowText): BodyFloor;
 /**
  * The authored size, grown to fit the body. Never shrinks: a row removed
- * leaves the node the size the author last saw it at, which is the only
- * behavior that survives a resize the author did on purpose.
+ * leaves the node the size the author last saw it at.
  */
 declare function sizeToBody<TPose extends Bounds>(pose: TPose, floor: BodyFloor): TPose;
 /** Where each row sits inside `bounds`, top to bottom. Rows keep their
@@ -575,8 +549,7 @@ declare function sizeToBody<TPose extends Bounds>(pose: TPose, floor: BodyFloor)
  *  places the block of them within it. */
 declare function layoutBody(spec: BodySpec, bounds: Bounds, measure?: MeasureRowText): RowBox[];
 /**
- * Where each of a `ports` row's ports goes inside `box`, on the same terms
- * `layoutBody` gives one box per row.
+ * Where each of a `ports` row's ports goes inside `box`.
  *
  * Both sides are cut into the same number of slots — the longer side's count —
  * so the nth input faces the nth output whichever side has more. A label box
@@ -592,13 +565,12 @@ declare function layoutRowPorts(row: Extract<Row, {
  * left or right edge.
  *
  * Anchors are normalized against `bounds`, so they survive the node being
- * resized — which is the whole reason `PortAnchor` is normalized.
+ * resized.
  *
  * **A row port on a side takes that side's compass default with it.** Both sit
  * on the same edge, and a row near the vertical middle puts one exactly on top
  * of `w` or `e` — where the later region wins the hit and the other is
- * grabbable nowhere. A body that declares where its inputs attach has said what
- * that side is for.
+ * grabbable nowhere.
  */
 declare function bodyTrait(spec: BodySpec, bounds: Bounds, measure?: MeasureRowText): DiagramNode;
 /** The outline path for a built body at `bounds` — what paints it, and what a
@@ -626,8 +598,7 @@ interface BuildBodyOptions<TData, TLayer extends string, TPose extends Bounds> {
     /** One row's data, or `null` to leave that row undrawn. */
     row: RowNodeData<TData>;
     /** One row port's label, or `null` to leave it undrawn. Ports with no
-     *  `label` are never offered. Omit to draw none — a body whose ports are
-     *  named only for the width they claim needs nothing here. */
+     *  `label` are never offered. Omit to draw none. */
     portLabel?: (text: string, box: RowPortBox) => TData | null;
 }
 /**
@@ -635,13 +606,9 @@ interface BuildBodyOptions<TData, TLayer extends string, TPose extends Bounds> {
  * leaf per row that wants drawing.
  *
  * Rows are ordinary scene nodes rather than something this package paints, so
- * the kit's own text painter draws them and text editing, styling and
- * selection work on them unchanged. The walk that places them is
- * `layoutBody` — the same one `bodyTrait` anchors its row ports against, which
- * is why a label and its ports cannot drift apart.
- *
- * The pose is `sizeToBody(at, measureBody(spec))`: the body measures a floor
- * and the authored size is grown to clear it, never shrunk.
+ * the kit's own text painter draws them and text editing, styling, and
+ * selection work on them unchanged. The returned pose is `at` grown to fit the
+ * body, never shrunk.
  */
 declare function buildBody<TData, TLayer extends string, TPose extends Bounds>(spec: BodySpec, at: TPose, opts: BuildBodyOptions<TData, TLayer, TPose>): {
     pose: TPose;
@@ -724,15 +691,10 @@ declare function portOf<TPose>(node: DiagramNodeLike, pose: TPose, portId: strin
  * Seeded from where the nodes already are rather than from a fresh random
  * scatter: an author who has arranged half a diagram gets that arrangement
  * relaxed, not replaced. There is no RNG in it at all — two coincident nodes
- * are separated along a golden-angle spiral keyed to their index, which is what
- * a random jiggle is for elsewhere.
+ * are separated along a golden-angle spiral keyed to their index.
  *
- * The integrator is the kit's own `createSimulation`, the same one
- * `useSimulation` runs a frame at a time. Only the forces are local, and they
- * are the naive O(n²) kind — right for the tens-to-hundreds of nodes an
- * edge-per-scene-node diagram is already sized for, wrong for a 10k-node graph,
- * which wants d3-force's Barnes–Hut through `useSimulation` and its own render
- * layer.
+ * The forces are the naive O(n²) kind — right for tens to hundreds of nodes,
+ * wrong for a 10k-node graph.
  *
  * **This is the one layout that is not idempotent.** A relaxation re-run from
  * its own output keeps relaxing; `direction` means nothing to it. Pins and the
@@ -769,10 +731,6 @@ interface ForceBody extends SimulationNode {
 }
 /**
  * The bodies and the force list, wound up and ready to tick.
- *
- * Shared by the one-shot `force` below and the live relaxation in `live.ts`,
- * which ticks it a frame at a time. Two copies of a force list drift, and the
- * only thing that would say so is the arrangement they produce.
  */
 interface ForceRelaxation {
     bodies: ForceBody[];
@@ -804,6 +762,7 @@ declare function ranksOf(graph: Graph, back: ReadonlySet<string>): Map<string, n
  *  moves nothing — except under `order: 'barycenter'`, which reorders them. */
 declare const layered: LayoutFn;
 
+/** A graph read as trees: its roots, each node's children in order, and each node's depth. */
 interface Forest {
     roots: GraphNode[];
     children: Map<string, GraphNode[]>;
@@ -843,4 +802,4 @@ declare function rayHit(poly: readonly number[], center: {
  */
 declare function portsOnOutline(ports: readonly Port[], outline: Outline, bounds: Bounds): Port[];
 
-export { contentBox as $, type GroupInset as A, type BodySpec as B, COMPASS as C, type DiagramNodeLike as D, type LayoutAxes as E, type ForceOptions as F, type GraphSource as G, type LayoutDirection as H, type RowBox as I, type RowNodeData as J, type RowPort as K, type LayoutFn as L, type MeasureRowText as M, type RowPortBox as N, type Outline as O, type Port as P, type RowTextStyle as Q, type Row as R, type Slot as S, axesFor as T, backEdges as U, bodyOutline as V, bodyTrait as W, boxForContent as X, buildBody as Y, buildGraph as Z, canvasMeasure as _, type PortsOptions as a, createDiagramNodes as a0, dataKeyReader as a1, diagramNodeOf as a2, expandGroupEdges as a3, force as a4, forceRelaxation as a5, forestOf as a6, graphOrder as a7, insetOf as a8, isPinned as a9, layered as aa, layoutBody as ab, layoutRowPorts as ac, measureBody as ad, outlinePath as ae, outlinePolyline as af, packAcross as ag, packClusters as ah, pinnedSet as ai, portOf as aj, portsOf as ak, portsOnOutline as al, rankGaps as am, ranksOf as an, rayHit as ao, seededOrder as ap, settle as aq, sizeToBody as ar, translated as as, tree as at, untilSettled as au, extent as av, type DiagramNodeReader as b, type PortAnchor as c, type DiagramGroup as d, type PortSpec as e, type DiagramNode as f, type LayoutOptions as g, type LayoutResult as h, type Graph as i, type BodyFloor as j, type BodyNodeSpec as k, type Bounds as l, type BuildBodyOptions as m, type BuildGraphOptions as n, DEFAULT_GROUP_INSET as o, DEFAULT_NODE_GAP as p, DEFAULT_PORTS as q, DEFAULT_RANK_GAP as r, DIAGRAM_TRAIT_KEY as s, type DiagramNodeEntry as t, type ForceBody as u, type ForceRelaxation as v, type GraphEdge as w, type GraphGroup as x, type GraphNode as y, type GraphNodeLike as z };
+export { canvasMeasure as $, type GraphNode as A, type BodySpec as B, COMPASS as C, type DiagramNodeLike as D, type GraphNodeLike as E, type ForceOptions as F, type GraphSource as G, type GroupInset as H, type LayoutAxes as I, type RowBox as J, type RowNodeData as K, type LayoutFn as L, type MeasureRowText as M, type RowPort as N, type Outline as O, type Port as P, type RowPortBox as Q, type Row as R, type RowTextStyle as S, type Slot as T, axesFor as U, backEdges as V, bodyOutline as W, bodyTrait as X, boxForContent as Y, buildBody as Z, buildGraph as _, type PortsOptions as a, contentBox as a0, createDiagramNodes as a1, dataKeyReader as a2, diagramNodeOf as a3, expandGroupEdges as a4, force as a5, forceRelaxation as a6, forestOf as a7, graphOrder as a8, insetOf as a9, isPinned as aa, layered as ab, layoutBody as ac, layoutRowPorts as ad, measureBody as ae, outlinePath as af, outlinePolyline as ag, packAcross as ah, packClusters as ai, pinnedSet as aj, portOf as ak, portsOf as al, portsOnOutline as am, rankGaps as an, ranksOf as ao, rayHit as ap, seededOrder as aq, settle as ar, sizeToBody as as, translated as at, tree as au, untilSettled as av, extent as aw, type DiagramNodeReader as b, type PortAnchor as c, type DiagramGroup as d, type PortSpec as e, type DiagramNode as f, type LayoutOptions as g, type LayoutResult as h, type Graph as i, type LayoutDirection as j, type BodyFloor as k, type BodyNodeSpec as l, type Bounds as m, type BuildBodyOptions as n, type BuildGraphOptions as o, DEFAULT_GROUP_INSET as p, DEFAULT_NODE_GAP as q, DEFAULT_PORTS as r, DEFAULT_RANK_GAP as s, DIAGRAM_TRAIT_KEY as t, type DiagramNodeEntry as u, type ForceBody as v, type ForceRelaxation as w, type Forest as x, type GraphEdge as y, type GraphGroup as z };

package/dist/layout.js

@@ -1,3 +1,3 @@
-export { COMPASS, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, axesFor, backEdges, bodyOutline, boxForContent, buildBody, canvasMeasure, contentBox, extent, force, forceRelaxation, forestOf, graphOrder, layered, layoutBody, layoutRowPorts, measureBody, outlinePath, outlinePolyline, packAcross, pinnedSet, portOf, portsOf, portsOnOutline, ranksOf, rayHit, seededOrder, settle, sizeToBody, translated, tree, untilSettled } from './chunk-EDSBULQM.js';
+export { COMPASS, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, axesFor, backEdges, bodyOutline, boxForContent, buildBody, canvasMeasure, contentBox, extent, force, forceRelaxation, forestOf, graphOrder, layered, layoutBody, layoutRowPorts, measureBody, outlinePath, outlinePolyline, packAcross, pinnedSet, portOf, portsOf, portsOnOutline, ranksOf, rayHit, seededOrder, settle, sizeToBody, translated, tree, untilSettled } from './chunk-JZ4CVLAB.js';
 //# sourceMappingURL=layout.js.map
 //# sourceMappingURL=layout.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/diagram",
-  "version": "1.9.4",
+  "version": "1.10.1",
   "description": "Node-link diagramming for weasel: any scene node becomes a diagram participant, with ports on its perimeter and an optional body builder for flowchart-shaped boxes.",
   "license": "MIT",
   "type": "module",
@@ -21,9 +21,11 @@
   },
   "peerDependencies": {
     "react": ">=18",
-    "@weasel-js/core": "1.9.4",
-    "@weasel-js/font": "1.9.4",
-    "@weasel-js/geom": "1.9.4"
+    "@weasel-js/animator": "1.10.1",
+    "@weasel-js/core": "1.10.1",
+    "@weasel-js/font": "1.10.1",
+    "@weasel-js/geom": "1.10.1",
+    "@weasel-js/simulation": "1.10.1"
   },
   "author": "orochi235",
   "homepage": "https://orochi235.github.io/weasel/",