@graphty/graphty-element 2.5.1 → 2.6.0

package/dist/chunks/parse-BMTqt4SS.js

@@ -0,0 +1,3658 @@
+var wt = (t) => {
+  throw TypeError(t);
+};
+var at = (t, e, i) => e.has(t) || wt("Cannot " + i);
+var o = (t, e, i) => (at(t, e, "read from private field"), i ? i.call(t) : e.get(t)), g = (t, e, i) => e.has(t) ? wt("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, i), u = (t, e, i, s) => (at(t, e, "write to private field"), s ? s.call(t, i) : e.set(t, i), i), p = (t, e, i) => (at(t, e, "access private method"), i);
+import { arfLayout as Jt, bfsLayout as Qt, bipartiteLayout as Zt, circularLayout as Xt, createSimulation as ei, seedPositions as ti, resolveNodeVector as ii, gridLayout as si, kamadaKawaiLayout as ni, multipartiteLayout as oi, planarLayout as ai, radialLayout as ri, randomLayout as di, shellLayout as ci, spectralLayout as li, spiralLayout as hi } from "@graphty/layout";
+import { z as n } from "zod/v4";
+import { a as I, S as A, L as ft, k as ui, W as mi, l as Wt, m as pi, g as _t } from "./paletteRegistry-BCFSwJGK.js";
+import { k as x, j as fi } from "./algorithms-BJ6DQMOe.js";
+import { forceLink as gi, forceSimulation as bi, forceManyBody as yi, forceCenter as xi } from "d3-force-3d";
+import { makeMask as Nt, maskSet as Ze } from "@graphty/graph-format";
+import { C as rt, E as Si, o as wi, F as gt, G as jt, H as dt, I as Ni } from "./optionsFromZod-CKMYSwTz.js";
+import { G as tt } from "./pluginRegistry-Bs8bEkz9.js";
+import Di from "ngraph.forcelayout";
+import Oi from "ngraph.graph";
+import { V as vi, Y as ki, g as Mi, I as Ei, B as Ii, G as Ai, d as Ri, O as Dt, i as Ot, T as vt, P as kt, C as Mt, h as Ci, b as zi, R as Fi, a as Et, c as It, e as At } from "./sequential-Zym81qm7.js";
+const Pi = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  scaling: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Scaling",
+      description: "Scale factor for the attractive force",
+      step: 0.1
+    }
+  },
+  a: {
+    schema: n.number().positive().default(1.1),
+    meta: {
+      label: "Attraction Ratio",
+      description: "Ratio of attraction to repulsion",
+      step: 0.1,
+      advanced: !0
+    }
+  },
+  maxIter: {
+    schema: n.number().int().positive().default(1e3),
+    meta: {
+      label: "Max Iterations",
+      description: "Maximum number of iterations"
+    }
+  },
+  seed: {
+    schema: n.number().positive().nullable().default(null),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible layout",
+      advanced: !0
+    }
+  }
+}), Ti = n.strictObject({
+  ...A.shape,
+  pos: n.record(n.number(), n.array(n.number())).or(n.null()).default(null),
+  scaling: n.number().positive().default(1),
+  a: n.number().positive().default(1.1),
+  maxIter: n.number().positive().default(1e3),
+  seed: n.number().positive().or(n.null()).default(null)
+}), Fe = class Fe extends I {
+  /**
+   * Create an ARF layout engine
+   * @param opts - Configuration options for the ARF algorithm
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 100, this.config = Ti.parse(e);
+  }
+  /**
+   * Get dimension-specific options for ARF layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Empty object for 2D, null for 3D (unsupported)
+   */
+  static getOptionsForDimension(e) {
+    return e > this.maxDimensions ? null : {};
+  }
+  /**
+   * Compute node positions using the ARF algorithm
+   */
+  doLayout() {
+    this.stale = !1;
+    const e = () => this._nodes.map((s) => s.id), i = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = Jt(
+      { nodes: e, edges: i },
+      this.config.pos,
+      this.config.scaling,
+      this.config.a,
+      this.config.maxIter,
+      this.config.seed
+    );
+  }
+};
+Fe.type = "arf", Fe.maxDimensions = 2, Fe.zodOptionsSchema = Pi;
+let pe = Fe;
+const Li = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(20),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  start: {
+    schema: n.union([n.string(), n.number()]),
+    meta: {
+      label: "Start Node",
+      description: "Starting node for BFS traversal"
+    }
+  },
+  align: {
+    schema: n.enum(["vertical", "horizontal"]).default("vertical"),
+    meta: {
+      label: "Alignment",
+      description: "Direction of BFS tree expansion"
+    }
+  },
+  scale: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the layout",
+      step: 0.1
+    }
+  }
+}), Wi = n.strictObject({
+  ...A.shape,
+  start: n.number().or(n.string()),
+  align: n.enum(["vertical", "horizontal"]).default("vertical"),
+  scale: n.number().positive().default(1),
+  center: n.array(n.number()).length(2).or(n.null()).default(null)
+}), Pe = class Pe extends I {
+  /**
+   * Create a BFS layout engine
+   * @param opts - Configuration options including start node and alignment
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 20, this.config = Wi.parse(e);
+  }
+  /**
+   * Get dimension-specific options for BFS layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Empty object for 2D, null for 3D (unsupported)
+   */
+  static getOptionsForDimension(e) {
+    return e > this.maxDimensions ? null : {};
+  }
+  /**
+   * Compute node positions using BFS traversal
+   */
+  doLayout() {
+    this.stale = !1;
+    const e = () => this._nodes.map((s) => s.id), i = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = Qt(
+      { nodes: e, edges: i },
+      this.config.start,
+      this.config.align,
+      this.config.scale,
+      this.config.center
+    );
+  }
+};
+Pe.type = "bfs", Pe.maxDimensions = 2, Pe.zodOptionsSchema = Li;
+let fe = Pe;
+const _i = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(40),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  align: {
+    schema: n.enum(["vertical", "horizontal"]).default("vertical"),
+    meta: {
+      label: "Alignment",
+      description: "Direction of bipartite partitions"
+    }
+  },
+  scale: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the layout",
+      step: 0.1
+    }
+  },
+  aspectRatio: {
+    schema: n.number().positive().default(4 / 3),
+    meta: {
+      label: "Aspect Ratio",
+      description: "Width to height ratio",
+      step: 0.1
+    }
+  }
+}), ji = n.strictObject({
+  ...A.shape,
+  nodes: n.array(n.number().or(n.string())),
+  align: n.enum(["vertical", "horizontal"]).default("vertical"),
+  scale: n.number().positive().default(1),
+  center: n.array(n.number()).length(2).or(n.null()).default(null),
+  aspectRatio: n.number().positive().default(4 / 3)
+}), Te = class Te extends I {
+  /**
+   * Create a bipartite layout engine
+   * @param opts - Configuration options including node partitions and alignment
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 40, this.config = ji.parse(e);
+  }
+  /**
+   * Get dimension-specific options for bipartite layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Empty object for 2D, null for 3D (unsupported)
+   */
+  static getOptionsForDimension(e) {
+    return e > this.maxDimensions ? null : {};
+  }
+  /**
+   * Compute node positions for bipartite graph
+   */
+  doLayout() {
+    this.stale = !1;
+    const e = () => this._nodes.map((s) => s.id), i = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = Zt(
+      { nodes: e, edges: i },
+      this.config.nodes,
+      this.config.align,
+      this.config.scale,
+      this.config.center,
+      this.config.aspectRatio
+    );
+  }
+};
+Te.type = "bipartite", Te.maxDimensions = 2, Te.zodOptionsSchema = _i;
+let ge = Te;
+const Hi = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  scale: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the circular layout radius",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: n.number().int().min(2).max(3).default(2),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  }
+}), Bi = n.strictObject({
+  ...A.shape,
+  scale: n.number().positive().default(1),
+  center: n.array(n.number()).min(2).max(3).or(n.null()).default(null),
+  dim: n.number().default(2)
+}), Le = class Le extends I {
+  /**
+   * Create a circular layout engine
+   * @param opts - Configuration options including scale and dimensions
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 80, this.config = Bi.parse(e);
+  }
+  /**
+   * Get dimension-specific options for circular layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Options object with dim parameter
+   */
+  static getOptionsForDimension(e) {
+    return { dim: e };
+  }
+  /**
+   * Compute node positions in a circular arrangement
+   */
+  doLayout() {
+    this.stale = !1;
+    const e = () => this._nodes.map((s) => s.id), i = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = Xt({ nodes: e, edges: i }, this.config.scale, this.config.center, this.config.dim);
+  }
+};
+Le.type = "circular", Le.maxDimensions = 3, Le.zodOptionsSchema = Hi;
+let be = Le;
+const Gi = x({
+  alphaMin: {
+    schema: n.number().positive().default(0.1),
+    meta: {
+      label: "Alpha Min",
+      description: "Minimum alpha before simulation stops",
+      step: 0.01,
+      advanced: !0
+    }
+  },
+  alphaTarget: {
+    schema: n.number().min(0).default(0),
+    meta: {
+      label: "Alpha Target",
+      description: "Target alpha value",
+      step: 0.01,
+      advanced: !0
+    }
+  },
+  alphaDecay: {
+    schema: n.number().positive().default(0.0228),
+    meta: {
+      label: "Alpha Decay",
+      description: "Rate of alpha decay per tick",
+      step: 1e-3,
+      advanced: !0
+    }
+  },
+  velocityDecay: {
+    schema: n.number().positive().default(0.4),
+    meta: {
+      label: "Velocity Decay",
+      description: "Velocity damping factor",
+      step: 0.05
+    }
+  }
+});
+function ct(t) {
+  return typeof t == "object" && t !== null && "index" in t && typeof t.index == "number" && "x" in t && typeof t.x == "number" && "y" in t && typeof t.y == "number" && "z" in t && typeof t.z == "number" && "vx" in t && typeof t.vx == "number" && "vy" in t && typeof t.vy == "number" && "vz" in t && typeof t.vz == "number";
+}
+const qi = n.strictObject({
+  alphaMin: n.number().positive().default(0.1),
+  alphaTarget: n.number().min(0).default(0),
+  alphaDecay: n.number().positive().default(0.0228),
+  velocityDecay: n.number().positive().default(0.4)
+});
+function $i(t) {
+  return !!(typeof t == "object" && t !== null && Object.hasOwn(t, "index") && "index" in t && typeof t.index == "number" && "source" in t && ct(t.source) && "target" in t && ct(t.target));
+}
+function Rt(t) {
+  t.fx = t.x, t.fy = t.y, t.fz = t.z;
+}
+const X = class X extends ft {
+  /**
+   * Create a D3 force-directed layout engine
+   * @param anyOpts - Configuration options for the D3 simulation
+   */
+  constructor(e = {}) {
+    super(), this.nodeMapping = /* @__PURE__ */ new Map(), this.edgeMapping = /* @__PURE__ */ new Map(), this.newNodeMap = /* @__PURE__ */ new Map(), this.newEdgeMap = /* @__PURE__ */ new Map(), this.reheat = !1;
+    const i = qi.parse(e);
+    this.d3AlphaMin = i.alphaMin, this.d3AlphaTarget = i.alphaTarget, this.d3AlphaDecay = i.alphaDecay, this.d3VelocityDecay = i.velocityDecay;
+    const s = gi();
+    s.strength(0.9), this.d3ForceLayout = bi().numDimensions(3).alpha(1).force("link", s).force("charge", yi()).force("center", xi()).force("dagRadial", null).stop(), this.d3ForceLayout.force("link").id((a) => a.id);
+  }
+  /**
+   * Check if there are pending nodes or edges to be processed
+   * @returns True if the graph needs to be refreshed
+   */
+  get graphNeedsRefresh() {
+    return !!this.newNodeMap.size || !!this.newEdgeMap.size;
+  }
+  /**
+   * Initialize the layout engine
+   *
+   * D3 force simulation is initialized in the constructor and doesn't require
+   * additional async initialization.
+   */
+  async init() {
+  }
+  /**
+   * Refresh the D3 simulation with pending nodes and edges
+   */
+  refresh() {
+    if (this.graphNeedsRefresh || this.reheat) {
+      let e = [...this.nodeMapping.values()];
+      e = e.concat([...this.newNodeMap.values()]), this.d3ForceLayout.alpha(1).nodes(e).stop();
+      for (const s of this.newNodeMap.entries()) {
+        const a = s[0], d = s[1];
+        if (!ct(d))
+          throw new Error("Internal error: Node is not settled as a complete D3 Node");
+        this.nodeMapping.set(a, d), this.isHeld(a.index) && Rt(d);
+      }
+      this.newNodeMap.clear();
+      let i = [...this.edgeMapping.values()];
+      i = i.concat([...this.newEdgeMap.values()]), this.d3ForceLayout.force("link").links(i);
+      for (const s of this.newEdgeMap.entries()) {
+        const a = s[0], d = s[1];
+        if (!$i(d))
+          throw new Error("Internal error: Edge is not settled as a complete D3 Edge");
+        this.edgeMapping.set(a, d);
+      }
+      this.newEdgeMap.clear(), this.reheat = !1;
+    }
+  }
+  /**
+   * Advance the D3 simulation by one tick, and publish where it moved every node to.
+   *
+   * `LayoutManager` publishes after every step batch as well, so this copy is a duplicate when
+   * the element is driving. It is kept because this engine is also driven directly, with no
+   * manager, by `test/layout/layout-positions.test.ts` -- which is what pins that a
+   * simulation's own coordinates reach the shared array at all. An engine that never publishes
+   * is still correct; that is what the layout extension test pins from the other side.
+   */
+  step() {
+    this.refresh(), this.d3ForceLayout.tick(), this.publishPositions();
+  }
+  /**
+   * Copy the simulation's node coordinates into the shared position array.
+   *
+   * d3 keeps x, y and z as plain numbers on its own node objects, so this reads them in place and
+   * allocates nothing -- which is the point of overriding the base, whose default would build one
+   * object per node per tick.
+   */
+  publishPositions() {
+    this.refresh();
+    for (const [e, i] of this.nodeMapping)
+      this.writeNodePosition(e, i.x, i.y, i.z);
+  }
+  /**
+   * Check if the simulation has settled below alpha minimum
+   * @returns True if the simulation has settled
+   */
+  get isSettled() {
+    return this.graphNeedsRefresh ? !1 : this.d3ForceLayout.alpha() < this.d3AlphaMin;
+  }
+  /**
+   * Add a node to the D3 simulation
+   * @param n - The node to add
+   */
+  addNode(e) {
+    this.newNodeMap.set(e, { id: e.id });
+  }
+  /**
+   * Add an edge to the D3 simulation
+   * @param e - The edge to add
+   */
+  addEdge(e) {
+    this.newEdgeMap.set(e, {
+      source: e.srcId,
+      target: e.dstId
+    });
+  }
+  /**
+   * Get all nodes in the simulation
+   * @returns Iterable of nodes
+   */
+  get nodes() {
+    return this.nodeMapping.keys();
+  }
+  /**
+   * Get all edges in the simulation
+   * @returns Iterable of edges
+   */
+  get edges() {
+    return this.edgeMapping.keys();
+  }
+  /**
+   * Get the current position of a node in the simulation
+   * @param n - The node to get position for
+   * @returns The node's position coordinates
+   */
+  getNodePosition(e) {
+    const i = this._getMappedNode(e), s = { x: 0, y: 0, z: 0 };
+    return this.writeNodePosition(e, i.x, i.y, i.z), this.readNodePosition(e, s) ? s : {
+      x: i.x,
+      y: i.y,
+      z: i.z
+    };
+  }
+  /**
+   * Set a node's position in the simulation
+   * @param n - The node to set position for
+   * @param newPos - The new position coordinates
+   */
+  setNodePosition(e, i) {
+    const s = this._getMappedNode(e);
+    s.x = i.x, s.y = i.y, s.z = i.z ?? 0, this.writeNodePosition(e, s.x, s.y, s.z, "placement"), this.reheat = !0;
+  }
+  /**
+   * Get the position of an edge based on its endpoint positions
+   * @param e - The edge to get position for
+   * @returns The edge's source and destination positions
+   */
+  getEdgePosition(e) {
+    const i = this._getMappedEdge(e);
+    return {
+      src: {
+        x: i.source.x,
+        y: i.source.y,
+        z: i.source.z
+      },
+      dst: {
+        x: i.target.x,
+        y: i.target.y,
+        z: i.target.z
+      }
+    };
+  }
+  /**
+   * Pin a node to its current position
+   * @param n - The node to pin
+   */
+  pin(e) {
+    const i = this._getMappedNode(e);
+    i.fx = i.x, i.fy = i.y, i.fz = i.z;
+  }
+  /**
+   * Unpin a node to allow it to move freely
+   * @param n - The node to unpin
+   */
+  unpin(e) {
+    const i = this._getMappedNode(e);
+    this.isHeld(e.index) || (i.fx = void 0, i.fy = void 0, i.fz = void 0, this.reheat = !0);
+  }
+  /**
+   * Holds the nodes a scoped layout may not move, as d3 fixes a node: at its current position.
+   *
+   * A node that is no longer held is released unless the reader pinned it.
+   * @param mask - One bit per row to hold, or null to hold nothing.
+   * @param rows - How many rows the mask covers.
+   */
+  setHoldMask(e, i) {
+    super.setHoldMask(e, i), this.refresh();
+    for (const [s, a] of this.nodeMapping)
+      this.isHeld(s.index) ? Rt(a) : s.isPinned() || (a.fx = void 0, a.fy = void 0, a.fz = void 0);
+  }
+  /**
+   * Take a node out of the simulation.
+   *
+   * The re-push is what makes it real: d3 keeps its own arrays of nodes and links, so deleting
+   * the mapping alone would leave the simulation stepping a node the element has disposed --
+   * and every link that referenced it, whose `source` and `target` are those very objects.
+   * `refresh()` rebuilds both arrays from the mappings, and `reheat` is what makes it run.
+   *
+   * The incident links go too, and not only because the element's own removal already takes
+   * them out first: d3's link force RESOLVES a link's endpoints against the node list on every
+   * re-push and throws for an endpoint it cannot find, so one link left behind would take the
+   * next tick down rather than merely draw wrong. An engine has to survive a caller that removes
+   * a node without removing its edges.
+   * @param n - the node leaving the graph
+   */
+  removeNode(e) {
+    for (const i of this.nodeEdges(e))
+      this.removeEdge(i);
+    this.nodeMapping.delete(e), this.newNodeMap.delete(e), this.reheat = !0;
+  }
+  /**
+   * Every edge this engine holds that touches one node.
+   * @param n - the node
+   * @returns the incident edges, as a fresh array so the caller may delete while it walks
+   */
+  nodeEdges(e) {
+    const i = [];
+    for (const s of [...this.edgeMapping.keys(), ...this.newEdgeMap.keys()])
+      (s.srcId === e.id || s.dstId === e.id) && i.push(s);
+    return i;
+  }
+  /**
+   * Take an edge out of the simulation. See {@link D3GraphEngine.removeNode}.
+   * @param e - the edge leaving the graph
+   */
+  removeEdge(e) {
+    this.edgeMapping.delete(e), this.newEdgeMap.delete(e), this.reheat = !0;
+  }
+  _getMappedNode(e) {
+    this.refresh();
+    const i = this.nodeMapping.get(e);
+    if (!i)
+      throw new Error("Internal error: Node not found in D3GraphEngine");
+    return i;
+  }
+  _getMappedEdge(e) {
+    this.refresh();
+    const i = this.edgeMapping.get(e);
+    if (!i)
+      throw new Error("Internal error: Edge not found in D3GraphEngine");
+    return i;
+  }
+};
+X.type = "d3", X.maxDimensions = 3, X.zodOptionsSchema = Gi, X.scoped = !0;
+let ye = X;
+const Ui = x({
+  dim: {
+    schema: n.number().int().min(2).max(3).default(3),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  }
+}), Ki = n.strictObject({
+  ...A.shape,
+  dim: n.number().default(3)
+}), We = class We extends I {
+  /**
+   * Create a fixed layout engine
+   * @param opts - Configuration options including dimensions
+   */
+  constructor(e = {}) {
+    super(e), this.scalingFactor = 1, this.config = Ki.parse(e);
+  }
+  /**
+   * Add a node and apply its fixed position immediately
+   * @param n - The node to add
+   */
+  addNode(e) {
+    super.addNode(e);
+    const s = e.data.position;
+    s && e.mesh.position.set(s.x ?? 0, s.y ?? 0, s.z ?? 0);
+  }
+  /**
+   * Read positions from node data and apply them directly
+   */
+  doLayout() {
+    this.stale = !1;
+    const e = {};
+    for (const i of this._nodes) {
+      const a = i.data.position;
+      let d;
+      a ? d = [a.x ?? 0, a.y ?? 0, a.z ?? 0] : d = [0, 0, 0], e[i.id] = d, i.mesh.position.set(d[0], d[1], d[2]);
+    }
+    this.positions = e;
+  }
+};
+We.type = "fixed", We.maxDimensions = 3, We.zodOptionsSchema = Ui;
+let xe = We;
+const Vi = 25e4, Yi = 4;
+function Ji(t, e, i) {
+  return t !== null ? t : i > Vi ? e * Yi : e;
+}
+function Qi(t, e) {
+  if (t == null || typeof t == "string")
+    return null;
+  const i = e.outDegree();
+  return ii(t, e, (s) => i[s] + 1);
+}
+const Zi = 1e-6;
+function Xi(t, e, i, s = null) {
+  let a = 0, d = 0, h = 0, c = 0;
+  for (let f = 0; f < e; f += 1) {
+    const R = t[3 * f], G = t[3 * f + 1], w = t[3 * f + 2];
+    Number.isFinite(R) && Number.isFinite(G) && Number.isFinite(w) && s?.(f) !== !0 && (a += 1, d += R, h += G, c += w);
+  }
+  if (a === 0)
+    return { scale: 1, centre: [0, 0, 0], placed: a };
+  d /= a, h /= a, c /= a;
+  let r = 0;
+  for (let f = 0; f < e; f += 1) {
+    if (s?.(f) === !0)
+      continue;
+    const R = t[3 * f] - d, G = t[3 * f + 1] - h, w = t[3 * f + 2] - c, N = R * R + G * G + w * w;
+    Number.isFinite(N) && N > r && (r = N);
+  }
+  const b = Math.sqrt(r);
+  return { scale: b > Zi ? i / b : 1, centre: [d, h, c], placed: a };
+}
+function es(t) {
+  return t == null ? [0, 0, 0] : [t.length > 0 ? t[0] : 0, t.length > 1 ? t[1] : 0, t.length > 2 ? t[2] : 0];
+}
+const ts = {
+  forceatlas2: "forceAtlas2",
+  fruchtermanReingold: "fruchtermanReingold",
+  spring: "fruchtermanReingold",
+  "spring-electrical": "springElectrical"
+};
+function is() {
+  return new tt({
+    code: "E_INTERNAL",
+    message: "a simulation layout is constructed by LayoutManager with the graph's acceleration controller, not by LayoutEngine.get: this one was built without one",
+    source: "layout"
+  });
+}
+var Ve, ne, v, j, Ye, C, oe, y, ae, H, z, $, U, T, K, k, M, L, re, W, Je, P, Qe, V, Y, de, B, J, l, lt, F, Xe, ht, Ht, ut, et, Bt, mt, he, ue, Gt;
+const St = class St extends ft {
+  /**
+   * Builds a bridge. Nothing is planned and no simulation exists until {@link init} loads one.
+   *
+   * The parameter is declared as a bare `object` because `LayoutEngine.register` files a class
+   * whose constructor takes the options a consumer passed to `setLayout`, and a bridge takes
+   * more than that. A caller that means to build one declares its argument as a
+   * {@link SimulationEngineInit}, which is what `LayoutManager` does; a caller that arrived
+   * through `LayoutEngine.get` is refused on the next line.
+   * @param init - A {@link SimulationEngineInit}: the type, the resolved options, the
+   * controller, the error channel and the data.
+   * @throws A `GraphtyError` with `E_INTERNAL` when no controller was passed.
+   */
+  constructor(i) {
+    super();
+    g(this, l);
+    g(this, Ve);
+    g(this, ne, rt);
+    g(this, v);
+    g(this, j);
+    g(this, Ye);
+    g(this, C);
+    /**
+     * One reused pair, valid until the next call. `Edge.update()` reads it and drops it, and a
+     * fresh pair per edge per frame is the allocation this avoids.
+     */
+    g(this, oe, { src: { x: 0, y: 0, z: 0 }, dst: { x: 0, y: 0, z: 0 } });
+    g(this, y, null);
+    /**
+     * What the controller had ATTACHED when the running simulation was built, which is not the
+     * same as what that simulation runs on: below `acceleration.minNodes` the plan answers CPU
+     * with an accelerator attached. Recording the attached one is what makes a transition that
+     * would plan exactly the same way answer "unchanged", so a settled CPU layout is not rebuilt,
+     * re-uploaded and reheated by every status change the controller publishes.
+     */
+    g(this, ae, null);
+    g(this, H, !1);
+    g(this, z, null);
+    g(this, $, null);
+    g(this, U, null);
+    /**
+     * The array the simulation actually runs in, in the simulation's own units.
+     *
+     * The bridge's, not the store's: see the file header. It is rebuilt from the element's array
+     * at every load and every reload -- a freeze renumbers the rows -- and DELIBERATELY kept
+     * across an accelerator swap, which is what makes the swap continue the layout rather than
+     * restart it.
+     */
+    g(this, T, null);
+    /** What a simulation-unit offset from {@link SimulationLayoutEngine.#simCentre} is multiplied by. */
+    g(this, K, 1);
+    /** The arrangement's centre at the last publish, in the simulation's own units. */
+    g(this, k, [0, 0, 0]);
+    /** Where the element expects the arrangement's centre to be, in scene units. */
+    g(this, M);
+    /**
+     * The rows the simulation is holding still, which are the rows the ELEMENT'S array is the
+     * authority for. Rebuilt with the mask in `#applyPins` and edited with it in `#setFixed`.
+     */
+    g(this, L, /* @__PURE__ */ new Set());
+    // THE PIN LANE HAS NO ROW FOR A DRAG. `#applyPins` repacks the mask from the store's lane
+    // after every load, so a freeze or an accelerator swap mid-drag would give the pointer's node
+    // back to the forces; these nodes are OR-ed back in. They are held as nodes, not as indices,
+    // because a freeze renumbers the rows underneath them.
+    g(this, re, /* @__PURE__ */ new Set());
+    /**
+     * The node masses this simulation was built with, when the reader gave them as a record keyed
+     * by node id, and null for every other form. See {@link SimulationLayoutEngine.resolvedNodeMass}.
+     */
+    g(this, W, null);
+    /**
+     * Every batch promise this bridge has already attached a handler to.
+     *
+     * A saturated simulation answers `step()` with the OLDEST promise still in flight rather than
+     * submitting another, and with more than one batch allowed in flight that promise comes back
+     * AFTER newer ones -- so "the same promise as last time" is not enough to keep the rule of one
+     * handler per distinct promise. Weak, so a retired batch is collectable.
+     */
+    g(this, Je, /* @__PURE__ */ new WeakSet());
+    g(this, P, !1);
+    /** The simulation whose failure has already been reported; see `#onError`. */
+    g(this, Qe, null);
+    /**
+     * Ends the controller's work span while an accelerated simulation is being stepped, or null
+     * when no span is open. See `#syncWork`.
+     */
+    g(this, V, null);
+    /** Batches submitted and not yet landed or rejected. See `#syncWork`. */
+    g(this, Y, 0);
+    /** Set by `LayoutManager` while it is not stepping this layout. See {@link paused}. */
+    g(this, de, !1);
+    g(this, B, 1);
+    g(this, J, 0);
+    const s = i;
+    if (s.controller === void 0 || s.type === void 0)
+      throw is();
+    this.simulationType = s.type, u(this, Ve, s.layoutType ?? s.type), this.capability = ts[s.type], u(this, v, s.options), u(this, j, s.controller), u(this, Ye, s.report), u(this, C, s.dataManager), u(this, M, es(o(this, v).model.center ?? o(this, v).center)), o(this, k)[0] = o(this, M)[0], o(this, k)[1] = o(this, M)[1], o(this, k)[2] = o(this, M)[2];
+  }
+  /**
+   * The registered layout name, which every other engine reads off its class's `static type`.
+   *
+   * Without this the manager's `layoutType`, `getStats().layoutType` and the details of every
+   * error this bridge reports would all be undefined, and a 2D/3D switch would ask the element
+   * to set a layout called "undefined".
+   * @returns The name the consumer set.
+   */
+  get type() {
+    return o(this, Ve);
+  }
+  /**
+   * The running simulation, or null before the first load and while the bridge is stopped.
+   *
+   * Exposed so a caller that has to wait for the device -- a screenshot after a pause -- can
+   * reach an accelerated simulation's own `flush()`.
+   * @returns The simulation.
+   */
+  get simulation() {
+    return o(this, y);
+  }
+  /**
+   * Whether the running simulation is the accelerator's rather than the CPU's.
+   * @returns True when the accelerator built it.
+   */
+  get isAccelerated() {
+    return o(this, H);
+  }
+  /**
+   * The arithmetic the running simulation computes in, for a caller that labels its results.
+   * @returns The precision, which is the CPU's whenever the CPU is running the layout.
+   */
+  get precision() {
+    return o(this, ne);
+  }
+  /**
+   * How many iterations this bridge has submitted since the simulation was built. Submitted,
+   * not retired: an accelerated batch is counted when it goes out, not when it lands.
+   * @returns The count.
+   */
+  get iterationsDone() {
+    return o(this, J);
+  }
+  /**
+   * The node masses the running simulation was handed, when the element resolved them itself.
+   *
+   * A reader may give `nodeMass` as a number per node ID, as the name of a numeric node column,
+   * or not at all. Only the FIRST of those three is resolved here, into one value per dense row,
+   * because it is the only one an accelerator refuses: a GPU never sees a node ID. The other two
+   * are handed to the simulation as they stand and resolved by it at every load, on either path,
+   * which is also what keeps them right when a freeze renumbers the graph.
+   * @returns The masses, or null when the simulation resolves them itself.
+   */
+  get resolvedNodeMass() {
+    return o(this, W) === null ? null : o(this, W).slice();
+  }
+  /**
+   * The fixed-node mask the simulation is running with, packed from the store's pin lane.
+   * @returns The mask, or an empty one before the first load.
+   */
+  get pinnedMask() {
+    return o(this, U) === null ? Nt(0) : o(this, U).slice();
+  }
+  /**
+   * Whether a different accelerator is attached now than when the simulation was built.
+   *
+   * What `LayoutManager` asks on every controller transition before it swaps: `null` is nothing
+   * attached, so a detach, an injection, a device loss and a recovery all answer true, while a
+   * transition that leaves the same accelerator attached answers false -- including for a
+   * simulation the plan put on the CPU because the graph is below `acceleration.minNodes`.
+   * Rebuilding that one on every status change would re-upload the graph and reheat a layout
+   * that had settled, and it is a RELOAD that re-plans the threshold, which it does on its own.
+   * @param accelerator - What the controller holds now.
+   * @returns True when the simulation has to be rebuilt.
+   */
+  builtWithChanged(i) {
+    return i !== o(this, ae);
+  }
+  /**
+   * The FIRST load, which is what makes this engine's `init()` different from every other's.
+   *
+   * `LayoutManager._setLayoutInternal` replays the pinned nodes between `init()` and
+   * `setLayoutEngine`, through `setNodePosition` and `pin`, so a load deferred to any later
+   * point would meet those calls with no simulation to tell.
+   * @returns A promise that resolves once the simulation exists and holds the graph.
+   */
+  init() {
+    const i = o(this, C).getSnapshot();
+    return this.load(i, o(this, C).positions.view(i.nodeCount)), Promise.resolve();
+  }
+  /**
+   * Adopts a snapshot and builds the simulation the controller's plan chose for it.
+   * @param snapshot - The graph, as `getSnapshot()` returns it; the bridge derives the
+   * undirected copy the simulations require itself.
+   * @param positions - The element's stride-3 array, written in place by every batch.
+   * @throws A `GraphtyError` with `E_NO_ACCELERATOR` under the `required` policy with nothing
+   * attached, or whatever `createSimulation` throws.
+   */
+  load(i, s) {
+    o(this, y)?.dispose(), u(this, y, null), p(this, l, F).call(this), u(this, z, i), u(this, $, s), p(this, l, et).call(this, i.nodeCount, s), p(this, l, ht).call(this);
+  }
+  /**
+   * Hands the running simulation a new snapshot, rebuilding it first when the plan flipped.
+   *
+   * The re-plan is the point: a freeze can carry the graph across `acceleration.minNodes` in
+   * either direction, and design 9.4 item 4 re-evaluates the threshold at every load.
+   * @param snapshot - The snapshot that has just replaced the old one.
+   * @param positions - The element's array, re-viewed at the new node count.
+   * @throws A `GraphtyError` with `E_NO_ACCELERATOR` under the `required` policy with nothing
+   * attached.
+   */
+  reload(i, s) {
+    if (o(this, z) === null)
+      return;
+    const a = o(this, y);
+    u(this, z, i), u(this, $, s);
+    const d = p(this, l, et).call(this, i.nodeCount, s), h = o(this, j).plan({ capability: this.capability, nodeCount: i.nodeCount }), c = o(this, W) !== null;
+    if (a === null || h.accelerated !== o(this, H) || c) {
+      this.replaceSimulation();
+      return;
+    }
+    u(this, B, p(this, l, mt).call(this, i.nodeCount)), p(this, l, ut).call(this, i, d), a.load(o(this, C).undirected(i).snapshot, d), p(this, l, Xe).call(this);
+  }
+  /**
+   * Rebuilds the simulation on whatever the controller holds now, keeping the arrangement.
+   *
+   * The old simulation is disposed and the new one is loaded with the SAME positions view and
+   * the same pins, so an accelerator arriving mid-run continues the layout rather than
+   * restarting it, and one leaving hands it to the CPU where the policy allows a CPU.
+   * @throws A `GraphtyError` with `E_NO_ACCELERATOR` when the policy is `"required"` and
+   * nothing is attached. The bridge is then STOPPED -- no simulation, nothing submitted -- and
+   * the next transition that attaches an accelerator brings it back through this same method.
+   */
+  replaceSimulation() {
+    if (o(this, y)?.dispose(), u(this, y, null), p(this, l, F).call(this), o(this, z) === null || o(this, $) === null) {
+      u(this, P, !1);
+      return;
+    }
+    try {
+      p(this, l, ht).call(this);
+    } catch (i) {
+      throw u(this, P, !0), i;
+    }
+  }
+  /**
+   * Submits one batch, fire and forget.
+   *
+   * The abstract signature returns nothing, and a GPU simulation's `step()` returns a promise,
+   * so the rejection is caught here instead of by a caller. A saturated simulation returns the
+   * OLDEST promise already in flight rather than submitting another, which is how it keeps the
+   * frame loop from queueing work faster than the device retires it -- so the handlers are
+   * attached only when the promise is one this bridge has not seen. They are what closes the
+   * controller's work span: a batch landing on a settled simulation is where a GPU layout
+   * stops being work on the device.
+   */
+  step() {
+    const i = o(this, y);
+    if (i === null || o(this, P))
+      return;
+    u(this, J, o(this, J) + o(this, B));
+    const s = i.step(o(this, B));
+    p(this, l, F).call(this), s !== void 0 && !o(this, Je).has(s) && (o(this, Je).add(s), u(this, Y, o(this, Y) + 1), s.then(
+      () => {
+        u(this, Y, o(this, Y) - 1), p(this, l, F).call(this);
+      },
+      (a) => {
+        u(this, Y, o(this, Y) - 1), p(this, l, Gt).call(this, a, i);
+      }
+    ));
+  }
+  /**
+   * Submits one batch and waits for it, which the pre-step loop and the tests need.
+   * @param iterations - Iterations this batch computes.
+   * @returns A promise that resolves when the batch has landed, or rejects with its failure.
+   */
+  async stepAsync(i) {
+    if (!(o(this, y) === null || o(this, P))) {
+      u(this, J, o(this, J) + i), p(this, l, F).call(this);
+      try {
+        await o(this, y).step(i);
+      } finally {
+        p(this, l, F).call(this);
+      }
+    }
+  }
+  /**
+   * Whether the manager has stopped stepping this layout -- a consumer's pause, or any other
+   * stop. A paused layout's work span closes once its in-flight batches land, because nothing
+   * is being submitted after them.
+   * @returns True while the layout is not being stepped.
+   */
+  get paused() {
+    return o(this, de);
+  }
+  /**
+   * Tells the bridge whether the manager is stepping it.
+   * @param value - True when the manager has stopped stepping this layout.
+   */
+  set paused(i) {
+    u(this, de, i), i && p(this, l, F).call(this);
+  }
+  /**
+   * Starts the settle count again, on a simulation that has one.
+   *
+   * `reheat()` is not on the `LayoutSimulation` interface -- both CPU simulations and the GPU
+   * ones have it, and a third party's may not -- so it is feature-tested rather than assumed.
+   */
+  reheat() {
+    const i = o(this, y);
+    typeof i?.reheat == "function" && i.reheat();
+  }
+  /**
+   * Holds a node still for the duration of a drag, without pinning it.
+   *
+   * The fixed bit is the same one a pin uses, because it is the only thing that stops a
+   * simulation writing the row; what makes this temporary is that {@link endDrag} clears it
+   * again unless the drag is about to become a pin.
+   * @param n - The node the pointer has taken.
+   */
+  beginDrag(i) {
+    o(this, re).add(i), p(this, l, he).call(this, i.index, !0);
+  }
+  /**
+   * Gives the node back to the simulation, or leaves it fixed because it is being pinned.
+   * A node that was ALREADY PINNED before the pointer took it keeps its bit whatever `pin`
+   * says: the store's pin stops the row being published over, but only the fixed bit stops the
+   * simulation's own copy of it drifting away from where the reader put it, which the next
+   * refit would then have to drag back. Clearing it would leave a node the store still calls
+   * pinned being pushed around inside the simulation every frame.
+   * @param n - The node the pointer has let go of.
+   * @param pin - True when the drag ends in a pin, so the bit stays set.
+   */
+  endDrag(i, s) {
+    o(this, re).delete(i), p(this, l, he).call(this, i.index, s || i.isPinned() || this.isHeld(i.index));
+  }
+  /**
+   * Fixes a pinned node in the simulation. The store already holds the pin.
+   * @param n - The node that was pinned.
+   */
+  pin(i) {
+    p(this, l, he).call(this, i.index, !0);
+  }
+  /**
+   * Releases a node the simulation was holding fixed.
+   * @param n - The node that was unpinned.
+   */
+  unpin(i) {
+    p(this, l, he).call(this, i.index, this.isHeld(i.index));
+  }
+  /**
+   * Holds the rows a scoped layout may not move, in the simulation's own fixed-node mask too.
+   * @param mask - One bit per row to hold, or null to hold nothing.
+   * @param rows - How many rows the mask covers.
+   */
+  setHoldMask(i, s) {
+    super.setHoldMask(i, s), p(this, l, Xe).call(this);
+  }
+  /**
+   * Places one node now. A drag reaches this per pointer move, and `replayPins` once per pin.
+   * @param n - The node that moved.
+   * @param p - Where it moved to.
+   */
+  setNodePosition(i, s) {
+    const a = s.z ?? 0;
+    if (!p(this, l, ue).call(this, i.index) || !Number.isFinite(s.x) || !Number.isFinite(s.y) || !Number.isFinite(a))
+      return;
+    this.writeNodePosition(i, s.x, s.y, a, "placement");
+    const d = o(this, K);
+    o(this, y)?.setPosition(
+      i.index,
+      (s.x - o(this, M)[0]) / d + o(this, k)[0],
+      (s.y - o(this, M)[1]) / d + o(this, k)[1],
+      (a - o(this, M)[2]) / d + o(this, k)[2]
+    );
+  }
+  /**
+   * Reads a node's current coordinates, in scene units, out of the element's own position array.
+   * @param n - The node to read.
+   * @returns Its scene-unit position; the origin for a row nothing has placed.
+   */
+  getNodePosition(i) {
+    const s = { x: 0, y: 0, z: 0 };
+    return this.readNodePosition(i, s), s;
+  }
+  /**
+   * Reads both endpoints of an edge into the one pair this engine reuses.
+   * @param e - The edge to read.
+   * @returns The pair, valid until the next call; the origin for an endpoint nothing has placed.
+   */
+  getEdgePosition(i) {
+    return p(this, l, lt).call(this, i.srcNode, o(this, oe).src), p(this, l, lt).call(this, i.dstNode, o(this, oe).dst), o(this, oe);
+  }
+  /**
+   * Nothing: the snapshot IS the graph, and the simulation reads it rather than a node list.
+   */
+  addNode() {
+  }
+  /**
+   * Nothing, for the same reason as {@link addNode}.
+   */
+  addEdge() {
+  }
+  /**
+   * Every node of the graph, which is the list the FRAME LOOP walks.
+   *
+   * The bridge keeps no list of its own -- the snapshot is the graph -- but these two getters
+   * are not bookkeeping: `UpdateManager` moves a mesh only for a node this one yields, draws an
+   * edge only for an edge the next one yields, and frames the camera on their count. An empty
+   * iterable would let the simulation rewrite the position array every frame while not one mesh
+   * moved. So they answer with the data manager's own collections, which hold exactly what
+   * `LayoutManager` hands every other engine through `addNodes` / `addEdges`.
+   * @returns The graph's live node collection.
+   */
+  get nodes() {
+    return o(this, C).nodes.values();
+  }
+  /**
+   * Every edge of the graph; see {@link SimulationLayoutEngine.nodes}.
+   * @returns The graph's live edge collection.
+   */
+  get edges() {
+    return o(this, C).edges.values();
+  }
+  /**
+   * Whether the simulation has stopped moving.
+   *
+   * A bridge with no simulation -- before the first load, or stopped after a swap the policy
+   * refused -- reads settled, because nothing is going to move.
+   * @returns True when the last completed batch settled.
+   */
+  get isSettled() {
+    return o(this, y)?.settled ?? !0;
+  }
+  /**
+   * Maps the simulation's arrangement into the element's scene units, and writes it.
+   *
+   * This is the seam the file header describes. The mapping is remeasured here rather than
+   * fixed once, because a ForceAtlas2 graph expands for hundreds of iterations before it
+   * settles: a scale taken at the first step would let the arrangement grow out of the frame,
+   * and one taken at the last would not exist until the reader had already watched it happen.
+   * Remeasured, a settling graph holds its apparent size and only its shape changes.
+   *
+   * A FIXED ROW IS NEITHER PUBLISHED NOR MEASURED. Its scene-unit coordinate is the reader's --
+   * the pointer's, or where a pin left it -- and `LayoutEngine.writeNodePosition` refuses a
+   * layout-intent write to a pinned row for every engine in this element, so the skip is that
+   * same rule reaching a row a drag is holding as well. It is left out of the measurement for
+   * the same reason it is left out of the write: a radius taken over a row that is not drawn
+   * there would resize every row that is. The two sides start in step, because
+   * every path that fixes a row leaves them in step: a drag writes both through
+   * {@link SimulationLayoutEngine.setNodePosition}, and a pin, a freeze and a rebuild all fix a
+   * row whose simulation copy this mapping had just published from.
+   *
+   * THEY DRIFT APART AFTERWARDS, and deliberately. A refit rescales the arrangement around a
+   * held row without moving the row, so the longer the arrangement keeps growing the further
+   * the simulation's copy of that row sits from where it is drawn. The obvious repair -- write
+   * the row back into the simulation whenever the mapping moves -- was tried and is worse than
+   * the problem: a simulation treats a written position as a disturbance and reheats, so an
+   * accelerated ForceAtlas2 with one pinned node cleared its settle window on every frame and
+   * ran the full sixty-second test budget without once reporting itself at rest. Worse, the
+   * write changes the arrangement, which changes the refit, which asks for another write. A pin
+   * is a scene-unit promise and it is kept; how far the arrangement moves under it is not part
+   * of that promise.
+   *
+   * WHAT A GRAPH OF NOTHING BUT HELD ROWS COSTS. Fitting only the published rows means that the
+   * fewer of them there are the less there is to fit, and two free rows a hair apart are spread
+   * to the full radius exactly as a two-node graph would be. That is this rule meeting a reader
+   * who has pinned almost everything and taken the size out of the layout's hands; it is bounded
+   * -- an arrangement that measures as a point publishes at its own size -- and a graph with no
+   * free row left keeps the last map rather than falling back to the identity.
+   */
+  publishPositions() {
+    const i = o(this, z), s = o(this, T);
+    if (i === null || s === null)
+      return;
+    const a = o(this, C).positions, d = o(this, L).size === 0 ? null : (b) => o(this, L).has(b) && a.isPlaced(b), h = Xi(s, i.nodeCount, o(this, v).scalingFactor, d);
+    h.placed > 0 && (u(this, K, h.scale), o(this, k)[0] = h.centre[0], o(this, k)[1] = h.centre[1], o(this, k)[2] = h.centre[2]);
+    const c = o(this, K), r = o(this, k);
+    for (const b of this.nodes) {
+      const f = b.index;
+      if (!p(this, l, ue).call(this, f))
+        continue;
+      const R = a.isPlaced(f);
+      R && o(this, L).has(f) || this.writeNodePosition(
+        b,
+        (s[3 * f] - r[0]) * c + o(this, M)[0],
+        (s[3 * f + 1] - r[1]) * c + o(this, M)[1],
+        (s[3 * f + 2] - r[2]) * c + o(this, M)[2],
+        R ? "layout" : "placement"
+      );
+    }
+  }
+  /**
+   * Releases the simulation. The accelerator's residency for the snapshot is NOT released here:
+   * it is per snapshot and shared with the algorithm runs, and `Graph` frees it at the next
+   * freeze and at shutdown.
+   */
+  dispose() {
+    o(this, y)?.dispose(), u(this, y, null), p(this, l, F).call(this);
+  }
+};
+Ve = new WeakMap(), ne = new WeakMap(), v = new WeakMap(), j = new WeakMap(), Ye = new WeakMap(), C = new WeakMap(), oe = new WeakMap(), y = new WeakMap(), ae = new WeakMap(), H = new WeakMap(), z = new WeakMap(), $ = new WeakMap(), U = new WeakMap(), T = new WeakMap(), K = new WeakMap(), k = new WeakMap(), M = new WeakMap(), L = new WeakMap(), re = new WeakMap(), W = new WeakMap(), Je = new WeakMap(), P = new WeakMap(), Qe = new WeakMap(), V = new WeakMap(), Y = new WeakMap(), de = new WeakMap(), B = new WeakMap(), J = new WeakMap(), l = new WeakSet(), /**
+ * Reads one endpoint into the reused pair, or zeroes that half of it.
+ *
+ * `readNodePosition` leaves `out` UNTOUCHED for a row nothing has placed, which is right for a
+ * caller holding one vector per node and wrong for one pair every edge reuses: the unplaced
+ * endpoint would be drawn at the PREVIOUS edge's coordinates. The origin is what
+ * `getNodePosition` answers for the same row.
+ * @param n - The endpoint to read.
+ * @param out - The half of the pair it goes in.
+ * @param out.x - receives the scene-unit x.
+ * @param out.y - receives the scene-unit y.
+ * @param out.z - receives the scene-unit z.
+ */
+lt = function(i, s) {
+  this.readNodePosition(i, s) || (s.x = 0, s.y = 0, s.z = 0);
+}, /**
+ * Tells the controller whether the accelerator is being stepped right now.
+ *
+ * The controller counts the work it runs itself, and a simulation is none of it: the bridge
+ * submits a batch per frame until the arrangement settles, so without this the state a
+ * consumer reads would stay `"idle"` -- attached, nothing using it -- for the whole of a GPU
+ * layout, and a status chip would say the device was asleep while it was busy.
+ *
+ * The span is one settle, not one batch: opening and closing it per batch would publish a
+ * transition twice a frame, to every `onChange` listener and out to the DOM. It opens when an
+ * accelerated batch is submitted and closes when one lands on a settled simulation, when the
+ * simulation is replaced or disposed, and when a batch fails. A layout PAUSED mid-settle
+ * keeps its span only until the batches it had in flight have landed: after them nothing is
+ * submitted, so the device is idle until the layout resumes.
+ */
+F = function() {
+  var s;
+  const i = o(this, H) && o(this, y) !== null && !o(this, P) && !this.isSettled && !(o(this, de) && o(this, Y) === 0);
+  if (i !== (o(this, V) !== null)) {
+    if (i) {
+      u(this, V, o(this, j).beginWork());
+      return;
+    }
+    (s = o(this, V)) == null || s.call(this), u(this, V, null);
+  }
+}, /**
+ * Packs the store's pin lane, the dragged nodes and the scope hold into the simulation's mask.
+ *
+ * A PACK, not a copy: the lane is one byte per node and the mask is one bit. It runs after
+ * every load, because a freeze renumbers the rows and the lane is remapped with them. The
+ * nodes a pointer is holding are OR-ed in afterwards: a drag is not a pin and has no row in
+ * the lane, but it holds the node just as still.
+ */
+Xe = function() {
+  const i = o(this, z), s = o(this, y);
+  if (i === null || s === null)
+    return;
+  const { nodeCount: a } = i, d = o(this, C).positions.pinnedView(a), h = Nt(a), c = /* @__PURE__ */ new Set();
+  for (let r = 0; r < a; r += 1)
+    d[r] === 1 && (Ze(h, r, !0), c.add(r));
+  for (const r of o(this, re))
+    p(this, l, ue).call(this, r.index) && (Ze(h, r.index, !0), c.add(r.index));
+  if (this.holdMask !== null)
+    for (let r = 0; r < a; r += 1)
+      this.isHeld(r) && (Ze(h, r, !0), c.add(r));
+  u(this, U, h), u(this, L, c), s.setFixed(h);
+}, /**
+ * Plans, builds and loads a simulation over the snapshot this bridge is holding.
+ * @throws Whatever `plan()` or `createSimulation` throws.
+ */
+ht = function() {
+  const i = o(this, z), s = o(this, $);
+  if (i === null || s === null)
+    return;
+  const a = o(this, T), d = a !== null && a.length === 3 * i.nodeCount ? a : p(this, l, et).call(this, i.nodeCount, s);
+  u(this, ae, null), u(this, H, !1), u(this, ne, rt);
+  const h = o(this, j).plan({ capability: this.capability, nodeCount: i.nodeCount }), c = h.accelerated ? h.accelerator : null;
+  if (!h.accelerated && this.simulationType === "spring-electrical")
+    throw new tt({
+      code: "E_NO_ACCELERATOR",
+      message: `the layout "${this.type}" is computed on a hardware accelerator and has no processor implementation: ${h.reason}`,
+      source: "layout",
+      details: {
+        layout: this.type,
+        reason: h.reason
+      }
+    });
+  const r = o(this, C).undirected(i).snapshot;
+  p(this, l, ut).call(this, i, d), u(this, W, p(this, l, Ht).call(this, r)), u(this, B, p(this, l, mt).call(this, i.nodeCount)), u(this, y, ei(
+    this.simulationType,
+    p(this, l, Bt).call(this),
+    c === null ? null : Si(c)
+  )), u(this, ae, o(this, j).accelerator), u(this, H, h.accelerated), u(this, ne, h.accelerated ? h.precision : rt), u(this, P, !1), u(this, J, 0), o(this, y).load(r, d), p(this, l, Xe).call(this);
+}, /**
+ * Turns a reader's `nodeMass` record into one value per dense row, and leaves every other form
+ * alone. See {@link SimulationLayoutEngine.resolvedNodeMass}.
+ * @param undirected - The graph the simulation will be loaded with.
+ * @returns The masses, or null when the simulation resolves them itself.
+ */
+Ht = function(i) {
+  return Qi(o(this, v).model.nodeMass, i);
+}, /**
+ * Gives a coordinate to every row that has none, before the simulation reads them.
+ *
+ * A row nothing has placed reads as NaN, which is the element's "not laid out yet" -- and a
+ * force is an arithmetic operation, so a NaN row stays NaN through every iteration and its
+ * node never appears. The CPU simulations say so outright ("the caller seeds the array with
+ * seedPositions"), so the caller is this. Finite rows are never touched, which is what makes
+ * this safe to run at every load: an existing arrangement survives and only the rows a freeze
+ * added are placed, inside the box the rest of the graph already occupies. The array is the
+ * SIMULATION'S, which `#adoptPositions` has just filled from the element's.
+ * @param snapshot - The graph being loaded.
+ * @param positions - The simulation's array, exactly `3 * nodeCount` long.
+ */
+ut = function(i, s) {
+  const { seed: a, dim: d, scale: h, center: c } = o(this, v).model;
+  ti(
+    i,
+    s,
+    a ?? null,
+    d ?? o(this, v).dim ?? 3,
+    h ?? o(this, v).scale ?? 1,
+    c ?? o(this, v).center ?? null,
+    this.simulationType === "forceatlas2" ? "fa2" : "fr"
+  );
+}, /**
+ * Rebuilds the simulation's array from the element's, in the simulation's own units.
+ *
+ * The element's array is the one a freeze renumbers, a drag writes and a file's coordinates
+ * arrive in, so it -- not the simulation's -- is what an arrangement is carried across a load
+ * in. Each row travels through the inverse of the mapping the last publish used, which is the
+ * identity before anything has been published; an unplaced row is NaN in both arrays, and
+ * `#seededSimPositions` is what gives it a coordinate.
+ * @param nodeCount - The graph being loaded.
+ * @param positions - The element's array, exactly `3 * nodeCount` long.
+ * @returns The simulation's array, holding the element's arrangement in simulation units.
+ */
+et = function(i, s) {
+  const a = 3 * i, d = o(this, T) !== null && o(this, T).length === a ? o(this, T) : new Float32Array(a), h = o(this, K);
+  for (let c = 0; c < i; c += 1)
+    for (let r = 0; r < 3; r += 1)
+      d[3 * c + r] = (s[3 * c + r] - o(this, M)[r]) / h + o(this, k)[r];
+  return u(this, T, d), d;
+}, /**
+ * The options handed to `createSimulation`: the common knobs, then the type's own, then the
+ * iteration count this load resolved.
+ * @returns The options object.
+ */
+Bt = function() {
+  const { model: i, iterationsPerStep: s, stepMultiplier: a, ...d } = o(this, v), h = o(this, W) === null ? {} : { nodeMass: o(this, W) };
+  return { ...d, ...i, ...h, iterationsPerStep: o(this, B) };
+}, /**
+ * How many iterations one `step()` submits over the graph this load holds.
+ * @param nodeCount - The graph this load is over.
+ * @returns The iteration count.
+ */
+mt = function(i) {
+  const { iterationsPerStep: s, stepMultiplier: a } = o(this, v);
+  return Ji(s, a, i);
+}, /**
+ * Sets or clears one bit of the fixed mask and tells the simulation.
+ *
+ * A no-op before the first load and while the bridge is stopped: there is no simulation to
+ * tell, and the next load packs the whole lane anyway.
+ * @param index - The node's dense row.
+ * @param fixed - Whether the simulation must hold it still.
+ */
+he = function(i, s) {
+  const a = o(this, U), d = o(this, y);
+  a === null || d === null || !p(this, l, ue).call(this, i) || (Ze(a, i, s), s ? o(this, L).add(i) : o(this, L).delete(i), d.setFixed(a));
+}, /**
+ * Whether the loaded snapshot has a row at this index.
+ *
+ * The element's "this node has no row yet" is `INVALID_INDEX`, which is `0xffffffff` and so
+ * passes any `index < 0` test; the simulations answer an index they have no row for with a
+ * `RangeError`.
+ * @param index - The node's dense row, or the sentinel.
+ * @returns True when the index addresses a row of the loaded graph.
+ */
+ue = function(i) {
+  return Number.isInteger(i) && i >= 0 && i < (o(this, z)?.nodeCount ?? 0);
+}, /**
+ * Reports a rejected batch and stops stepping the simulation it came from.
+ *
+ * ONCE PER SIMULATION: a lost device rejects every batch it had outstanding -- two by default
+ * -- and the consumer is told about that device once.
+ *
+ * The stop flag belongs to the simulation the batch was SUBMITTED on, which is not always the
+ * one running when it lands: the device loss that rejected it also transitions the controller,
+ * and that transition can reach `LayoutManager` and swap the simulation while the rest of the
+ * batches are still in flight. Setting the flag on whatever is current would stop the
+ * simulation that just RECOVERED the layout, which would then submit nothing for the rest of
+ * its life. Dropping a replaced simulation's rejection is the other wrong answer: which of
+ * `device.lost` and an outstanding readback settles first is not ordered, so a report that
+ * skipped it would arrive or not depending on that race. It is reported either way, and only
+ * the simulation that failed is stopped.
+ *
+ * What happens after a live simulation's failure is the controller's: its own device-loss
+ * watch transitions, and that transition reaches `LayoutManager`, which rebuilds the
+ * simulation on whatever the policy now allows. The running layout reaches the CPU only AFTER
+ * the failure was reported, and only under a policy that permits a CPU.
+ * @param error - The rejection.
+ * @param from - The simulation the batch was submitted on.
+ */
+Gt = function(i, s) {
+  o(this, Qe) !== s && (u(this, Qe, s), s === o(this, y) && (u(this, P, !0), p(this, l, F).call(this)), o(this, Ye).call(this, tt.wrap(i, {
+    code: "E_INTERNAL",
+    source: "layout",
+    details: { layoutType: this.type, simulation: this.simulationType }
+  })));
+}, St.scoped = !0;
+let Ke = St;
+const ss = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  maxIter: {
+    schema: n.number().int().positive().default(100),
+    meta: {
+      label: "Max Iterations",
+      description: "Maximum number of simulation iterations"
+    }
+  },
+  jitterTolerance: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Jitter Tolerance",
+      description: "Tolerance for position jitter",
+      step: 0.1,
+      advanced: !0
+    }
+  },
+  scalingRatio: {
+    schema: n.number().positive().default(2),
+    meta: {
+      label: "Scaling Ratio",
+      description: "Ratio for force scaling",
+      step: 0.1
+    }
+  },
+  gravity: {
+    // NONNEGATIVE, not positive: zero gravity is a legal ForceAtlas2 setting -- nothing pulls
+    // the graph towards the centre and the components drift apart -- and it is what the
+    // Storybook slider has always offered as its lowest value.
+    schema: n.number().nonnegative().default(1),
+    meta: {
+      label: "Gravity",
+      description: "Strength of center gravity",
+      step: 0.1
+    }
+  },
+  distributedAction: {
+    schema: n.boolean().default(!1),
+    meta: {
+      label: "Distributed Action",
+      description: "Use distributed attraction for hubs",
+      advanced: !0
+    }
+  },
+  strongGravity: {
+    schema: n.boolean().default(!1),
+    meta: {
+      label: "Strong Gravity",
+      description: "Use stronger gravity to prevent escape",
+      advanced: !0
+    }
+  },
+  dissuadeHubs: {
+    schema: n.boolean().default(!1),
+    meta: {
+      label: "Dissuade Hubs",
+      description: "Push hubs away from each other",
+      advanced: !0
+    }
+  },
+  linlog: {
+    schema: n.boolean().default(!1),
+    meta: {
+      label: "LinLog Mode",
+      description: "Use logarithmic attraction",
+      advanced: !0
+    }
+  },
+  seed: {
+    schema: n.number().nullable().default(null),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible layout",
+      advanced: !0
+    }
+  },
+  dim: {
+    schema: n.number().int().min(2).max(3).default(2),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  },
+  weighted: {
+    schema: n.boolean().default(!0),
+    meta: {
+      label: "Use Edge Weights",
+      description: "Pull strongly connected nodes closer together"
+    }
+  },
+  nodeMass: {
+    schema: n.record(n.string(), n.number()).or(n.string()).or(n.null()).default(null),
+    meta: {
+      label: "Node Mass",
+      description: "How hard each node is to move, in one of three forms: a mass per node id, the name of a numeric node attribute to read it from, or nothing at all -- which gives every node a mass of one more than its degree, so a hub holds its ground.",
+      advanced: !0
+    }
+  }
+}), q = class q extends Ke {
+  /**
+   * Get dimension-specific options for ForceAtlas2 layout.
+   * @param dimension - The desired dimension (2 or 3).
+   * @returns Options object with dim parameter.
+   */
+  static getOptionsForDimension(e) {
+    return { dim: e };
+  }
+};
+q.type = "forceatlas2", q.simulationType = "forceatlas2", q.maxDimensions = 3, q.honoursWeights = !0, q.zodOptionsSchema = ss;
+let Se = q;
+const ns = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  columns: {
+    schema: n.number().int().positive().nullable().default(null),
+    meta: {
+      label: "Columns",
+      description: "Number of columns; empty makes the grid as close to square as it can"
+    }
+  },
+  scale: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Half the length of the grid's longer side",
+      step: 0.1
+    }
+  }
+}), os = n.strictObject({
+  ...A.shape,
+  columns: n.number().int().positive().nullable().default(null),
+  scale: n.number().positive().default(1),
+  center: n.array(n.number()).length(2).or(n.null()).default(null)
+}), _e = class _e extends I {
+  /**
+   * Create a grid layout engine
+   * @param opts - Configuration options including the column count
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 100, this.config = os.parse(e);
+  }
+  /**
+   * Get dimension-specific options for grid layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Empty object for 2D, null for 3D (unsupported)
+   */
+  static getOptionsForDimension(e) {
+    return e > this.maxDimensions ? null : {};
+  }
+  /**
+   * Compute node positions on the lattice
+   */
+  doLayout() {
+    this.stale = !1;
+    const e = () => this._nodes.map((s) => s.id), i = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = si({ nodes: e, edges: i }, this.config.columns, this.config.scale, this.config.center);
+  }
+};
+_e.type = "grid", _e.maxDimensions = 2, _e.zodOptionsSchema = ns;
+let we = _e;
+const as = "weight", rs = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(50),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  scale: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the layout",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: n.number().int().min(2).max(3).default(3),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  },
+  weighted: {
+    schema: n.boolean().default(!0),
+    meta: {
+      label: "Use Edge Weights",
+      description: "Place strongly connected nodes closer together"
+    }
+  }
+}), ds = n.strictObject({
+  ...A.shape,
+  dist: n.record(n.number(), n.record(n.number(), n.number())).or(n.null()).default(null),
+  pos: n.record(n.number(), n.array(n.number()).min(1).max(3)).or(n.null()).default(null),
+  weighted: n.boolean().default(!0),
+  scale: n.number().positive().default(1),
+  center: n.array(n.number()).min(2).max(3).or(n.null()).default(null),
+  dim: n.number().default(3)
+}), ee = class ee extends I {
+  /**
+   * Create a Kamada-Kawai layout engine
+   * @param opts - Configuration options including scale and dimensions
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 50, this.config = ds.parse(e);
+  }
+  /**
+   * Get dimension-specific options for Kamada-Kawai layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Options object with dim parameter
+   */
+  static getOptionsForDimension(e) {
+    return { dim: e };
+  }
+  /**
+   * Compute node positions using Kamada-Kawai algorithm
+   *
+   * A WEIGHT IS INVERTED ON THE WAY IN, and that is the one thing about this engine a reader
+   * has to know. Kamada-Kawai reads its weight as a graph DISTANCE -- it is fed straight to
+   * Floyd-Warshall and then drawn as a length -- so a heavier edge would push its two nodes
+   * FURTHER APART, the opposite of what a weight means everywhere else in the element, where a
+   * larger number is a stronger connection. Nothing on screen would say which convention was in
+   * force. So the element hands this solver `1 / weight` and the whole package keeps one
+   * reading: heavier means more strongly connected, means drawn closer together.
+   */
+  doLayout() {
+    this.stale = !1;
+    const s = { nodes: () => this._nodes.map((d) => d.id), edges: () => this._edges.map((d) => [d.srcId, d.dstId]) }, a = this.config.weighted ? this.pairWeights(this._edges) : null;
+    a !== null && (this.reportClampedWeights("kamada-kawai", a), s.getEdgeData = (d, h) => {
+      const c = a.get(ui(d, h));
+      if (c !== void 0)
+        return 1 / Math.max(c, mi);
+    }), this.positions = ni(
+      s,
+      this.config.dist,
+      this.config.pos,
+      as,
+      this.config.scale,
+      this.config.center,
+      this.config.dim
+    );
+  }
+};
+ee.type = "kamada-kawai", ee.maxDimensions = 3, ee.honoursWeights = !0, ee.zodOptionsSchema = rs;
+let Ne = ee;
+const cs = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(40),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  align: {
+    schema: n.enum(["vertical", "horizontal"]).default("vertical"),
+    meta: {
+      label: "Alignment",
+      description: "Direction of multipartite partitions"
+    }
+  },
+  scale: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the layout",
+      step: 0.1
+    }
+  }
+}), ls = n.strictObject({
+  ...A.shape,
+  // subsetKey: z.string().or(z.record(z.number(), z.array(z.string().or(z.number())))),
+  subsetKey: n.record(n.string(), n.array(n.string().or(n.number()))),
+  align: n.enum(["vertical", "horizontal"]).default("vertical"),
+  scale: n.number().positive().default(1),
+  center: n.array(n.number()).length(2).or(n.null()).default(null)
+}), je = class je extends I {
+  /**
+   * Create a multipartite layout engine
+   * @param opts - Configuration options including subset keys and alignment
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 40, this.config = ls.parse(e);
+  }
+  /**
+   * Get dimension-specific options for multipartite layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Empty object for 2D, null for 3D (unsupported)
+   */
+  static getOptionsForDimension(e) {
+    return e > this.maxDimensions ? null : {};
+  }
+  /**
+   * Compute node positions for multipartite graph
+   */
+  doLayout() {
+    this.stale = !1;
+    const e = () => this._nodes.map((s) => s.id), i = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = oi(
+      { nodes: e, edges: i },
+      this.config.subsetKey,
+      this.config.align,
+      this.config.scale,
+      this.config.center
+    );
+  }
+};
+je.type = "multipartite", je.maxDimensions = 2, je.zodOptionsSchema = cs;
+let De = je;
+var ce = { exports: {} }, Ct;
+function hs() {
+  if (Ct) return ce.exports;
+  Ct = 1, ce.exports = t, ce.exports.random = t, ce.exports.randomIterator = c;
+  function t(r) {
+    var b = typeof r == "number" ? r : +/* @__PURE__ */ new Date();
+    return new e(b);
+  }
+  function e(r) {
+    this.seed = r;
+  }
+  e.prototype.next = h, e.prototype.nextDouble = d, e.prototype.uniform = d, e.prototype.gaussian = i, e.prototype.random = d;
+  function i() {
+    var r, b, f;
+    do
+      b = this.nextDouble() * 2 - 1, f = this.nextDouble() * 2 - 1, r = b * b + f * f;
+    while (r >= 1 || r === 0);
+    return b * Math.sqrt(-2 * Math.log(r) / r);
+  }
+  e.prototype.levy = s;
+  function s() {
+    var r = 1.5, b = Math.pow(
+      a(1 + r) * Math.sin(Math.PI * r / 2) / (a((1 + r) / 2) * r * Math.pow(2, (r - 1) / 2)),
+      1 / r
+    );
+    return this.gaussian() * b / Math.pow(Math.abs(this.gaussian()), 1 / r);
+  }
+  function a(r) {
+    return Math.sqrt(2 * Math.PI / r) * Math.pow(1 / Math.E * (r + 1 / (12 * r - 1 / (10 * r))), r);
+  }
+  function d() {
+    var r = this.seed;
+    return r = r + 2127912214 + (r << 12) & 4294967295, r = (r ^ 3345072700 ^ r >>> 19) & 4294967295, r = r + 374761393 + (r << 5) & 4294967295, r = (r + 3550635116 ^ r << 9) & 4294967295, r = r + 4251993797 + (r << 3) & 4294967295, r = (r ^ 3042594569 ^ r >>> 16) & 4294967295, this.seed = r, (r & 268435455) / 268435456;
+  }
+  function h(r) {
+    return Math.floor(this.nextDouble() * r);
+  }
+  function c(r, b) {
+    var f = b || t();
+    if (typeof f.next != "function")
+      throw new Error("customRandom does not match expected API: next() function is missing");
+    return {
+      /**
+       * Visits every single element of a collection once, in a random order.
+       * Note: collection is modified in place.
+       */
+      forEach: G,
+      /**
+       * Shuffles array randomly, in place.
+       */
+      shuffle: R
+    };
+    function R() {
+      var w, N, Z;
+      for (w = r.length - 1; w > 0; --w)
+        N = f.next(w + 1), Z = r[N], r[N] = r[w], r[w] = Z;
+      return r;
+    }
+    function G(w) {
+      var N, Z, ot;
+      for (N = r.length - 1; N > 0; --N)
+        Z = f.next(N + 1), ot = r[Z], r[Z] = r[N], r[N] = ot, w(ot);
+      r.length && w(r[0]);
+    }
+  }
+  return ce.exports;
+}
+var us = hs();
+const ms = /* @__PURE__ */ fi(us), ps = x({
+  dim: {
+    schema: n.number().int().min(2).max(3).default(3),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  },
+  springLength: {
+    schema: n.number().positive().default(30),
+    meta: {
+      label: "Spring Length",
+      description: "Ideal spring length between connected nodes"
+    }
+  },
+  springCoefficient: {
+    schema: n.number().positive().default(8e-4),
+    meta: {
+      label: "Spring Coefficient",
+      description: "Spring stiffness coefficient",
+      step: 1e-4,
+      advanced: !0
+    }
+  },
+  gravity: {
+    schema: n.number().default(-1.2),
+    meta: {
+      label: "Gravity",
+      description: "Gravity strength (negative for repulsion)",
+      step: 0.1
+    }
+  },
+  theta: {
+    schema: n.number().positive().default(0.8),
+    meta: {
+      label: "Theta",
+      description: "Barnes-Hut approximation parameter",
+      step: 0.1,
+      advanced: !0
+    }
+  },
+  dragCoefficient: {
+    schema: n.number().positive().default(0.02),
+    meta: {
+      label: "Drag Coefficient",
+      description: "Velocity damping coefficient",
+      step: 0.01,
+      advanced: !0
+    }
+  },
+  timeStep: {
+    schema: n.number().positive().default(20),
+    meta: {
+      label: "Time Step",
+      description: "Simulation time step size",
+      advanced: !0
+    }
+  },
+  seed: {
+    schema: n.number().int().positive().nullable().default(null),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible layout",
+      advanced: !0
+    }
+  }
+}), te = class te extends ft {
+  /**
+   * Create an NGraph layout engine
+   * @param config - Configuration options for the NGraph simulation
+   */
+  constructor(e = {}) {
+    super(), this.nodeMapping = /* @__PURE__ */ new Map(), this.edgeMapping = /* @__PURE__ */ new Map(), this._settled = !0, this._stepCount = 0, this._lastMoves = [], this.seededPlacement = null, this.ngraph = Oi();
+    const i = e, s = {
+      dimensions: i.dim !== void 0 ? i.dim : 3
+    };
+    i.springLength !== void 0 && (s.springLength = i.springLength), i.springCoefficient !== void 0 && (s.springCoefficient = i.springCoefficient), i.gravity !== void 0 && (s.gravity = i.gravity), i.theta !== void 0 && (s.theta = i.theta), i.dragCoefficient !== void 0 && (s.dragCoefficient = i.dragCoefficient), i.timeStep !== void 0 && (s.timeStep = i.timeStep), typeof i.seed == "number" && (this.seededPlacement = { rng: ms(i.seed), dim: s.dimensions }), this.ngraphLayout = Di(this.ngraph, s);
+  }
+  /**
+   * Get dimension-specific options for NGraph layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Options object with dim parameter
+   */
+  static getOptionsForDimension(e) {
+    return { dim: e };
+  }
+  /**
+   * Initialize the layout engine
+   *
+   * NGraph layout is initialized in the constructor and doesn't require
+   * additional async initialization.
+   */
+  async init() {
+  }
+  /**
+   * Advance the NGraph simulation by one step
+   */
+  step() {
+    const e = this.ngraphLayout.step(), { lastMove: i } = this.ngraphLayout, s = this.nodeMapping.size, a = s > 0 ? i / s : 0;
+    this._stepCount++, this._lastMoves.push(a), this._lastMoves.length > 10 && this._lastMoves.shift();
+    const d = this._lastMoves.length > 0 ? this._lastMoves.reduce((r, b) => r + b, 0) / this._lastMoves.length : 0, h = 0.05, c = 1e3;
+    this._settled = e || d <= h || this._stepCount >= c, this.publishPositions();
+  }
+  /**
+   * Copy the simulation's node coordinates into the shared position array.
+   *
+   * `ngraphLayout.getNodePosition` hands back the body's own position object rather than a copy,
+   * so this reads it in place and allocates nothing -- which is the point of overriding the base,
+   * whose default would build one object per node per step. In two dimensions ngraph carries no
+   * z at all, and the row is published flat rather than left unplaced.
+   */
+  publishPositions() {
+    for (const [e, i] of this.nodeMapping) {
+      const s = this.ngraphLayout.getNodePosition(i.id);
+      this.writeNodePosition(e, s.x, s.y, s.z ?? 0);
+    }
+  }
+  /**
+   * Check if the simulation has settled
+   * @returns True if the simulation has settled
+   */
+  get isSettled() {
+    return this._settled;
+  }
+  /**
+   * Add a node to the NGraph simulation
+   * @param n - The node to add
+   */
+  addNode(e) {
+    const i = this.ngraph.addNode(e.id, { parentNode: e });
+    if (this.nodeMapping.set(e, i), this.seededPlacement) {
+      const { rng: s, dim: a } = this.seededPlacement, { springLength: d } = this.ngraphLayout.simulator.settings, h = () => (s.nextDouble() - 0.5) * d, c = h(), r = h();
+      this.ngraphLayout.setNodePosition(e.id, c, r, a === 3 ? h() : 0);
+    }
+    this.isHeld(e.index) && this.ngraphLayout.pinNode(i, !0), this._settled = !1, this._stepCount = 0, this._lastMoves = [];
+  }
+  /**
+   * Add an edge to the NGraph simulation
+   * @param e - The edge to add
+   */
+  addEdge(e) {
+    const i = this.ngraph.addLink(e.srcId, e.dstId, { parentEdge: e });
+    this.edgeMapping.set(e, i), this._settled = !1, this._stepCount = 0, this._lastMoves = [];
+  }
+  /**
+   * Get the current position of a node
+   * @param n - The node to get position for
+   * @returns The node's position coordinates
+   */
+  getNodePosition(e) {
+    const i = this._getMappedNode(e), s = this.ngraphLayout.getNodePosition(i.id), a = { x: 0, y: 0, z: 0 };
+    return this.writeNodePosition(e, s.x, s.y, s.z ?? 0), this.readNodePosition(e, a) ? a : s;
+  }
+  /**
+   * Set a node's position in the simulation
+   * @param n - The node to set position for
+   * @param newPos - The new position coordinates
+   */
+  setNodePosition(e, i) {
+    const s = this._getMappedNode(e), a = this.ngraphLayout.getNodePosition(s.id);
+    a.x = i.x, a.y = i.y, a.z = i.z, this.writeNodePosition(e, i.x, i.y, i.z ?? 0, "placement");
+  }
+  /**
+   * Get the position of an edge based on its endpoint positions
+   * @param e - The edge to get position for
+   * @returns The edge's source and destination positions
+   */
+  getEdgePosition(e) {
+    const i = this._getMappedEdge(e), s = this.ngraphLayout.getLinkPosition(i.id);
+    return {
+      src: {
+        x: s.from.x,
+        y: s.from.y,
+        z: s.from.z
+      },
+      dst: {
+        x: s.to.x,
+        y: s.to.y,
+        z: s.to.z
+      }
+    };
+  }
+  /**
+   * Get all nodes in the simulation
+   * @returns Iterable of nodes
+   */
+  get nodes() {
+    return this.nodeMapping.keys();
+  }
+  /**
+   * Get all edges in the simulation
+   * @returns Iterable of edges
+   */
+  get edges() {
+    return this.edgeMapping.keys();
+  }
+  /**
+   * Pin a node to its current position
+   * @param n - The node to pin
+   */
+  pin(e) {
+    const i = this._getMappedNode(e);
+    this.ngraphLayout.pinNode(i, !0);
+  }
+  /**
+   * Unpin a node to allow it to move freely
+   * @param n - The node to unpin
+   */
+  unpin(e) {
+    const i = this._getMappedNode(e);
+    this.ngraphLayout.pinNode(i, this.isHeld(e.index));
+  }
+  /**
+   * Holds the nodes a scoped layout may not move, as pinned bodies. A node that is no longer
+   * held is released unless the reader pinned it.
+   * @param mask - One bit per row to hold, or null to hold nothing.
+   * @param rows - How many rows the mask covers.
+   */
+  setHoldMask(e, i) {
+    super.setHoldMask(e, i);
+    for (const [s, a] of this.nodeMapping)
+      this.ngraphLayout.pinNode(a, this.isHeld(s.index) || s.isPinned());
+  }
+  /**
+   * Take a node out of the simulation, and the links ngraph drops with it.
+   *
+   * `ngraph.removeNode` removes the node's links too, so the element's own edge mapping is
+   * swept for links that no longer belong to any graph -- otherwise `getEdgePosition` would ask
+   * ngraph for the position of a link it has already forgotten.
+   * @param n - the node leaving the graph
+   */
+  removeNode(e) {
+    const i = this.nodeMapping.get(e);
+    if (i) {
+      for (const [s, a] of this.edgeMapping)
+        (a.fromId === i.id || a.toId === i.id) && this.edgeMapping.delete(s);
+      this.ngraph.removeNode(i.id), this.nodeMapping.delete(e), this._settled = !1;
+    }
+  }
+  /**
+   * Take an edge out of the simulation. See {@link NGraphEngine.removeNode}.
+   * @param e - the edge leaving the graph
+   */
+  removeEdge(e) {
+    const i = this.edgeMapping.get(e);
+    i && (this.ngraph.removeLink(i), this.edgeMapping.delete(e), this._settled = !1);
+  }
+  _getMappedNode(e) {
+    const i = this.nodeMapping.get(e);
+    if (!i)
+      throw new Error("Internal error: Node not found in NGraphEngine");
+    return i;
+  }
+  _getMappedEdge(e) {
+    const i = this.edgeMapping.get(e);
+    if (!i)
+      throw new Error("Internal error: Edge not found in NGraphEngine");
+    return i;
+  }
+};
+te.type = "ngraph", te.maxDimensions = 3, te.zodOptionsSchema = ps, te.scoped = !0;
+let Oe = te;
+const fs = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(70),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  scale: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the planar layout",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: n.number().int().min(2).max(2).default(2),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D only for planar)"
+    }
+  },
+  seed: {
+    schema: n.number().nullable().default(null),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible layout",
+      advanced: !0
+    }
+  }
+}), gs = n.strictObject({
+  ...A.shape,
+  scale: n.number().positive().default(1),
+  center: n.array(n.number()).length(2).or(n.null()).default(null),
+  dim: n.number().default(2),
+  seed: n.number().or(n.null()).default(null)
+}), He = class He extends I {
+  /**
+   * Create a planar layout engine
+   * @param opts - Configuration options including scale and seed
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 70, this.config = gs.parse(e);
+  }
+  /**
+   * Get dimension-specific options for planar layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Options object with dim parameter or null for 3D (unsupported)
+   */
+  static getOptionsForDimension(e) {
+    return e > this.maxDimensions ? null : { dim: e };
+  }
+  /**
+   * Compute planar node positions with no edge crossings
+   */
+  doLayout() {
+    this.stale = !1;
+    const e = () => this._nodes.map((s) => s.id), i = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = ai(
+      { nodes: e, edges: i },
+      this.config.scale,
+      this.config.center,
+      this.config.dim,
+      this.config.seed
+    );
+  }
+};
+He.type = "planar", He.maxDimensions = 2, He.zodOptionsSchema = fs;
+let ve = He;
+const bs = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  root: {
+    schema: n.union([n.string(), n.number()]).nullable().default(null),
+    meta: {
+      label: "Root Node",
+      description: "The node at the centre; empty picks the node with the most edges"
+    }
+  },
+  scale: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Radius of the outermost ring",
+      step: 0.1
+    }
+  }
+}), ys = n.strictObject({
+  ...A.shape,
+  root: n.union([n.string(), n.number()]).nullable().default(null),
+  scale: n.number().positive().default(1),
+  center: n.array(n.number()).length(2).or(n.null()).default(null)
+}), Be = class Be extends I {
+  /**
+   * Create a radial layout engine
+   * @param opts - Configuration options including the root node
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 100, this.config = ys.parse(e);
+  }
+  /**
+   * Get dimension-specific options for radial layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Empty object for 2D, null for 3D (unsupported)
+   */
+  static getOptionsForDimension(e) {
+    return e > this.maxDimensions ? null : {};
+  }
+  /**
+   * Compute node positions on rings around the root
+   */
+  doLayout() {
+    this.stale = !1;
+    const e = () => this._nodes.map((s) => s.id), i = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = ri({ nodes: e, edges: i }, this.config.root, this.config.scale, this.config.center);
+  }
+};
+Be.type = "radial", Be.maxDimensions = 2, Be.zodOptionsSchema = bs;
+let ke = Be;
+const qt = 1, xs = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  dim: {
+    schema: n.number().int().min(2).max(3).default(2),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  },
+  seed: {
+    schema: n.number().positive().nullable().default(qt),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible random positions",
+      advanced: !0
+    }
+  }
+}), Ss = n.strictObject({
+  ...A.shape,
+  center: n.array(n.number()).min(2).max(3).or(n.null()).default(null),
+  dim: n.number().default(2),
+  seed: n.number().positive().or(n.null()).default(qt)
+}), Ge = class Ge extends I {
+  /**
+   * Create a random layout engine
+   * @param opts - Configuration options including dimensions and seed
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 100, this.config = Ss.parse(e);
+  }
+  /**
+   * Get dimension-specific options for random layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Options object with dim parameter
+   */
+  static getOptionsForDimension(e) {
+    return { dim: e };
+  }
+  /**
+   * Compute random node positions
+   */
+  doLayout() {
+    this.stale = !1;
+    const e = () => this._nodes.map((s) => s.id), i = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = di({ nodes: e, edges: i }, this.config.center, this.config.dim, this.config.seed);
+  }
+};
+Ge.type = "random", Ge.maxDimensions = 3, Ge.zodOptionsSchema = xs;
+let Me = Ge;
+const ws = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  scale: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the shell layout radius",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: n.number().int().min(2).max(2).default(2),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D only for shell)"
+    }
+  }
+}), Ns = n.strictObject({
+  ...A.shape,
+  nlist: n.array(n.array(n.number())).or(n.null()).default(null),
+  dim: n.number().default(2),
+  center: n.array(n.number()).length(2).or(n.null()).default(null),
+  scale: n.number().positive().default(1)
+}), qe = class qe extends I {
+  /**
+   * Create a shell layout engine
+   * @param opts - Configuration options including node lists for each shell
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 100, this.config = Ns.parse(e);
+  }
+  /**
+   * Get dimension-specific options for shell layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Options object with dim parameter or null for 3D (unsupported)
+   */
+  static getOptionsForDimension(e) {
+    return e > this.maxDimensions ? null : { dim: e };
+  }
+  /**
+   * Compute node positions in concentric shells
+   */
+  doLayout() {
+    this.stale = !1;
+    const e = () => this._nodes.map((s) => s.id), i = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = ci(
+      { nodes: e, edges: i },
+      this.config.nlist,
+      this.config.scale,
+      this.config.center,
+      this.config.dim
+    );
+  }
+};
+qe.type = "shell", qe.maxDimensions = 2, qe.zodOptionsSchema = ws;
+let Ee = qe;
+const Ds = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  scale: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the spectral layout",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: n.number().int().min(2).max(2).default(2),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D only for spectral)"
+    }
+  }
+}), Os = n.strictObject({
+  ...A.shape,
+  scale: n.number().positive().default(1),
+  center: n.array(n.number()).length(2).or(n.null()).default(null),
+  dim: n.number().default(2)
+}), $e = class $e extends I {
+  /**
+   * Create a spectral layout engine
+   * @param opts - Configuration options including scale and center
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 100, this.config = Os.parse(e);
+  }
+  /**
+   * Get dimension-specific options for spectral layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Options object with dim parameter or null for 3D (unsupported)
+   */
+  static getOptionsForDimension(e) {
+    return e > this.maxDimensions ? null : { dim: e };
+  }
+  /**
+   * Compute node positions using spectral graph theory
+   */
+  doLayout() {
+    this.stale = !1;
+    const e = () => this._nodes.map((s) => s.id), i = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = li({ nodes: e, edges: i }, this.config.scale, this.config.center, this.config.dim);
+  }
+};
+$e.type = "spectral", $e.maxDimensions = 2, $e.zodOptionsSchema = Ds;
+let Ie = $e;
+const vs = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(80),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  scale: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the spiral layout",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: n.number().int().min(2).max(2).default(2),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D only for spiral)"
+    }
+  },
+  resolution: {
+    schema: n.number().positive().default(0.35),
+    meta: {
+      label: "Resolution",
+      description: "Controls spacing between spiral turns",
+      step: 0.05,
+      advanced: !0
+    }
+  },
+  equidistant: {
+    schema: n.boolean().default(!1),
+    meta: {
+      label: "Equidistant",
+      description: "Place nodes at equal distances along the spiral",
+      advanced: !0
+    }
+  }
+}), ks = n.strictObject({
+  ...A.shape,
+  scale: n.number().positive().default(1),
+  center: n.array(n.number()).length(2).or(n.null()).default(null),
+  dim: n.number().default(2),
+  resolution: n.number().positive().default(0.35),
+  equidistant: n.boolean().default(!1)
+}), Ue = class Ue extends I {
+  /**
+   * Create a spiral layout engine
+   * @param opts - Configuration options including resolution and equidistant spacing
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 80, this.config = ks.parse(e);
+  }
+  /**
+   * Get dimension-specific options for spiral layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Options object with dim parameter or null for 3D (unsupported)
+   */
+  static getOptionsForDimension(e) {
+    return e > this.maxDimensions ? null : { dim: e };
+  }
+  /**
+   * Compute node positions along a spiral path
+   */
+  doLayout() {
+    this.stale = !1;
+    const e = () => this._nodes.map((s) => s.id), i = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = hi(
+      { nodes: e, edges: i },
+      this.config.scale,
+      this.config.center,
+      this.config.dim,
+      this.config.resolution,
+      this.config.equidistant
+    );
+  }
+};
+Ue.type = "spiral", Ue.maxDimensions = 2, Ue.zodOptionsSchema = vs;
+let Ae = Ue;
+const Ms = x({
+  springLength: {
+    schema: n.number().positive().default(10),
+    meta: {
+      label: "Spring Length",
+      description: "The distance an edge pulls its two nodes towards",
+      step: 1
+    }
+  },
+  springCoefficient: {
+    schema: n.number().positive().default(0.8),
+    meta: {
+      label: "Spring Strength",
+      description: "How hard an edge pulls; Hooke's constant",
+      step: 0.1
+    }
+  },
+  gravity: {
+    schema: n.number().default(-12),
+    meta: {
+      label: "Repulsion",
+      description: "How hard two nodes push each other apart; negative repels",
+      step: 1
+    }
+  },
+  dragCoefficient: {
+    schema: n.number().positive().default(0.9),
+    meta: {
+      label: "Drag",
+      description: "How quickly motion bleeds away, which is what lets the shape settle",
+      step: 0.05,
+      advanced: !0
+    }
+  },
+  timeStep: {
+    schema: n.number().positive().default(0.5),
+    meta: {
+      label: "Time Step",
+      description: "How far one iteration integrates; larger is faster and less stable",
+      step: 0.1,
+      advanced: !0
+    }
+  },
+  scale: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the layout",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: n.number().int().min(2).max(3).default(3),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  },
+  seed: {
+    schema: n.number().nullable().default(null),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible layout",
+      advanced: !0
+    }
+  }
+}), ie = class ie extends Ke {
+  /**
+   * Get dimension-specific options for the spring-electrical layout.
+   * @param dimension - The desired dimension (2 or 3).
+   * @returns Options object with dim parameter.
+   */
+  static getOptionsForDimension(e) {
+    return { dim: e };
+  }
+};
+ie.type = "spring-electrical", ie.simulationType = "spring-electrical", ie.maxDimensions = 3, ie.zodOptionsSchema = Ms;
+let Re = ie;
+const Es = x({
+  scalingFactor: {
+    schema: n.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  k: {
+    schema: n.number().nullable().default(null),
+    meta: {
+      label: "Spring Constant",
+      description: "Optimal distance between nodes (auto-calculated if null)",
+      advanced: !0
+    }
+  },
+  iterations: {
+    schema: n.number().positive().default(50),
+    meta: {
+      label: "Iterations",
+      description: "Number of spring simulation iterations"
+    }
+  },
+  scale: {
+    schema: n.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the layout",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: n.number().int().min(2).max(3).default(3),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  },
+  seed: {
+    schema: n.number().positive().nullable().default(null),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible layout",
+      advanced: !0
+    }
+  }
+}), se = class se extends Ke {
+  /**
+   * Get dimension-specific options for spring layout.
+   * @param dimension - The desired dimension (2 or 3).
+   * @returns Options object with dim parameter.
+   */
+  static getOptionsForDimension(e) {
+    return { dim: e };
+  }
+};
+se.type = "spring", se.simulationType = "spring", se.maxDimensions = 3, se.zodOptionsSchema = Es;
+let Ce = se;
+const Q = {
+  seed: { type: "seed" }
+};
+function S(t, e = {}) {
+  return wi(t, { overrides: e });
+}
+function D(t, e, i = []) {
+  return {
+    descriptor: {
+      ...t,
+      engine: e.engine,
+      options: e.options,
+      honoursWeights: e.honoursWeights,
+      scoped: e.scoped
+    },
+    implementations: [
+      { ...e, isDefault: !0 },
+      ...i.map((s) => ({ ...s, isDefault: !1 }))
+    ]
+  };
+}
+const Is = {
+  engine: "ngraph",
+  plainName: "NGraph Force",
+  technicalName: "ngraph.forcelayout",
+  kind: "live",
+  maxDimensions: 3,
+  reason: "The default: a Barnes-Hut simulation that runs live, accepts nodes and edges added while it is running, and stays interactive on graphs of a hundred thousand nodes.",
+  options: S(Oe.zodOptionsSchema, Q),
+  honoursWeights: Oe.honoursWeights,
+  scoped: Oe.scoped
+}, As = {
+  engine: "d3",
+  plainName: "D3 Force",
+  technicalName: "d3-force-3d",
+  kind: "live",
+  maxDimensions: 3,
+  reason: "Choose it for d3's own tuning vocabulary -- alpha, alpha decay, velocity decay -- when the arrangement has to match a d3 drawing elsewhere in the product.",
+  options: S(ye.zodOptionsSchema),
+  honoursWeights: ye.honoursWeights,
+  scoped: ye.scoped
+}, Rs = {
+  engine: "forceatlas2",
+  plainName: "ForceAtlas2",
+  technicalName: "ForceAtlas2 (Gephi)",
+  kind: "live",
+  maxDimensions: 3,
+  reason: "Choose it for the Gephi look, and for the arrangement an accelerator reproduces first. It keeps running until the layout settles and reheats on a drag or a pin.",
+  options: S(Se.zodOptionsSchema, Q),
+  honoursWeights: Se.honoursWeights,
+  scoped: Se.scoped
+}, Cs = {
+  engine: "spring",
+  plainName: "Spring",
+  technicalName: "Fruchterman-Reingold",
+  kind: "live",
+  maxDimensions: 3,
+  reason: "Choose it when the arrangement must be reproducible from a seed: the same seed gives the same settled shape.",
+  options: S(Ce.zodOptionsSchema, Q),
+  honoursWeights: Ce.honoursWeights,
+  scoped: Ce.scoped
+}, zs = {
+  engine: "spring-electrical",
+  plainName: "Spring Electrical",
+  technicalName: "ngraph.forcelayout (spring-electrical)",
+  kind: "live",
+  maxDimensions: 3,
+  reason: "Choose it for ngraph's look at a size ngraph cannot reach; it needs a hardware accelerator and says so when there is none.",
+  options: S(Re.zodOptionsSchema, Q),
+  honoursWeights: Re.honoursWeights,
+  scoped: Re.scoped,
+  requires: { accelerator: !0 }
+}, Fs = {
+  engine: "kamada-kawai",
+  plainName: "Kamada-Kawai",
+  technicalName: "Kamada-Kawai stress majorization",
+  kind: "batch",
+  maxDimensions: 3,
+  reason: "Choose it for a small graph whose drawn distances should match its graph distances. It solves over every pair of nodes, so it is slow well before the other force engines are.",
+  options: S(Ne.zodOptionsSchema),
+  honoursWeights: Ne.honoursWeights,
+  scoped: Ne.scoped
+}, Ps = {
+  engine: "arf",
+  plainName: "ARF",
+  technicalName: "Attractive and Repulsive Forces",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only registered force engine that is two-dimensional by nature, so a flat result is what it computes rather than what it is flattened into afterwards.",
+  options: S(pe.zodOptionsSchema, Q),
+  honoursWeights: pe.honoursWeights,
+  scoped: pe.scoped
+}, Ts = {
+  engine: "circular",
+  plainName: "Circular",
+  technicalName: "Circular layout",
+  kind: "batch",
+  maxDimensions: 3,
+  reason: "The only engine that draws this arrangement.",
+  options: S(be.zodOptionsSchema),
+  honoursWeights: be.honoursWeights,
+  scoped: be.scoped
+}, Ls = {
+  engine: "shell",
+  plainName: "Shell",
+  technicalName: "Shell layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: S(Ee.zodOptionsSchema),
+  honoursWeights: Ee.honoursWeights,
+  scoped: Ee.scoped
+}, Ws = {
+  engine: "radial",
+  plainName: "Radial",
+  technicalName: "Radial layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: S(ke.zodOptionsSchema),
+  honoursWeights: ke.honoursWeights,
+  scoped: ke.scoped
+}, _s = {
+  engine: "grid",
+  plainName: "Grid",
+  technicalName: "Grid layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: S(we.zodOptionsSchema),
+  honoursWeights: we.honoursWeights,
+  scoped: we.scoped
+}, js = {
+  engine: "spiral",
+  plainName: "Spiral",
+  technicalName: "Archimedean spiral layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: S(Ae.zodOptionsSchema),
+  honoursWeights: Ae.honoursWeights,
+  scoped: Ae.scoped
+}, Hs = {
+  engine: "spectral",
+  plainName: "Spectral",
+  technicalName: "Laplacian eigenvector layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: S(Ie.zodOptionsSchema),
+  honoursWeights: Ie.honoursWeights,
+  scoped: Ie.scoped
+}, Bs = {
+  engine: "planar",
+  plainName: "Planar",
+  technicalName: "Planar embedding",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: S(ve.zodOptionsSchema, Q),
+  honoursWeights: ve.honoursWeights,
+  scoped: ve.scoped
+}, Gs = {
+  engine: "bfs",
+  plainName: "BFS Tree",
+  technicalName: "Breadth-first tree layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement. It orders each row by breadth-first arrival and does not reduce edge crossings between rows.",
+  options: S(fe.zodOptionsSchema),
+  honoursWeights: fe.honoursWeights,
+  scoped: fe.scoped
+}, qs = {
+  engine: "bipartite",
+  plainName: "Bipartite",
+  technicalName: "Bipartite layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: S(ge.zodOptionsSchema),
+  honoursWeights: ge.honoursWeights,
+  scoped: ge.scoped
+}, $s = {
+  engine: "multipartite",
+  plainName: "Multipartite",
+  technicalName: "Multipartite layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: S(De.zodOptionsSchema),
+  honoursWeights: De.honoursWeights,
+  scoped: De.scoped
+}, Us = {
+  engine: "fixed",
+  plainName: "Fixed",
+  technicalName: "Fixed layout",
+  kind: "batch",
+  maxDimensions: 3,
+  reason: "The only engine that draws this arrangement.",
+  options: S(xe.zodOptionsSchema),
+  honoursWeights: xe.honoursWeights,
+  scoped: xe.scoped
+}, Ks = {
+  engine: "random",
+  plainName: "Random",
+  technicalName: "Random layout",
+  kind: "batch",
+  maxDimensions: 3,
+  reason: "The only engine that draws this arrangement.",
+  options: S(Me.zodOptionsSchema, Q),
+  honoursWeights: Me.honoursWeights,
+  scoped: Me.scoped
+}, bt = [
+  D(
+    {
+      id: "force",
+      plainName: "Spread Out",
+      technicalName: "Force-directed layout",
+      description: "Pulls connected nodes together and pushes unconnected ones apart until the shape stops moving, in three dimensions.",
+      family: "force",
+      kind: "live",
+      maxDimensions: 3,
+      sizeRating: "any",
+      structuralInputs: []
+    },
+    Is,
+    [As, Rs, Cs, Fs, zs]
+  ),
+  D(
+    {
+      id: "force-2d",
+      plainName: "Spread Out, Flat",
+      technicalName: "Force-directed layout, two-dimensional",
+      description: "The same pull and push as Spread Out, worked out on a single plane.",
+      family: "force",
+      kind: "batch",
+      maxDimensions: 2,
+      sizeRating: 2e3,
+      structuralInputs: []
+    },
+    Ps
+  ),
+  D(
+    {
+      id: "circular",
+      plainName: "Ring",
+      technicalName: "Circular layout",
+      description: "Places every node on one circle, in the order the nodes were loaded.",
+      family: "geometric",
+      kind: "batch",
+      maxDimensions: 3,
+      sizeRating: "any",
+      structuralInputs: []
+    },
+    Ts
+  ),
+  D(
+    {
+      id: "radial",
+      plainName: "Rings from a Node",
+      technicalName: "Radial layout",
+      description: "Puts one node at the centre and every other node on a ring by how many steps away it is, so the rings read outward as distance from that node.",
+      family: "geometric",
+      kind: "batch",
+      maxDimensions: 2,
+      sizeRating: "any",
+      structuralInputs: []
+    },
+    Ws
+  ),
+  D(
+    {
+      id: "grid",
+      plainName: "Grid",
+      technicalName: "Grid layout",
+      description: "Places nodes in evenly spaced rows and columns, in the order the nodes were loaded.",
+      family: "geometric",
+      kind: "batch",
+      maxDimensions: 2,
+      sizeRating: "any",
+      structuralInputs: []
+    },
+    _s
+  ),
+  D(
+    {
+      id: "shell",
+      plainName: "Concentric Rings",
+      technicalName: "Shell layout",
+      description: "Places each group of nodes on its own ring, around a shared centre.",
+      family: "geometric",
+      kind: "batch",
+      maxDimensions: 2,
+      sizeRating: "any",
+      structuralInputs: ["partition"]
+    },
+    Ls
+  ),
+  D(
+    {
+      id: "spiral",
+      plainName: "Spiral",
+      technicalName: "Archimedean spiral layout",
+      description: "Places nodes one after another along a spiral winding out from the centre.",
+      family: "geometric",
+      kind: "batch",
+      maxDimensions: 2,
+      sizeRating: "any",
+      structuralInputs: []
+    },
+    js
+  ),
+  D(
+    {
+      id: "spectral",
+      plainName: "Natural Grouping",
+      technicalName: "Spectral layout",
+      description: "Places nodes from the graph's own structure, so densely connected groups land near each other without any grouping being named.",
+      family: "geometric",
+      kind: "batch",
+      maxDimensions: 2,
+      sizeRating: 2e3,
+      structuralInputs: []
+    },
+    Hs
+  ),
+  D(
+    {
+      id: "planar",
+      plainName: "No Crossings",
+      technicalName: "Planar embedding",
+      description: "Places nodes so that no two edges cross, for the graphs where that is possible.",
+      family: "geometric",
+      kind: "batch",
+      maxDimensions: 2,
+      sizeRating: 2e3,
+      structuralInputs: []
+    },
+    Bs
+  ),
+  D(
+    {
+      id: "random",
+      plainName: "Scattered",
+      technicalName: "Random layout",
+      description: "Puts every node somewhere at random, which is where a live layout starts.",
+      family: "geometric",
+      kind: "batch",
+      maxDimensions: 3,
+      sizeRating: "any",
+      structuralInputs: []
+    },
+    Ks
+  ),
+  D(
+    {
+      id: "hierarchical",
+      plainName: "Tree",
+      technicalName: "Layered layout",
+      description: "Puts nodes in rows by how many steps they are from a starting node, so the graph reads as a tree growing away from it.",
+      family: "hierarchical",
+      kind: "batch",
+      maxDimensions: 2,
+      sizeRating: "any",
+      structuralInputs: ["node"]
+    },
+    Gs
+  ),
+  D(
+    {
+      id: "bipartite",
+      plainName: "Two Columns",
+      technicalName: "Bipartite layout",
+      description: "Puts one named set of nodes in one column and everything else in a second, for a graph whose edges only ever run between the two.",
+      family: "hierarchical",
+      kind: "batch",
+      maxDimensions: 2,
+      sizeRating: "any",
+      structuralInputs: ["partition"]
+    },
+    qs
+  ),
+  D(
+    {
+      id: "layers",
+      plainName: "Columns by Group",
+      technicalName: "Multipartite layout",
+      description: "Puts each group of nodes in its own column, in the order the groups are given.",
+      family: "hierarchical",
+      kind: "batch",
+      maxDimensions: 2,
+      sizeRating: "any",
+      structuralInputs: ["partition"]
+    },
+    $s
+  ),
+  D(
+    {
+      id: "fixed",
+      plainName: "Keep Positions",
+      technicalName: "Fixed layout",
+      description: "Leaves every node exactly where the loaded data placed it.",
+      family: "special",
+      kind: "batch",
+      maxDimensions: 3,
+      sizeRating: "any",
+      structuralInputs: []
+    },
+    Us
+  )
+], Vs = bt.map((t) => t.descriptor), xn = [];
+function Sn(t) {
+  return Vs.find((e) => e.id === t) ?? Wt(t)?.descriptor;
+}
+function wn(t) {
+  return bt.find((e) => e.descriptor.id === t);
+}
+function Nn(t) {
+  const e = bt.find(
+    (i) => i.implementations.some((s) => s.engine === t)
+  );
+  return e !== void 0 ? e.descriptor.id : Wt(t)?.descriptor.id;
+}
+const O = ["deuteranopia", "protanopia", "tritanopia"], yt = Object.freeze([
+  {
+    id: "viridis",
+    plainName: "Purple to Yellow",
+    kind: "sequential",
+    colors: vi,
+    capacity: null,
+    colorblindSafe: O
+  },
+  // Paul Tol, "Colour Schemes" (2021): YlOrBr, trimmed to the steps that stand off a light
+  // background. The default for a measurement.
+  {
+    id: "ylorbr",
+    plainName: "Orange to Brown",
+    kind: "sequential",
+    colors: ki,
+    capacity: null,
+    colorblindSafe: O
+  },
+  {
+    id: "plasma",
+    plainName: "Blue to Yellow",
+    kind: "sequential",
+    colors: Mi,
+    capacity: null,
+    colorblindSafe: O
+  },
+  {
+    id: "inferno",
+    plainName: "Black to Yellow",
+    kind: "sequential",
+    colors: Ei,
+    capacity: null,
+    colorblindSafe: O
+  },
+  {
+    id: "blues",
+    plainName: "Shades of Blue",
+    kind: "sequential",
+    colors: Ii,
+    capacity: null,
+    colorblindSafe: O
+  },
+  {
+    id: "greens",
+    plainName: "Shades of Green",
+    kind: "sequential",
+    colors: Ai,
+    capacity: null,
+    colorblindSafe: []
+  },
+  {
+    id: "oranges",
+    plainName: "Shades of Orange",
+    kind: "sequential",
+    colors: Ri,
+    capacity: null,
+    colorblindSafe: []
+  },
+  {
+    id: "okabe-ito",
+    plainName: "Eight Distinct Colours",
+    kind: "categorical",
+    colors: Dt,
+    capacity: Dt.length,
+    colorblindSafe: O
+  },
+  {
+    id: "tol-vibrant",
+    plainName: "Seven Bright Colours",
+    kind: "categorical",
+    colors: Ot,
+    capacity: Ot.length,
+    colorblindSafe: O
+  },
+  {
+    id: "tol-muted",
+    plainName: "Nine Soft Colours",
+    kind: "categorical",
+    colors: vt,
+    capacity: vt.length,
+    colorblindSafe: O
+  },
+  {
+    id: "pastel",
+    plainName: "Eight Pale Colours",
+    kind: "categorical",
+    colors: kt,
+    capacity: kt.length,
+    colorblindSafe: O
+  },
+  {
+    id: "carbon",
+    plainName: "Five Enterprise Colours",
+    kind: "categorical",
+    colors: Mt,
+    capacity: Mt.length,
+    colorblindSafe: []
+  },
+  {
+    id: "purple-green",
+    plainName: "Purple to Green",
+    kind: "diverging",
+    colors: Ci,
+    capacity: null,
+    colorblindSafe: O
+  },
+  {
+    id: "blue-orange",
+    plainName: "Blue to Orange",
+    kind: "diverging",
+    colors: zi,
+    capacity: null,
+    colorblindSafe: O
+  },
+  {
+    id: "red-blue",
+    plainName: "Red to Blue",
+    kind: "diverging",
+    colors: Fi,
+    capacity: null,
+    colorblindSafe: []
+  },
+  {
+    id: "blue-highlight",
+    plainName: "Blue Highlight",
+    kind: "categorical",
+    colors: [Et.highlighted, Et.muted],
+    capacity: 2,
+    colorblindSafe: O
+  },
+  {
+    id: "green-highlight",
+    plainName: "Green Highlight",
+    kind: "categorical",
+    colors: [It.highlighted, It.muted],
+    capacity: 2,
+    colorblindSafe: O
+  },
+  {
+    id: "orange-highlight",
+    plainName: "Orange Highlight",
+    kind: "categorical",
+    colors: [At.highlighted, At.muted],
+    capacity: 2,
+    colorblindSafe: O
+  }
+]);
+function Dn(t) {
+  return yt.find((e) => e.id === t) ?? pi(t);
+}
+function On(t) {
+  const e = yt.filter((s) => s.kind === t), i = _t().filter((s) => s.kind === t);
+  return i.length === 0 ? e : [...e, ...i];
+}
+function vn() {
+  return [...yt, ..._t()].map((t) => String(t.id));
+}
+const _ = {
+  name: "reverse",
+  plainName: "Reverse",
+  technicalName: "reverse",
+  type: "boolean",
+  default: !1,
+  description: "Send the smallest value to the far end of the range instead of the near end."
+}, le = {
+  name: "midpoint",
+  plainName: "Midpoint",
+  technicalName: "midpoint",
+  type: "number",
+  description: "The value that lands on the middle colour of a diverging palette."
+};
+function zt(t, e, i) {
+  return {
+    name: "bins",
+    plainName: t,
+    technicalName: "bins",
+    type: "integer",
+    default: i,
+    min: 2,
+    max: 20,
+    step: 1,
+    description: e
+  };
+}
+const $t = [
+  {
+    name: "linear",
+    plainName: "Even Steps",
+    domainKind: "numeric",
+    options: [_, le]
+  },
+  {
+    name: "log",
+    plainName: "By Order of Magnitude",
+    domainKind: "numeric",
+    options: [_, le]
+  },
+  {
+    name: "neglog10",
+    plainName: "By Significance",
+    domainKind: "numeric",
+    options: [_, le]
+  },
+  {
+    name: "sqrt",
+    plainName: "By Area",
+    domainKind: "numeric",
+    options: [_, le]
+  },
+  {
+    name: "pow",
+    plainName: "Curved",
+    domainKind: "numeric",
+    options: [
+      {
+        name: "exponent",
+        plainName: "Exponent",
+        technicalName: "exponent",
+        type: "number",
+        default: 1,
+        min: 0.1,
+        max: 10,
+        step: 0.1,
+        description: "How hard the curve bends. Below one spreads the small values out; above one spreads the large ones out."
+      },
+      _,
+      le
+    ]
+  },
+  {
+    name: "bins",
+    plainName: "Equal Ranges",
+    domainKind: "numeric",
+    options: [
+      zt("Groups", "How many equally wide ranges to cut the values into.", 5),
+      _
+    ]
+  },
+  {
+    name: "quantile",
+    plainName: "Equal Counts",
+    domainKind: "numeric",
+    options: [
+      zt("Groups", "How many groups of equal size to sort the values into.", 4),
+      _
+    ]
+  },
+  {
+    name: "ordinal",
+    plainName: "One Colour per Value",
+    domainKind: "categorical",
+    options: [_]
+  },
+  {
+    name: "passthrough",
+    plainName: "Use the Value As It Is",
+    domainKind: "categorical",
+    options: []
+  }
+];
+function kn(t) {
+  return $t.find((e) => e.name === t);
+}
+function Mn(t) {
+  return $t.filter((e) => e.domainKind === t);
+}
+const Ys = /* @__PURE__ */ new Set([
+  "fixed.weights",
+  "rule.scope",
+  "edgeMember.key",
+  "edgeMember.dataSource",
+  "set.graph",
+  "search",
+  "threshold.percentile",
+  "threshold.z",
+  "threshold.population",
+  "itemKey.op",
+  "itemKey.smallestNode",
+  "itemKey.edges",
+  "itemKey.binds"
+]), Js = ["visible", "graph", "selection", "largest-component"], Qs = ["induced", "listed", "clipped"], Zs = ["in", "out", "all"];
+function m(t, e = {}) {
+  return new tt({ code: "E_BAD_COMMAND", message: t, source: "data", details: e });
+}
+function E(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t);
+}
+function nt(t) {
+  return typeof t == "number" && Number.isFinite(t);
+}
+function me(t) {
+  return typeof t == "string" || nt(t);
+}
+class xt {
+  constructor(e) {
+    this.mode = e;
+  }
+  /**
+   * Meet a kind or field this element does not define: refused at a door, remembered on load.
+   * @param name - The kind, or `<node>.<field>`.
+   * @param what - How to say it in a refusal.
+   */
+  unknown(e, i) {
+    if (this.mode === "door") {
+      const s = Ys.has(e);
+      throw m(
+        s ? `"${e}" is reserved for a later release of graphty-element and cannot be used yet.` : `${i} "${e}" is not one graphty-element knows.`,
+        s ? { field: e, reserved: !0 } : { name: e }
+      );
+    }
+    this.first ??= e;
+  }
+  /**
+   * Meet every field of a node outside its known list, in code-unit order.
+   * @param value - The node.
+   * @param node - Its name, for `<node>.<field>`.
+   * @param known - The fields it defines.
+   */
+  fields(e, i, s) {
+    for (const a of Object.keys(e).sort())
+      e[a] !== void 0 && !s.includes(a) && this.unknown(`${i}.${a}`, "The field");
+  }
+}
+function it(t, e) {
+  if (!Array.isArray(t))
+    throw m(`${e} is a list of node ids.`, { value: t });
+  for (const i of t)
+    if (!me(i))
+      throw m(`${e} holds ${String(i)}, which is not a node id: an id is a string or a finite number.`, {
+        id: i
+      });
+}
+function Ft(t, e) {
+  if (!E(t))
+    throw m(
+      "An edge member is an object with a source, a target and one of id, key or ordinal with among. A session edge id is accepted only at a write door, which stores its stable form.",
+      { member: t }
+    );
+  if (e.fields(t, "edgeMember", Ni), !me(t.source) || !me(t.target))
+    throw m("An edge member's source and target are node ids.", { member: t });
+  const i = t.ordinal !== void 0;
+  if (i !== (t.among !== void 0))
+    throw m("An edge member's ordinal and among come together or not at all.", { member: t });
+  if ([t.id, t.key, t.ordinal].filter((a) => a !== void 0).length !== 1)
+    throw m("An edge member names its edge by exactly one of id, key or ordinal with among.", { member: t });
+  if (t.id !== void 0 && !me(t.id))
+    throw m("An edge member's id is a string or a finite number.", { member: t });
+  if (t.key !== void 0) {
+    if (!me(t.key))
+      throw m("An edge member's key is a string or a finite number.", { member: t });
+    e.unknown("edgeMember.key", "The field");
+  }
+  if (i) {
+    const { ordinal: a, among: d } = t;
+    if (!Number.isInteger(d) || d < 1 || !Number.isInteger(a) || a < 0 || a >= d)
+      throw m("An edge member's ordinal counts from 0 and is below among, a whole number from 1.", {
+        member: t
+      });
+  }
+}
+function ze(t, e) {
+  if (typeof t != "string" || t.trim() === "")
+    throw m(`${e} needs a query. An empty one matches every element rather than none.`, { where: t });
+}
+function Pt(t) {
+  for (const e of ["min", "max"])
+    if (t[e] !== void 0 && !nt(t[e]))
+      throw m(`A "${String(t.kind)}" leaf's ${e} must be a finite number.`, { [e]: t[e] });
+  if (t.min !== void 0 && t.max !== void 0 && t.min > t.max)
+    throw m(`A "${String(t.kind)}" leaf's min is above its max.`, { min: t.min, max: t.max });
+}
+function Xs(t, e) {
+  if (!E(t))
+    throw m("An item leaf's item is an object with a result and a key.", { item: t });
+  e.fields(t, "resultItem", ["result", "run", "key"]);
+  const i = e.mode === "door" ? jt(t.result) : t.result;
+  if (typeof i != "string" || i === "")
+    throw m("An item names its result by the result's id.", { result: t.result });
+  if (t.run !== void 0 && (typeof t.run != "string" || t.run === ""))
+    throw m("An item's run is the token of the run it holds.", { run: t.run });
+  const { key: s } = t;
+  if (!E(s))
+    throw m(`An item's key is an object, such as { field: "group", value: 3 }.`, { key: s });
+  if (s.field === void 0) {
+    e.unknown(`itemKey.${Object.keys(s).sort()[0] ?? "{}"}`, "The item key form");
+    return;
+  }
+  if (e.fields(s, "itemKey", ["field", "value"]), typeof s.field != "string" || s.field === "")
+    throw m("An item key's field names a field of the result.", { key: s });
+  const { value: a } = s;
+  if (typeof a != "string" && typeof a != "boolean" && !nt(a))
+    throw m("An item key's value is a string, a finite number or a boolean.", { key: s });
+}
+function en(t) {
+  if (typeof t != "string")
+    return !1;
+  if (t.startsWith("data."))
+    return t.length > 5;
+  const e = t.startsWith("results.") ? t.slice(8) : "", i = e.indexOf(".");
+  return i > 0 && i < e.length - 1;
+}
+function tn(t, e) {
+  if (e.fields(t, "threshold", ["kind", "path", "top", "above"]), Ut(t.path), !en(t.path))
+    throw m(`A "threshold" leaf's path is "data.<field>" or "results.<run>.<field>".`, { path: t.path });
+  const i = e.mode === "load" && (t.percentile !== void 0 || t.z !== void 0), s = [t.top, t.above].filter((a) => a !== void 0).length;
+  if (s !== 1 && !(i && s === 0))
+    throw m('A "threshold" leaf has exactly one cut: top or above.', { top: t.top, above: t.above });
+  if (t.top !== void 0 && (!Number.isInteger(t.top) || t.top < 0))
+    throw m(`A "threshold" leaf's top is a whole number of elements.`, { top: t.top });
+  if (t.above !== void 0 && !nt(t.above))
+    throw m(`A "threshold" leaf's above is a finite number.`, { above: t.above });
+}
+const sn = ["data", "results"];
+function Ut(t) {
+  if (typeof t != "string" || t === "")
+    return;
+  const e = t.split(".")[0];
+  if (!sn.includes(e))
+    throw m(
+      `A field path starts with "data." or "results.", so "${t}" is refused: the root "${e}" is reserved.`,
+      {
+        path: t,
+        root: e,
+        reason: "reserved-root"
+      }
+    );
+}
+function Tt(t, e) {
+  e.mode === "door" && Ut(t);
+}
+function st(t, e) {
+  if (!E(t) || typeof t.kind != "string")
+    throw m("A rule tree node is an object with a kind.", { node: t });
+  const { kind: i } = t, s = (a) => {
+    e.fields(t, i, ["kind", ...a]);
+  };
+  switch (i) {
+    case "expression":
+    case "edges":
+      s(["where"]), ze(t.where, `An "${i}" leaf`);
+      return;
+    case "range":
+      s(["attribute", "min", "max"]), ze(t.attribute, `A "range" leaf's attribute`), Tt(t.attribute, e), Pt(t);
+      return;
+    case "categories":
+      if (s(["attribute", "values"]), ze(t.attribute, `A "categories" leaf's attribute`), Tt(t.attribute, e), !Array.isArray(t.values) || !t.values.every((a) => typeof a == "string"))
+        throw m(`A "categories" leaf's values are a list of strings.`, { values: t.values });
+      return;
+    case "degree":
+      if (s(["min", "max", "direction"]), Pt(t), t.direction !== void 0 && !Zs.includes(t.direction))
+        throw m(`A "degree" leaf's direction is "in", "out" or "all".`, { direction: t.direction });
+      return;
+    case "component":
+      if (s(["id"]), !Number.isInteger(t.id) || t.id < 0)
+        throw m(`A "component" leaf's id is a component number, counting from 0.`, { id: t.id });
+      return;
+    case "neighborhood":
+      if (s(["seeds", "depth"]), it(t.seeds, `A "neighborhood" leaf's seeds`), !Number.isInteger(t.depth) || t.depth < 0)
+        throw m(`A "neighborhood" leaf's depth is a whole number of hops, from 0.`, { depth: t.depth });
+      return;
+    case "member":
+      s(["of"]), Kt(t.of, e);
+      return;
+    case "item":
+      s(["item"]), Xs(t.item, e);
+      return;
+    case "threshold":
+      tn(t, e);
+      return;
+    case "all":
+    case "any":
+      if (s(["of"]), !Array.isArray(t.of))
+        throw m(`An "${i}" node's operands are a list.`, { of: t.of });
+      for (const a of t.of)
+        st(a, e);
+      return;
+    case "not":
+      s(["of"]), st(t.of, e);
+      return;
+    default:
+      e.unknown(i, "The rule leaf kind");
+  }
+}
+function nn(t, e) {
+  return t === "visible" ? "clipped" : E(t) ? E(t.define) ? t.define.kind === "path" ? "listed" : typeof t.define.reading == "string" ? t.define.reading : "induced" : typeof t.set == "string" ? e?.(t.set) ?? "induced" : "induced" : "induced";
+}
+function pt(t, e, i) {
+  if (!E(t))
+    return !1;
+  switch (t.kind) {
+    case "edges":
+      return !0;
+    case "member":
+      return nn(t.of, e) !== "induced";
+    case "item": {
+      const s = E(t.item) ? t.item : {}, a = E(s.key) ? s.key : {}, d = jt(s.result);
+      return typeof d == "string" && typeof a.field == "string" && i?.(`results.${d}.${a.field}`).includes("edge") === !0;
+    }
+    case "threshold":
+      return typeof t.path == "string" && i?.(t.path).includes("edge") === !0;
+    case "all":
+    case "any":
+      return Array.isArray(t.of) && t.of.some((s) => pt(s, e, i));
+    case "not":
+      return pt(t.of, e, i);
+    default:
+      return !1;
+  }
+}
+function on() {
+  return m(
+    `An induced set derives its edges from its nodes, so this rule's edge-speaking leaf would be ignored. Read it "clipped" or "listed" instead.`,
+    { reason: "induced-edge-leaf" }
+  );
+}
+function Kt(t, e) {
+  if (typeof t == "string") {
+    Js.includes(t) || e.unknown(t, "The scope keyword");
+    return;
+  }
+  if (!E(t))
+    throw m(
+      'A scope is "visible", "graph", "selection", "largest-component", { set }, { where }, { nodes } or { define }.',
+      {
+        scope: t
+      }
+    );
+  if (t.set !== void 0) {
+    if (e.fields(t, "set", ["set"]), typeof t.set != "string" || t.set === "")
+      throw m("A { set } scope names a set by its id.", { scope: t });
+  } else t.where !== void 0 ? (e.fields(t, "where", ["where"]), ze(t.where, "A { where } scope")) : t.nodes !== void 0 ? (e.fields(t, "nodes", ["nodes"]), it(t.nodes, "A { nodes } scope")) : t.define !== void 0 ? (e.fields(t, "define", ["define"]), Yt(t.define, e)) : e.unknown(Object.keys(t).sort()[0] ?? "{}", "The scope form");
+}
+function Lt(t) {
+  if (!Qs.includes(t))
+    throw m(`A set's reading is "induced", "listed" or "clipped".`, { reading: t });
+}
+function Vt(t, e) {
+  const i = new xt(e);
+  return Yt(t, i), i;
+}
+function Yt(t, e) {
+  if (!E(t) || typeof t.kind != "string")
+    throw m('A set definition is an object whose kind is "fixed", "rule" or "path".', { definition: t });
+  switch (t.kind) {
+    case "fixed":
+      if (e.fields(t, "fixed", dt.fixed), it(t.nodes, "A fixed set's nodes"), Lt(t.reading), t.edges !== void 0) {
+        if (!Array.isArray(t.edges))
+          throw m("A fixed set's edges are a list of edge members.", { edges: t.edges });
+        for (const i of t.edges)
+          Ft(i, e);
+      }
+      break;
+    case "rule":
+      if (e.fields(t, "rule", dt.rule), Lt(t.reading), typeof t.where == "string" ? ze(t.where, "A rule") : st(t.where, e), e.mode === "door" && t.reading === "induced" && pt(t.where))
+        throw on();
+      break;
+    case "path": {
+      e.fields(t, "path", dt.path), it(t.nodes, "A path's nodes");
+      const i = t.nodes;
+      if (i.length === 0)
+        throw m("A path has at least one node; one node is a path of length zero.");
+      if (t.directed !== void 0 && typeof t.directed != "boolean")
+        throw m("A path's directed is true or false.", { directed: t.directed });
+      if (t.edges !== void 0) {
+        if (!Array.isArray(t.edges) || t.edges.length !== i.length - 1)
+          throw m(`A path of ${i.length} nodes names ${i.length - 1} steps' edges, one per step.`, {
+            edges: t.edges
+          });
+        t.edges.forEach((s, a) => {
+          if (s !== null) {
+            if (Array.isArray(s) && s.length === 0)
+              throw m(
+                "A path step's edge group names at least one edge; null means every edge of the pair."
+              );
+            for (const d of Array.isArray(s) ? s : [s])
+              Ft(d, e), an(d, i[a], i[a + 1], a, e);
+          }
+        });
+      }
+      break;
+    }
+    default:
+      e.unknown(t.kind, "The set definition kind");
+  }
+}
+function an(t, e, i, s, a) {
+  const d = t.source === e && t.target === i || t.source === i && t.target === e;
+  if (a.mode === "door" && !d)
+    throw m(
+      `A path's step ${s} names an edge from "${String(t.source)}" to "${String(t.target)}", which does not join its nodes.`,
+      {
+        step: s,
+        edge: t,
+        nodes: [e, i]
+      }
+    );
+}
+function En(t) {
+  return Vt(t, "door"), gt(t);
+}
+function In(t) {
+  const { first: e } = Vt(t, "load"), i = gt(t);
+  return e === void 0 ? { definition: i } : { definition: i, opaque: { first: e } };
+}
+function An(t) {
+  st(t, new xt("door"));
+}
+function Rn(t) {
+  return Kt(t, new xt("door")), E(t) && t.define !== void 0 ? Object.freeze({ define: gt(t.define) }) : t;
+}
+function Cn(t, e) {
+  const i = (s) => {
+    if (!E(s))
+      return s;
+    const a = (c, r) => r === s[c] ? s : { ...s, [c]: r }, d = (c, r) => {
+      if (!Array.isArray(c))
+        return c;
+      const b = c.map(r);
+      return b.every((f, R) => f === c[R]) ? c : b;
+    }, h = (c) => typeof c == "string" || E(c) ? e(c) : c;
+    if (s.define !== void 0)
+      return a("define", i(s.define));
+    if (s.match === "member")
+      return a("of", i(s.of));
+    switch (s.kind) {
+      case "fixed":
+      case "path":
+        return a(
+          "edges",
+          d(s.edges, (c) => Array.isArray(c) ? d(c, h) : h(c))
+        );
+      case "rule":
+        return a("where", i(s.where));
+      case "member":
+        return a("of", i(s.of));
+      case "all":
+      case "any":
+        return a("of", d(s.of, i));
+      case "not":
+        return a("of", i(s.of));
+      default:
+        return s;
+    }
+  };
+  return i(t);
+}
+export {
+  pe as A,
+  fe as B,
+  be as C,
+  ye as D,
+  Qs as E,
+  Se as F,
+  we as G,
+  Ke as H,
+  Ne as K,
+  Vs as L,
+  De as M,
+  Oe as N,
+  yt as P,
+  Me as R,
+  $t as S,
+  xn as U,
+  En as a,
+  bt as b,
+  wn as c,
+  Nn as d,
+  Dn as e,
+  On as f,
+  Mn as g,
+  An as h,
+  In as i,
+  pt as j,
+  on as k,
+  Sn as l,
+  Cn as m,
+  vn as n,
+  Ae as o,
+  Rn as p,
+  Ee as q,
+  nn as r,
+  kn as s,
+  Ce as t,
+  Re as u,
+  ve as v,
+  Ie as w,
+  ge as x,
+  xe as y,
+  ke as z
+};