@graphty/graphty-element 2.3.0 → 2.4.0

package/dist/chunks/scales-B2d-7Bf0.js

@@ -0,0 +1,3220 @@
+import { arfLayout as Le, bfsLayout as Te, bipartiteLayout as We, circularLayout as Ae, createSimulation as _e, seedPositions as Be, resolveNodeVector as Ge, gridLayout as qe, kamadaKawaiLayout as je, multipartiteLayout as Ue, planarLayout as He, radialLayout as Ke, randomLayout as Ve, shellLayout as Ye, spectralLayout as $e, spiralLayout as Je } from "@graphty/layout";
+import { z as i } from "zod/v4";
+import { a as y, S as v, L as fe, k as Ze, W as Qe, l as ke, m as Xe, g as ze } from "./paletteRegistry-A63C71Gn.js";
+import { k as u, j as et } from "./algorithms-BF0X6RPw.js";
+import { forceLink as tt, forceSimulation as it, forceManyBody as st, forceCenter as nt } from "d3-force-3d";
+import { makeMask as xe, maskSet as ue } from "@graphty/graph-format";
+import { C as me, E as at, o as ot } from "./optionsFromZod-BuTOFgVM.js";
+import { G as pe } from "./GraphtyError-B93WRH3e.js";
+import rt from "ngraph.forcelayout";
+import lt from "ngraph.graph";
+import { V as ct, Y as dt, g as ht, I as ut, B as mt, G as pt, d as gt, O as Se, i as Ne, T as De, P as we, C as Oe, h as ft, b as bt, R as yt, a as Me, c as Ee, e as Ie } from "./sequential-Zym81qm7.js";
+const vt = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  scaling: {
+    schema: i.number().positive().default(1),
+    meta: {
+      label: "Scaling",
+      description: "Scale factor for the attractive force",
+      step: 0.1
+    }
+  },
+  a: {
+    schema: i.number().positive().default(1.1),
+    meta: {
+      label: "Attraction Ratio",
+      description: "Ratio of attraction to repulsion",
+      step: 0.1,
+      advanced: !0
+    }
+  },
+  maxIter: {
+    schema: i.number().int().positive().default(1e3),
+    meta: {
+      label: "Max Iterations",
+      description: "Maximum number of iterations"
+    }
+  },
+  seed: {
+    schema: i.number().positive().nullable().default(null),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible layout",
+      advanced: !0
+    }
+  }
+}), xt = i.strictObject({
+  ...v.shape,
+  pos: i.record(i.number(), i.array(i.number())).or(i.null()).default(null),
+  scaling: i.number().positive().default(1),
+  a: i.number().positive().default(1.1),
+  maxIter: i.number().positive().default(1e3),
+  seed: i.number().positive().or(i.null()).default(null)
+}), k = class k extends y {
+  /**
+   * Create an ARF layout engine
+   * @param opts - Configuration options for the ARF algorithm
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 100, this.config = xt.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), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = Le(
+      { nodes: e, edges: t },
+      this.config.pos,
+      this.config.scaling,
+      this.config.a,
+      this.config.maxIter,
+      this.config.seed
+    );
+  }
+};
+k.type = "arf", k.maxDimensions = 2, k.zodOptionsSchema = vt;
+let K = k;
+const St = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(20),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  start: {
+    schema: i.union([i.string(), i.number()]),
+    meta: {
+      label: "Start Node",
+      description: "Starting node for BFS traversal"
+    }
+  },
+  align: {
+    schema: i.enum(["vertical", "horizontal"]).default("vertical"),
+    meta: {
+      label: "Alignment",
+      description: "Direction of BFS tree expansion"
+    }
+  },
+  scale: {
+    schema: i.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the layout",
+      step: 0.1
+    }
+  }
+}), Nt = i.strictObject({
+  ...v.shape,
+  start: i.number().or(i.string()),
+  align: i.enum(["vertical", "horizontal"]).default("vertical"),
+  scale: i.number().positive().default(1),
+  center: i.array(i.number()).length(2).or(i.null()).default(null)
+}), z = class z extends y {
+  /**
+   * Create a BFS layout engine
+   * @param opts - Configuration options including start node and alignment
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 20, this.config = Nt.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), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = Te(
+      { nodes: e, edges: t },
+      this.config.start,
+      this.config.align,
+      this.config.scale,
+      this.config.center
+    );
+  }
+};
+z.type = "bfs", z.maxDimensions = 2, z.zodOptionsSchema = St;
+let V = z;
+const Dt = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(40),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  align: {
+    schema: i.enum(["vertical", "horizontal"]).default("vertical"),
+    meta: {
+      label: "Alignment",
+      description: "Direction of bipartite partitions"
+    }
+  },
+  scale: {
+    schema: i.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the layout",
+      step: 0.1
+    }
+  },
+  aspectRatio: {
+    schema: i.number().positive().default(4 / 3),
+    meta: {
+      label: "Aspect Ratio",
+      description: "Width to height ratio",
+      step: 0.1
+    }
+  }
+}), wt = i.strictObject({
+  ...v.shape,
+  nodes: i.array(i.number().or(i.string())),
+  align: i.enum(["vertical", "horizontal"]).default("vertical"),
+  scale: i.number().positive().default(1),
+  center: i.array(i.number()).length(2).or(i.null()).default(null),
+  aspectRatio: i.number().positive().default(4 / 3)
+}), F = class F extends y {
+  /**
+   * Create a bipartite layout engine
+   * @param opts - Configuration options including node partitions and alignment
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 40, this.config = wt.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), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = We(
+      { nodes: e, edges: t },
+      this.config.nodes,
+      this.config.align,
+      this.config.scale,
+      this.config.center,
+      this.config.aspectRatio
+    );
+  }
+};
+F.type = "bipartite", F.maxDimensions = 2, F.zodOptionsSchema = Dt;
+let Y = F;
+const Ot = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  scale: {
+    schema: i.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the circular layout radius",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: i.number().int().min(2).max(3).default(2),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  }
+}), Mt = i.strictObject({
+  ...v.shape,
+  scale: i.number().positive().default(1),
+  center: i.array(i.number()).min(2).max(3).or(i.null()).default(null),
+  dim: i.number().default(2)
+}), P = class P extends y {
+  /**
+   * Create a circular layout engine
+   * @param opts - Configuration options including scale and dimensions
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 80, this.config = Mt.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), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = Ae({ nodes: e, edges: t }, this.config.scale, this.config.center, this.config.dim);
+  }
+};
+P.type = "circular", P.maxDimensions = 3, P.zodOptionsSchema = Ot;
+let $ = P;
+const Et = u({
+  alphaMin: {
+    schema: i.number().positive().default(0.1),
+    meta: {
+      label: "Alpha Min",
+      description: "Minimum alpha before simulation stops",
+      step: 0.01,
+      advanced: !0
+    }
+  },
+  alphaTarget: {
+    schema: i.number().min(0).default(0),
+    meta: {
+      label: "Alpha Target",
+      description: "Target alpha value",
+      step: 0.01,
+      advanced: !0
+    }
+  },
+  alphaDecay: {
+    schema: i.number().positive().default(0.0228),
+    meta: {
+      label: "Alpha Decay",
+      description: "Rate of alpha decay per tick",
+      step: 1e-3,
+      advanced: !0
+    }
+  },
+  velocityDecay: {
+    schema: i.number().positive().default(0.4),
+    meta: {
+      label: "Velocity Decay",
+      description: "Velocity damping factor",
+      step: 0.05
+    }
+  }
+});
+function ge(n) {
+  return typeof n == "object" && n !== null && "index" in n && typeof n.index == "number" && "x" in n && typeof n.x == "number" && "y" in n && typeof n.y == "number" && "z" in n && typeof n.z == "number" && "vx" in n && typeof n.vx == "number" && "vy" in n && typeof n.vy == "number" && "vz" in n && typeof n.vz == "number";
+}
+const It = i.strictObject({
+  alphaMin: i.number().positive().default(0.1),
+  alphaTarget: i.number().min(0).default(0),
+  alphaDecay: i.number().positive().default(0.0228),
+  velocityDecay: i.number().positive().default(0.4)
+});
+function Ct(n) {
+  return !!(typeof n == "object" && n !== null && Object.hasOwn(n, "index") && "index" in n && typeof n.index == "number" && "source" in n && ge(n.source) && "target" in n && ge(n.target));
+}
+const L = class L extends fe {
+  /**
+   * 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 t = It.parse(e);
+    this.d3AlphaMin = t.alphaMin, this.d3AlphaTarget = t.alphaTarget, this.d3AlphaDecay = t.alphaDecay, this.d3VelocityDecay = t.velocityDecay;
+    const s = tt();
+    s.strength(0.9), this.d3ForceLayout = it().numDimensions(3).alpha(1).force("link", s).force("charge", st()).force("center", nt()).force("dagRadial", null).stop(), this.d3ForceLayout.force("link").id((o) => o.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 o = s[0], r = s[1];
+        if (!ge(r))
+          throw new Error("Internal error: Node is not settled as a complete D3 Node");
+        this.nodeMapping.set(o, r);
+      }
+      this.newNodeMap.clear();
+      let t = [...this.edgeMapping.values()];
+      t = t.concat([...this.newEdgeMap.values()]), this.d3ForceLayout.force("link").links(t);
+      for (const s of this.newEdgeMap.entries()) {
+        const o = s[0], r = s[1];
+        if (!Ct(r))
+          throw new Error("Internal error: Edge is not settled as a complete D3 Edge");
+        this.edgeMapping.set(o, r);
+      }
+      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, t] of this.nodeMapping)
+      this.writeNodePosition(e, t.x, t.y, t.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 t = this._getMappedNode(e), s = { x: 0, y: 0, z: 0 };
+    return this.writeNodePosition(e, t.x, t.y, t.z), this.readNodePosition(e, s) ? s : {
+      x: t.x,
+      y: t.y,
+      z: t.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, t) {
+    const s = this._getMappedNode(e);
+    s.x = t.x, s.y = t.y, s.z = t.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 t = this._getMappedEdge(e);
+    return {
+      src: {
+        x: t.source.x,
+        y: t.source.y,
+        z: t.source.z
+      },
+      dst: {
+        x: t.target.x,
+        y: t.target.y,
+        z: t.target.z
+      }
+    };
+  }
+  /**
+   * Pin a node to its current position
+   * @param n - The node to pin
+   */
+  pin(e) {
+    const t = this._getMappedNode(e);
+    t.fx = t.x, t.fy = t.y, t.fz = t.z;
+  }
+  /**
+   * Unpin a node to allow it to move freely
+   * @param n - The node to unpin
+   */
+  unpin(e) {
+    const t = this._getMappedNode(e);
+    t.fx = void 0, t.fy = void 0, t.fz = void 0, this.reheat = !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 t of this.nodeEdges(e))
+      this.removeEdge(t);
+    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 t = [];
+    for (const s of [...this.edgeMapping.keys(), ...this.newEdgeMap.keys()])
+      (s.srcId === e.id || s.dstId === e.id) && t.push(s);
+    return t;
+  }
+  /**
+   * 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 t = this.nodeMapping.get(e);
+    if (!t)
+      throw new Error("Internal error: Node not found in D3GraphEngine");
+    return t;
+  }
+  _getMappedEdge(e) {
+    this.refresh();
+    const t = this.edgeMapping.get(e);
+    if (!t)
+      throw new Error("Internal error: Edge not found in D3GraphEngine");
+    return t;
+  }
+};
+L.type = "d3", L.maxDimensions = 3, L.zodOptionsSchema = Et;
+let J = L;
+const Rt = u({
+  dim: {
+    schema: i.number().int().min(2).max(3).default(3),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  }
+}), kt = i.strictObject({
+  ...v.shape,
+  dim: i.number().default(3)
+}), T = class T extends y {
+  /**
+   * Create a fixed layout engine
+   * @param opts - Configuration options including dimensions
+   */
+  constructor(e = {}) {
+    super(e), this.scalingFactor = 1, this.config = kt.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 t of this._nodes) {
+      const o = t.data.position;
+      let r;
+      o ? r = [o.x ?? 0, o.y ?? 0, o.z ?? 0] : r = [0, 0, 0], e[t.id] = r, t.mesh.position.set(r[0], r[1], r[2]);
+    }
+    this.positions = e;
+  }
+};
+T.type = "fixed", T.maxDimensions = 3, T.zodOptionsSchema = Rt;
+let Z = T;
+const zt = 25e4, Ft = 4;
+function Pt(n, e, t) {
+  return n !== null ? n : t > zt ? e * Ft : e;
+}
+function Lt(n, e) {
+  if (n == null || typeof n == "string")
+    return null;
+  const t = e.outDegree();
+  return Ge(n, e, (s) => t[s] + 1);
+}
+const Tt = 1e-6;
+function Wt(n, e, t, s = null) {
+  let o = 0, r = 0, c = 0, l = 0;
+  for (let d = 0; d < e; d += 1) {
+    const S = n[3 * d], N = n[3 * d + 1], p = n[3 * d + 2];
+    Number.isFinite(S) && Number.isFinite(N) && Number.isFinite(p) && s?.(d) !== !0 && (o += 1, r += S, c += N, l += p);
+  }
+  if (o === 0)
+    return { scale: 1, centre: [0, 0, 0], placed: o };
+  r /= o, c /= o, l /= o;
+  let a = 0;
+  for (let d = 0; d < e; d += 1) {
+    if (s?.(d) === !0)
+      continue;
+    const S = n[3 * d] - r, N = n[3 * d + 1] - c, p = n[3 * d + 2] - l, g = S * S + N * N + p * p;
+    Number.isFinite(g) && g > a && (a = g);
+  }
+  const h = Math.sqrt(a);
+  return { scale: h > Tt ? t / h : 1, centre: [r, c, l], placed: o };
+}
+function At(n) {
+  return n == null ? [0, 0, 0] : [
+    n.length > 0 ? n[0] : 0,
+    n.length > 1 ? n[1] : 0,
+    n.length > 2 ? n[2] : 0
+  ];
+}
+const _t = {
+  forceatlas2: "forceAtlas2",
+  fruchtermanReingold: "fruchtermanReingold",
+  spring: "fruchtermanReingold",
+  "spring-electrical": "springElectrical"
+};
+function Bt() {
+  return new pe({
+    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"
+  });
+}
+class be extends fe {
+  #I;
+  #N = me;
+  #t;
+  #h;
+  #C;
+  #n;
+  /**
+   * 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.
+   */
+  #D = { src: { x: 0, y: 0, z: 0 }, dst: { x: 0, y: 0, z: 0 } };
+  #e = 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.
+   */
+  #w = null;
+  #u = !1;
+  #o = null;
+  #p = null;
+  #g = 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.
+   */
+  #l = null;
+  /** What a simulation-unit offset from {@link SimulationLayoutEngine.#simCentre} is multiplied by. */
+  #f = 1;
+  /** The arrangement's centre at the last publish, in the simulation's own units. */
+  #i = [0, 0, 0];
+  /** Where the element expects the arrangement's centre to be, in scene units. */
+  #s;
+  /**
+   * 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`.
+   */
+  #c = /* @__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.
+  #O = /* @__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}.
+   */
+  #d = 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.
+   */
+  #R = /* @__PURE__ */ new WeakSet();
+  #r = !1;
+  /** The simulation whose failure has already been reported; see `#onError`. */
+  #k = null;
+  /**
+   * Ends the controller's work span while an accelerated simulation is being stepped, or null
+   * when no span is open. See `#syncWork`.
+   */
+  #b = null;
+  /** Batches submitted and not yet landed or rejected. See `#syncWork`. */
+  #y = 0;
+  /** Set by `LayoutManager` while it is not stepping this layout. See {@link paused}. */
+  #M = !1;
+  #m = 1;
+  #v = 0;
+  /**
+   * 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(e) {
+    super();
+    const t = e;
+    if (t.controller === void 0 || t.type === void 0)
+      throw Bt();
+    this.simulationType = t.type, this.#I = t.layoutType ?? t.type, this.capability = _t[t.type], this.#t = t.options, this.#h = t.controller, this.#C = t.report, this.#n = t.dataManager, this.#s = At(this.#t.model.center ?? this.#t.center), this.#i[0] = this.#s[0], this.#i[1] = this.#s[1], this.#i[2] = this.#s[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 this.#I;
+  }
+  /**
+   * 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 this.#e;
+  }
+  /**
+   * Whether the running simulation is the accelerator's rather than the CPU's.
+   * @returns True when the accelerator built it.
+   */
+  get isAccelerated() {
+    return this.#u;
+  }
+  /**
+   * 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 this.#N;
+  }
+  /**
+   * 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 this.#v;
+  }
+  /**
+   * 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 this.#d === null ? null : this.#d.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 this.#g === null ? xe(0) : this.#g.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(e) {
+    return e !== this.#w;
+  }
+  /**
+   * 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 e = this.#n.getSnapshot();
+    return this.load(e, this.#n.positions.view(e.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(e, t) {
+    this.#e?.dispose(), this.#e = null, this.#a(), this.#o = e, this.#p = t, this.#E(e.nodeCount, t), this.#P();
+  }
+  /**
+   * 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(e, t) {
+    if (this.#o === null)
+      return;
+    const s = this.#e;
+    this.#o = e, this.#p = t;
+    const o = this.#E(e.nodeCount, t), r = this.#h.plan({ capability: this.capability, nodeCount: e.nodeCount }), c = this.#d !== null;
+    if (s === null || r.accelerated !== this.#u || c) {
+      this.replaceSimulation();
+      return;
+    }
+    this.#m = this.#T(e.nodeCount), this.#L(e, o), s.load(this.#n.undirected(e).snapshot, o), this.#F();
+  }
+  /**
+   * 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 (this.#e?.dispose(), this.#e = null, this.#a(), this.#o === null || this.#p === null) {
+      this.#r = !1;
+      return;
+    }
+    try {
+      this.#P();
+    } catch (e) {
+      throw this.#r = !0, e;
+    }
+  }
+  /**
+   * 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 e = this.#e;
+    if (e === null || this.#r)
+      return;
+    this.#v += this.#m;
+    const t = e.step(this.#m);
+    this.#a(), t !== void 0 && !this.#R.has(t) && (this.#R.add(t), this.#y += 1, t.then(
+      () => {
+        this.#y -= 1, this.#a();
+      },
+      (s) => {
+        this.#y -= 1, this.#_(s, e);
+      }
+    ));
+  }
+  /**
+   * 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(e) {
+    if (!(this.#e === null || this.#r)) {
+      this.#v += e, this.#a();
+      try {
+        await this.#e.step(e);
+      } finally {
+        this.#a();
+      }
+    }
+  }
+  /**
+   * 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 this.#M;
+  }
+  /**
+   * Tells the bridge whether the manager is stepping it.
+   * @param value - True when the manager has stopped stepping this layout.
+   */
+  set paused(e) {
+    this.#M = e, e && this.#a();
+  }
+  /**
+   * 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 e = this.#e;
+    typeof e?.reheat == "function" && e.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(e) {
+    this.#O.add(e), this.#x(e.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(e, t) {
+    this.#O.delete(e), this.#x(e.index, t || e.isPinned());
+  }
+  /**
+   * Fixes a pinned node in the simulation. The store already holds the pin.
+   * @param n - The node that was pinned.
+   */
+  pin(e) {
+    this.#x(e.index, !0);
+  }
+  /**
+   * Releases a node the simulation was holding fixed.
+   * @param n - The node that was unpinned.
+   */
+  unpin(e) {
+    this.#x(e.index, !1);
+  }
+  /**
+   * 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(e, t) {
+    const s = t.z ?? 0;
+    if (!this.#S(e.index) || !Number.isFinite(t.x) || !Number.isFinite(t.y) || !Number.isFinite(s))
+      return;
+    this.writeNodePosition(e, t.x, t.y, s, "placement");
+    const o = this.#f;
+    this.#e?.setPosition(
+      e.index,
+      (t.x - this.#s[0]) / o + this.#i[0],
+      (t.y - this.#s[1]) / o + this.#i[1],
+      (s - this.#s[2]) / o + this.#i[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(e) {
+    const t = { x: 0, y: 0, z: 0 };
+    return this.readNodePosition(e, t), t;
+  }
+  /**
+   * 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(e) {
+    return this.#z(e.srcNode, this.#D.src), this.#z(e.dstNode, this.#D.dst), this.#D;
+  }
+  /**
+   * 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.
+   */
+  #z(e, t) {
+    this.readNodePosition(e, t) || (t.x = 0, t.y = 0, t.z = 0);
+  }
+  /**
+   * 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 this.#n.nodes.values();
+  }
+  /**
+   * Every edge of the graph; see {@link SimulationLayoutEngine.nodes}.
+   * @returns The graph's live edge collection.
+   */
+  get edges() {
+    return this.#n.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 this.#e?.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 e = this.#o, t = this.#l;
+    if (e === null || t === null)
+      return;
+    const s = this.#n.positions, o = this.#c.size === 0 ? null : (a) => this.#c.has(a) && s.isPlaced(a), r = Wt(t, e.nodeCount, this.#t.scalingFactor, o);
+    r.placed > 0 && (this.#f = r.scale, this.#i[0] = r.centre[0], this.#i[1] = r.centre[1], this.#i[2] = r.centre[2]);
+    const c = this.#f, l = this.#i;
+    for (const a of this.nodes) {
+      const h = a.index;
+      if (!this.#S(h))
+        continue;
+      const d = s.isPlaced(h);
+      d && this.#c.has(h) || this.writeNodePosition(
+        a,
+        (t[3 * h] - l[0]) * c + this.#s[0],
+        (t[3 * h + 1] - l[1]) * c + this.#s[1],
+        (t[3 * h + 2] - l[2]) * c + this.#s[2],
+        d ? "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() {
+    this.#e?.dispose(), this.#e = null, this.#a();
+  }
+  /**
+   * 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.
+   */
+  #a() {
+    const e = this.#u && this.#e !== null && !this.#r && !this.isSettled && !(this.#M && this.#y === 0);
+    if (e !== (this.#b !== null)) {
+      if (e) {
+        this.#b = this.#h.beginWork();
+        return;
+      }
+      this.#b?.(), this.#b = null;
+    }
+  }
+  /**
+   * Packs the store's pin lane 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.
+   */
+  #F() {
+    const e = this.#o, t = this.#e;
+    if (e === null || t === null)
+      return;
+    const { nodeCount: s } = e, o = this.#n.positions.pinnedView(s), r = xe(s), c = /* @__PURE__ */ new Set();
+    for (let l = 0; l < s; l += 1)
+      o[l] === 1 && (ue(r, l, !0), c.add(l));
+    for (const l of this.#O)
+      this.#S(l.index) && (ue(r, l.index, !0), c.add(l.index));
+    this.#g = r, this.#c = c, t.setFixed(r);
+  }
+  /**
+   * Plans, builds and loads a simulation over the snapshot this bridge is holding.
+   * @throws Whatever `plan()` or `createSimulation` throws.
+   */
+  #P() {
+    const e = this.#o, t = this.#p;
+    if (e === null || t === null)
+      return;
+    const s = this.#l, o = s !== null && s.length === 3 * e.nodeCount ? s : this.#E(e.nodeCount, t);
+    this.#w = null, this.#u = !1, this.#N = me;
+    const r = this.#h.plan({ capability: this.capability, nodeCount: e.nodeCount }), c = r.accelerated ? r.accelerator : null;
+    if (!r.accelerated && this.simulationType === "spring-electrical")
+      throw new pe({
+        code: "E_NO_ACCELERATOR",
+        message: `the layout "${this.type}" is computed on a hardware accelerator and has no processor implementation: ${r.reason}`,
+        source: "layout",
+        details: {
+          layout: this.type,
+          reason: r.reason
+        }
+      });
+    const l = this.#n.undirected(e).snapshot;
+    this.#L(e, o), this.#d = this.#W(l), this.#m = this.#T(e.nodeCount), this.#e = _e(
+      this.simulationType,
+      this.#A(),
+      c === null ? null : at(c)
+    ), this.#w = this.#h.accelerator, this.#u = r.accelerated, this.#N = r.accelerated ? r.precision : me, this.#r = !1, this.#v = 0, this.#e.load(l, o), this.#F();
+  }
+  /**
+   * 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.
+   */
+  #W(e) {
+    return Lt(this.#t.model.nodeMass, e);
+  }
+  /**
+   * 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.
+   */
+  #L(e, t) {
+    const { seed: s, dim: o, scale: r, center: c } = this.#t.model;
+    Be(
+      e,
+      t,
+      s ?? null,
+      o ?? this.#t.dim ?? 3,
+      r ?? this.#t.scale ?? 1,
+      c ?? this.#t.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.
+   */
+  #E(e, t) {
+    const s = 3 * e, o = this.#l !== null && this.#l.length === s ? this.#l : new Float32Array(s), r = this.#f;
+    for (let c = 0; c < e; c += 1)
+      for (let l = 0; l < 3; l += 1)
+        o[3 * c + l] = (t[3 * c + l] - this.#s[l]) / r + this.#i[l];
+    return this.#l = o, o;
+  }
+  /**
+   * The options handed to `createSimulation`: the common knobs, then the type's own, then the
+   * iteration count this load resolved.
+   * @returns The options object.
+   */
+  #A() {
+    const { model: e, iterationsPerStep: t, stepMultiplier: s, ...o } = this.#t, r = this.#d === null ? {} : { nodeMass: this.#d };
+    return { ...o, ...e, ...r, iterationsPerStep: this.#m };
+  }
+  /**
+   * How many iterations one `step()` submits over the graph this load holds.
+   * @param nodeCount - The graph this load is over.
+   * @returns The iteration count.
+   */
+  #T(e) {
+    const { iterationsPerStep: t, stepMultiplier: s } = this.#t;
+    return Pt(t, s, e);
+  }
+  /**
+   * 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.
+   */
+  #x(e, t) {
+    const s = this.#g, o = this.#e;
+    s === null || o === null || !this.#S(e) || (ue(s, e, t), t ? this.#c.add(e) : this.#c.delete(e), o.setFixed(s));
+  }
+  /**
+   * 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.
+   */
+  #S(e) {
+    return Number.isInteger(e) && e >= 0 && e < (this.#o?.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.
+   */
+  #_(e, t) {
+    this.#k !== t && (this.#k = t, t === this.#e && (this.#r = !0, this.#a()), this.#C(
+      pe.wrap(e, {
+        code: "E_INTERNAL",
+        source: "layout",
+        details: { layoutType: this.type, simulation: this.simulationType }
+      })
+    ));
+  }
+}
+const Gt = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  maxIter: {
+    schema: i.number().int().positive().default(100),
+    meta: {
+      label: "Max Iterations",
+      description: "Maximum number of simulation iterations"
+    }
+  },
+  jitterTolerance: {
+    schema: i.number().positive().default(1),
+    meta: {
+      label: "Jitter Tolerance",
+      description: "Tolerance for position jitter",
+      step: 0.1,
+      advanced: !0
+    }
+  },
+  scalingRatio: {
+    schema: i.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: i.number().nonnegative().default(1),
+    meta: {
+      label: "Gravity",
+      description: "Strength of center gravity",
+      step: 0.1
+    }
+  },
+  distributedAction: {
+    schema: i.boolean().default(!1),
+    meta: {
+      label: "Distributed Action",
+      description: "Use distributed attraction for hubs",
+      advanced: !0
+    }
+  },
+  strongGravity: {
+    schema: i.boolean().default(!1),
+    meta: {
+      label: "Strong Gravity",
+      description: "Use stronger gravity to prevent escape",
+      advanced: !0
+    }
+  },
+  dissuadeHubs: {
+    schema: i.boolean().default(!1),
+    meta: {
+      label: "Dissuade Hubs",
+      description: "Push hubs away from each other",
+      advanced: !0
+    }
+  },
+  linlog: {
+    schema: i.boolean().default(!1),
+    meta: {
+      label: "LinLog Mode",
+      description: "Use logarithmic attraction",
+      advanced: !0
+    }
+  },
+  seed: {
+    schema: i.number().nullable().default(null),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible layout",
+      advanced: !0
+    }
+  },
+  dim: {
+    schema: i.number().int().min(2).max(3).default(2),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  },
+  weighted: {
+    schema: i.boolean().default(!0),
+    meta: {
+      label: "Use Edge Weights",
+      description: "Pull strongly connected nodes closer together"
+    }
+  },
+  nodeMass: {
+    schema: i.record(i.string(), i.number()).or(i.string()).or(i.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
+    }
+  }
+}), D = class D extends be {
+  /**
+   * 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 };
+  }
+};
+D.type = "forceatlas2", D.simulationType = "forceatlas2", D.maxDimensions = 3, D.honoursWeights = !0, D.zodOptionsSchema = Gt;
+let Q = D;
+const qt = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  columns: {
+    schema: i.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: i.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Half the length of the grid's longer side",
+      step: 0.1
+    }
+  }
+}), jt = i.strictObject({
+  ...v.shape,
+  columns: i.number().int().positive().nullable().default(null),
+  scale: i.number().positive().default(1),
+  center: i.array(i.number()).length(2).or(i.null()).default(null)
+}), W = class W extends y {
+  /**
+   * Create a grid layout engine
+   * @param opts - Configuration options including the column count
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 100, this.config = jt.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), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = qe({ nodes: e, edges: t }, this.config.columns, this.config.scale, this.config.center);
+  }
+};
+W.type = "grid", W.maxDimensions = 2, W.zodOptionsSchema = qt;
+let X = W;
+const Ut = "weight", Ht = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(50),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  scale: {
+    schema: i.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the layout",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: i.number().int().min(2).max(3).default(3),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  },
+  weighted: {
+    schema: i.boolean().default(!0),
+    meta: {
+      label: "Use Edge Weights",
+      description: "Place strongly connected nodes closer together"
+    }
+  }
+}), Kt = i.strictObject({
+  ...v.shape,
+  dist: i.record(i.number(), i.record(i.number(), i.number())).or(i.null()).default(null),
+  pos: i.record(i.number(), i.array(i.number()).min(1).max(3)).or(i.null()).default(null),
+  weighted: i.boolean().default(!0),
+  scale: i.number().positive().default(1),
+  center: i.array(i.number()).min(2).max(3).or(i.null()).default(null),
+  dim: i.number().default(3)
+}), M = class M extends y {
+  /**
+   * Create a Kamada-Kawai layout engine
+   * @param opts - Configuration options including scale and dimensions
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 50, this.config = Kt.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((r) => r.id), edges: () => this._edges.map((r) => [r.srcId, r.dstId]) }, o = this.config.weighted ? this.pairWeights(this._edges) : null;
+    o !== null && (this.reportClampedWeights("kamada-kawai", o), s.getEdgeData = (r, c) => {
+      const l = o.get(Ze(r, c));
+      if (l !== void 0)
+        return 1 / Math.max(l, Qe);
+    }), this.positions = je(
+      s,
+      this.config.dist,
+      this.config.pos,
+      Ut,
+      this.config.scale,
+      this.config.center,
+      this.config.dim
+    );
+  }
+};
+M.type = "kamada-kawai", M.maxDimensions = 3, M.honoursWeights = !0, M.zodOptionsSchema = Ht;
+let ee = M;
+const Vt = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(40),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  align: {
+    schema: i.enum(["vertical", "horizontal"]).default("vertical"),
+    meta: {
+      label: "Alignment",
+      description: "Direction of multipartite partitions"
+    }
+  },
+  scale: {
+    schema: i.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the layout",
+      step: 0.1
+    }
+  }
+}), Yt = i.strictObject({
+  ...v.shape,
+  // subsetKey: z.string().or(z.record(z.number(), z.array(z.string().or(z.number())))),
+  subsetKey: i.record(i.string(), i.array(i.string().or(i.number()))),
+  align: i.enum(["vertical", "horizontal"]).default("vertical"),
+  scale: i.number().positive().default(1),
+  center: i.array(i.number()).length(2).or(i.null()).default(null)
+}), A = class A extends y {
+  /**
+   * Create a multipartite layout engine
+   * @param opts - Configuration options including subset keys and alignment
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 40, this.config = Yt.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), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = Ue(
+      { nodes: e, edges: t },
+      this.config.subsetKey,
+      this.config.align,
+      this.config.scale,
+      this.config.center
+    );
+  }
+};
+A.type = "multipartite", A.maxDimensions = 2, A.zodOptionsSchema = Vt;
+let te = A;
+var C = { exports: {} }, Ce;
+function $t() {
+  if (Ce) return C.exports;
+  Ce = 1, C.exports = n, C.exports.random = n, C.exports.randomIterator = l;
+  function n(a) {
+    var h = typeof a == "number" ? a : +/* @__PURE__ */ new Date();
+    return new e(h);
+  }
+  function e(a) {
+    this.seed = a;
+  }
+  e.prototype.next = c, e.prototype.nextDouble = r, e.prototype.uniform = r, e.prototype.gaussian = t, e.prototype.random = r;
+  function t() {
+    var a, h, d;
+    do
+      h = this.nextDouble() * 2 - 1, d = this.nextDouble() * 2 - 1, a = h * h + d * d;
+    while (a >= 1 || a === 0);
+    return h * Math.sqrt(-2 * Math.log(a) / a);
+  }
+  e.prototype.levy = s;
+  function s() {
+    var a = 1.5, h = Math.pow(
+      o(1 + a) * Math.sin(Math.PI * a / 2) / (o((1 + a) / 2) * a * Math.pow(2, (a - 1) / 2)),
+      1 / a
+    );
+    return this.gaussian() * h / Math.pow(Math.abs(this.gaussian()), 1 / a);
+  }
+  function o(a) {
+    return Math.sqrt(2 * Math.PI / a) * Math.pow(1 / Math.E * (a + 1 / (12 * a - 1 / (10 * a))), a);
+  }
+  function r() {
+    var a = this.seed;
+    return a = a + 2127912214 + (a << 12) & 4294967295, a = (a ^ 3345072700 ^ a >>> 19) & 4294967295, a = a + 374761393 + (a << 5) & 4294967295, a = (a + 3550635116 ^ a << 9) & 4294967295, a = a + 4251993797 + (a << 3) & 4294967295, a = (a ^ 3042594569 ^ a >>> 16) & 4294967295, this.seed = a, (a & 268435455) / 268435456;
+  }
+  function c(a) {
+    return Math.floor(this.nextDouble() * a);
+  }
+  function l(a, h) {
+    var d = h || n();
+    if (typeof d.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: N,
+      /**
+       * Shuffles array randomly, in place.
+       */
+      shuffle: S
+    };
+    function S() {
+      var p, g, O;
+      for (p = a.length - 1; p > 0; --p)
+        g = d.next(p + 1), O = a[g], a[g] = a[p], a[p] = O;
+      return a;
+    }
+    function N(p) {
+      var g, O, he;
+      for (g = a.length - 1; g > 0; --g)
+        O = d.next(g + 1), he = a[O], a[O] = a[g], a[g] = he, p(he);
+      a.length && p(a[0]);
+    }
+  }
+  return C.exports;
+}
+var Jt = $t();
+const Zt = /* @__PURE__ */ et(Jt), Qt = u({
+  dim: {
+    schema: i.number().int().min(2).max(3).default(3),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  },
+  springLength: {
+    schema: i.number().positive().default(30),
+    meta: {
+      label: "Spring Length",
+      description: "Ideal spring length between connected nodes"
+    }
+  },
+  springCoefficient: {
+    schema: i.number().positive().default(8e-4),
+    meta: {
+      label: "Spring Coefficient",
+      description: "Spring stiffness coefficient",
+      step: 1e-4,
+      advanced: !0
+    }
+  },
+  gravity: {
+    schema: i.number().default(-1.2),
+    meta: {
+      label: "Gravity",
+      description: "Gravity strength (negative for repulsion)",
+      step: 0.1
+    }
+  },
+  theta: {
+    schema: i.number().positive().default(0.8),
+    meta: {
+      label: "Theta",
+      description: "Barnes-Hut approximation parameter",
+      step: 0.1,
+      advanced: !0
+    }
+  },
+  dragCoefficient: {
+    schema: i.number().positive().default(0.02),
+    meta: {
+      label: "Drag Coefficient",
+      description: "Velocity damping coefficient",
+      step: 0.01,
+      advanced: !0
+    }
+  },
+  timeStep: {
+    schema: i.number().positive().default(20),
+    meta: {
+      label: "Time Step",
+      description: "Simulation time step size",
+      advanced: !0
+    }
+  },
+  seed: {
+    schema: i.number().int().positive().nullable().default(null),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible layout",
+      advanced: !0
+    }
+  }
+}), _ = class _ extends fe {
+  /**
+   * 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 = lt();
+    const t = e, s = {
+      dimensions: t.dim !== void 0 ? t.dim : 3
+    };
+    t.springLength !== void 0 && (s.springLength = t.springLength), t.springCoefficient !== void 0 && (s.springCoefficient = t.springCoefficient), t.gravity !== void 0 && (s.gravity = t.gravity), t.theta !== void 0 && (s.theta = t.theta), t.dragCoefficient !== void 0 && (s.dragCoefficient = t.dragCoefficient), t.timeStep !== void 0 && (s.timeStep = t.timeStep), typeof t.seed == "number" && (this.seededPlacement = { rng: Zt(t.seed), dim: s.dimensions }), this.ngraphLayout = rt(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: t } = this.ngraphLayout, s = this.nodeMapping.size, o = s > 0 ? t / s : 0;
+    this._stepCount++, this._lastMoves.push(o), this._lastMoves.length > 10 && this._lastMoves.shift();
+    const r = this._lastMoves.length > 0 ? this._lastMoves.reduce((a, h) => a + h, 0) / this._lastMoves.length : 0, c = 0.05, l = 1e3;
+    this._settled = e || r <= c || this._stepCount >= l, 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, t] of this.nodeMapping) {
+      const s = this.ngraphLayout.getNodePosition(t.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 t = this.ngraph.addNode(e.id, { parentNode: e });
+    if (this.nodeMapping.set(e, t), this.seededPlacement) {
+      const { rng: s, dim: o } = this.seededPlacement, { springLength: r } = this.ngraphLayout.simulator.settings, c = () => (s.nextDouble() - 0.5) * r, l = c(), a = c();
+      this.ngraphLayout.setNodePosition(e.id, l, a, o === 3 ? c() : 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 t = this.ngraph.addLink(e.srcId, e.dstId, { parentEdge: e });
+    this.edgeMapping.set(e, t), 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 t = this._getMappedNode(e), s = this.ngraphLayout.getNodePosition(t.id), o = { x: 0, y: 0, z: 0 };
+    return this.writeNodePosition(e, s.x, s.y, s.z ?? 0), this.readNodePosition(e, o) ? o : 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, t) {
+    const s = this._getMappedNode(e), o = this.ngraphLayout.getNodePosition(s.id);
+    o.x = t.x, o.y = t.y, o.z = t.z, this.writeNodePosition(e, t.x, t.y, t.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 t = this._getMappedEdge(e), s = this.ngraphLayout.getLinkPosition(t.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 t = this._getMappedNode(e);
+    this.ngraphLayout.pinNode(t, !0);
+  }
+  /**
+   * Unpin a node to allow it to move freely
+   * @param n - The node to unpin
+   */
+  unpin(e) {
+    const t = this._getMappedNode(e);
+    this.ngraphLayout.pinNode(t, !1);
+  }
+  /**
+   * 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 t = this.nodeMapping.get(e);
+    if (t) {
+      for (const [s, o] of this.edgeMapping)
+        (o.fromId === t.id || o.toId === t.id) && this.edgeMapping.delete(s);
+      this.ngraph.removeNode(t.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 t = this.edgeMapping.get(e);
+    t && (this.ngraph.removeLink(t), this.edgeMapping.delete(e), this._settled = !1);
+  }
+  _getMappedNode(e) {
+    const t = this.nodeMapping.get(e);
+    if (!t)
+      throw new Error("Internal error: Node not found in NGraphEngine");
+    return t;
+  }
+  _getMappedEdge(e) {
+    const t = this.edgeMapping.get(e);
+    if (!t)
+      throw new Error("Internal error: Edge not found in NGraphEngine");
+    return t;
+  }
+};
+_.type = "ngraph", _.maxDimensions = 3, _.zodOptionsSchema = Qt;
+let ie = _;
+const Xt = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(70),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  scale: {
+    schema: i.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the planar layout",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: i.number().int().min(2).max(2).default(2),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D only for planar)"
+    }
+  },
+  seed: {
+    schema: i.number().nullable().default(null),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible layout",
+      advanced: !0
+    }
+  }
+}), ei = i.strictObject({
+  ...v.shape,
+  scale: i.number().positive().default(1),
+  center: i.array(i.number()).length(2).or(i.null()).default(null),
+  dim: i.number().default(2),
+  seed: i.number().or(i.null()).default(null)
+}), B = class B extends y {
+  /**
+   * Create a planar layout engine
+   * @param opts - Configuration options including scale and seed
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 70, this.config = ei.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), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = He(
+      { nodes: e, edges: t },
+      this.config.scale,
+      this.config.center,
+      this.config.dim,
+      this.config.seed
+    );
+  }
+};
+B.type = "planar", B.maxDimensions = 2, B.zodOptionsSchema = Xt;
+let se = B;
+const ti = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  root: {
+    schema: i.union([i.string(), i.number()]).nullable().default(null),
+    meta: {
+      label: "Root Node",
+      description: "The node at the centre; empty picks the node with the most edges"
+    }
+  },
+  scale: {
+    schema: i.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Radius of the outermost ring",
+      step: 0.1
+    }
+  }
+}), ii = i.strictObject({
+  ...v.shape,
+  root: i.union([i.string(), i.number()]).nullable().default(null),
+  scale: i.number().positive().default(1),
+  center: i.array(i.number()).length(2).or(i.null()).default(null)
+}), G = class G extends y {
+  /**
+   * Create a radial layout engine
+   * @param opts - Configuration options including the root node
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 100, this.config = ii.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), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = Ke({ nodes: e, edges: t }, this.config.root, this.config.scale, this.config.center);
+  }
+};
+G.type = "radial", G.maxDimensions = 2, G.zodOptionsSchema = ti;
+let ne = G;
+const Fe = 1, si = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  dim: {
+    schema: i.number().int().min(2).max(3).default(2),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  },
+  seed: {
+    schema: i.number().positive().nullable().default(Fe),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible random positions",
+      advanced: !0
+    }
+  }
+}), ni = i.strictObject({
+  ...v.shape,
+  center: i.array(i.number()).min(2).max(3).or(i.null()).default(null),
+  dim: i.number().default(2),
+  seed: i.number().positive().or(i.null()).default(Fe)
+}), q = class q extends y {
+  /**
+   * Create a random layout engine
+   * @param opts - Configuration options including dimensions and seed
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 100, this.config = ni.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), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = Ve({ nodes: e, edges: t }, this.config.center, this.config.dim, this.config.seed);
+  }
+};
+q.type = "random", q.maxDimensions = 3, q.zodOptionsSchema = si;
+let ae = q;
+const ai = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  scale: {
+    schema: i.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the shell layout radius",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: i.number().int().min(2).max(2).default(2),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D only for shell)"
+    }
+  }
+}), oi = i.strictObject({
+  ...v.shape,
+  nlist: i.array(i.array(i.number())).or(i.null()).default(null),
+  dim: i.number().default(2),
+  center: i.array(i.number()).length(2).or(i.null()).default(null),
+  scale: i.number().positive().default(1)
+}), j = class j extends y {
+  /**
+   * Create a shell layout engine
+   * @param opts - Configuration options including node lists for each shell
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 100, this.config = oi.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), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = Ye(
+      { nodes: e, edges: t },
+      this.config.nlist,
+      this.config.scale,
+      this.config.center,
+      this.config.dim
+    );
+  }
+};
+j.type = "shell", j.maxDimensions = 2, j.zodOptionsSchema = ai;
+let oe = j;
+const ri = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  scale: {
+    schema: i.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the spectral layout",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: i.number().int().min(2).max(2).default(2),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D only for spectral)"
+    }
+  }
+}), li = i.strictObject({
+  ...v.shape,
+  scale: i.number().positive().default(1),
+  center: i.array(i.number()).length(2).or(i.null()).default(null),
+  dim: i.number().default(2)
+}), U = class U extends y {
+  /**
+   * Create a spectral layout engine
+   * @param opts - Configuration options including scale and center
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 100, this.config = li.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), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = $e({ nodes: e, edges: t }, this.config.scale, this.config.center, this.config.dim);
+  }
+};
+U.type = "spectral", U.maxDimensions = 2, U.zodOptionsSchema = ri;
+let re = U;
+const ci = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(80),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  scale: {
+    schema: i.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the spiral layout",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: i.number().int().min(2).max(2).default(2),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D only for spiral)"
+    }
+  },
+  resolution: {
+    schema: i.number().positive().default(0.35),
+    meta: {
+      label: "Resolution",
+      description: "Controls spacing between spiral turns",
+      step: 0.05,
+      advanced: !0
+    }
+  },
+  equidistant: {
+    schema: i.boolean().default(!1),
+    meta: {
+      label: "Equidistant",
+      description: "Place nodes at equal distances along the spiral",
+      advanced: !0
+    }
+  }
+}), di = i.strictObject({
+  ...v.shape,
+  scale: i.number().positive().default(1),
+  center: i.array(i.number()).length(2).or(i.null()).default(null),
+  dim: i.number().default(2),
+  resolution: i.number().positive().default(0.35),
+  equidistant: i.boolean().default(!1)
+}), H = class H extends y {
+  /**
+   * Create a spiral layout engine
+   * @param opts - Configuration options including resolution and equidistant spacing
+   */
+  constructor(e) {
+    super(e), this.scalingFactor = 80, this.config = di.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), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
+    this.positions = Je(
+      { nodes: e, edges: t },
+      this.config.scale,
+      this.config.center,
+      this.config.dim,
+      this.config.resolution,
+      this.config.equidistant
+    );
+  }
+};
+H.type = "spiral", H.maxDimensions = 2, H.zodOptionsSchema = ci;
+let le = H;
+const hi = u({
+  springLength: {
+    schema: i.number().positive().default(10),
+    meta: {
+      label: "Spring Length",
+      description: "The distance an edge pulls its two nodes towards",
+      step: 1
+    }
+  },
+  springCoefficient: {
+    schema: i.number().positive().default(0.8),
+    meta: {
+      label: "Spring Strength",
+      description: "How hard an edge pulls; Hooke's constant",
+      step: 0.1
+    }
+  },
+  gravity: {
+    schema: i.number().default(-12),
+    meta: {
+      label: "Repulsion",
+      description: "How hard two nodes push each other apart; negative repels",
+      step: 1
+    }
+  },
+  dragCoefficient: {
+    schema: i.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: i.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: i.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the layout",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: i.number().int().min(2).max(3).default(3),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  },
+  seed: {
+    schema: i.number().nullable().default(null),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible layout",
+      advanced: !0
+    }
+  }
+}), E = class E extends be {
+  /**
+   * 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 };
+  }
+};
+E.type = "spring-electrical", E.simulationType = "spring-electrical", E.maxDimensions = 3, E.zodOptionsSchema = hi;
+let ce = E;
+const ui = u({
+  scalingFactor: {
+    schema: i.number().min(1).max(1e3).default(100),
+    meta: {
+      label: "Scaling Factor",
+      description: "Multiplier for node positions"
+    }
+  },
+  k: {
+    schema: i.number().nullable().default(null),
+    meta: {
+      label: "Spring Constant",
+      description: "Optimal distance between nodes (auto-calculated if null)",
+      advanced: !0
+    }
+  },
+  iterations: {
+    schema: i.number().positive().default(50),
+    meta: {
+      label: "Iterations",
+      description: "Number of spring simulation iterations"
+    }
+  },
+  scale: {
+    schema: i.number().positive().default(1),
+    meta: {
+      label: "Scale",
+      description: "Scale factor for the layout",
+      step: 0.1
+    }
+  },
+  dim: {
+    schema: i.number().int().min(2).max(3).default(3),
+    meta: {
+      label: "Dimensions",
+      description: "Layout dimensionality (2D or 3D)"
+    }
+  },
+  seed: {
+    schema: i.number().positive().nullable().default(null),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible layout",
+      advanced: !0
+    }
+  }
+}), I = class I extends be {
+  /**
+   * 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 };
+  }
+};
+I.type = "spring", I.simulationType = "spring", I.maxDimensions = 3, I.zodOptionsSchema = ui;
+let de = I;
+const w = {
+  seed: { type: "seed" }
+};
+function m(n, e = {}) {
+  return ot(n, { overrides: e });
+}
+function f(n, e, t = []) {
+  return {
+    descriptor: {
+      ...n,
+      engine: e.engine,
+      options: e.options,
+      honoursWeights: e.honoursWeights
+    },
+    implementations: [
+      { ...e, isDefault: !0 },
+      ...t.map((s) => ({ ...s, isDefault: !1 }))
+    ]
+  };
+}
+const mi = {
+  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: m(ie.zodOptionsSchema, w),
+  honoursWeights: ie.honoursWeights
+}, pi = {
+  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: m(J.zodOptionsSchema),
+  honoursWeights: J.honoursWeights
+}, gi = {
+  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: m(Q.zodOptionsSchema, w),
+  honoursWeights: Q.honoursWeights
+}, fi = {
+  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: m(de.zodOptionsSchema, w),
+  honoursWeights: de.honoursWeights
+}, bi = {
+  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: m(ce.zodOptionsSchema, w),
+  honoursWeights: ce.honoursWeights,
+  requires: { accelerator: !0 }
+}, yi = {
+  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: m(ee.zodOptionsSchema),
+  honoursWeights: ee.honoursWeights
+}, vi = {
+  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: m(K.zodOptionsSchema, w),
+  honoursWeights: K.honoursWeights
+}, xi = {
+  engine: "circular",
+  plainName: "Circular",
+  technicalName: "Circular layout",
+  kind: "batch",
+  maxDimensions: 3,
+  reason: "The only engine that draws this arrangement.",
+  options: m($.zodOptionsSchema),
+  honoursWeights: $.honoursWeights
+}, Si = {
+  engine: "shell",
+  plainName: "Shell",
+  technicalName: "Shell layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: m(oe.zodOptionsSchema),
+  honoursWeights: oe.honoursWeights
+}, Ni = {
+  engine: "radial",
+  plainName: "Radial",
+  technicalName: "Radial layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: m(ne.zodOptionsSchema),
+  honoursWeights: ne.honoursWeights
+}, Di = {
+  engine: "grid",
+  plainName: "Grid",
+  technicalName: "Grid layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: m(X.zodOptionsSchema),
+  honoursWeights: X.honoursWeights
+}, wi = {
+  engine: "spiral",
+  plainName: "Spiral",
+  technicalName: "Archimedean spiral layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: m(le.zodOptionsSchema),
+  honoursWeights: le.honoursWeights
+}, Oi = {
+  engine: "spectral",
+  plainName: "Spectral",
+  technicalName: "Laplacian eigenvector layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: m(re.zodOptionsSchema),
+  honoursWeights: re.honoursWeights
+}, Mi = {
+  engine: "planar",
+  plainName: "Planar",
+  technicalName: "Planar embedding",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: m(se.zodOptionsSchema, w),
+  honoursWeights: se.honoursWeights
+}, Ei = {
+  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: m(V.zodOptionsSchema),
+  honoursWeights: V.honoursWeights
+}, Ii = {
+  engine: "bipartite",
+  plainName: "Bipartite",
+  technicalName: "Bipartite layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: m(Y.zodOptionsSchema),
+  honoursWeights: Y.honoursWeights
+}, Ci = {
+  engine: "multipartite",
+  plainName: "Multipartite",
+  technicalName: "Multipartite layout",
+  kind: "batch",
+  maxDimensions: 2,
+  reason: "The only engine that draws this arrangement.",
+  options: m(te.zodOptionsSchema),
+  honoursWeights: te.honoursWeights
+}, Ri = {
+  engine: "fixed",
+  plainName: "Fixed",
+  technicalName: "Fixed layout",
+  kind: "batch",
+  maxDimensions: 3,
+  reason: "The only engine that draws this arrangement.",
+  options: m(Z.zodOptionsSchema),
+  honoursWeights: Z.honoursWeights
+}, ki = {
+  engine: "random",
+  plainName: "Random",
+  technicalName: "Random layout",
+  kind: "batch",
+  maxDimensions: 3,
+  reason: "The only engine that draws this arrangement.",
+  options: m(ae.zodOptionsSchema, w),
+  honoursWeights: ae.honoursWeights
+}, ye = [
+  f(
+    {
+      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: []
+    },
+    mi,
+    [pi, gi, fi, yi, bi]
+  ),
+  f(
+    {
+      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: []
+    },
+    vi
+  ),
+  f(
+    {
+      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: []
+    },
+    xi
+  ),
+  f(
+    {
+      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: []
+    },
+    Ni
+  ),
+  f(
+    {
+      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: []
+    },
+    Di
+  ),
+  f(
+    {
+      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"]
+    },
+    Si
+  ),
+  f(
+    {
+      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: []
+    },
+    wi
+  ),
+  f(
+    {
+      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: []
+    },
+    Oi
+  ),
+  f(
+    {
+      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: []
+    },
+    Mi
+  ),
+  f(
+    {
+      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: []
+    },
+    ki
+  ),
+  f(
+    {
+      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"]
+    },
+    Ei
+  ),
+  f(
+    {
+      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"]
+    },
+    Ii
+  ),
+  f(
+    {
+      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"]
+    },
+    Ci
+  ),
+  f(
+    {
+      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: []
+    },
+    Ri
+  )
+], zi = ye.map((n) => n.descriptor), Ui = [];
+function Hi(n) {
+  return zi.find((e) => e.id === n) ?? ke(n)?.descriptor;
+}
+function Ki(n) {
+  return ye.find((e) => e.descriptor.id === n);
+}
+function Vi(n) {
+  const e = ye.find(
+    (t) => t.implementations.some((s) => s.engine === n)
+  );
+  return e !== void 0 ? e.descriptor.id : ke(n)?.descriptor.id;
+}
+const b = ["deuteranopia", "protanopia", "tritanopia"], ve = Object.freeze([
+  {
+    id: "viridis",
+    plainName: "Purple to Yellow",
+    kind: "sequential",
+    colors: ct,
+    capacity: null,
+    colorblindSafe: b
+  },
+  // 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: dt,
+    capacity: null,
+    colorblindSafe: b
+  },
+  {
+    id: "plasma",
+    plainName: "Blue to Yellow",
+    kind: "sequential",
+    colors: ht,
+    capacity: null,
+    colorblindSafe: b
+  },
+  {
+    id: "inferno",
+    plainName: "Black to Yellow",
+    kind: "sequential",
+    colors: ut,
+    capacity: null,
+    colorblindSafe: b
+  },
+  {
+    id: "blues",
+    plainName: "Shades of Blue",
+    kind: "sequential",
+    colors: mt,
+    capacity: null,
+    colorblindSafe: b
+  },
+  {
+    id: "greens",
+    plainName: "Shades of Green",
+    kind: "sequential",
+    colors: pt,
+    capacity: null,
+    colorblindSafe: []
+  },
+  {
+    id: "oranges",
+    plainName: "Shades of Orange",
+    kind: "sequential",
+    colors: gt,
+    capacity: null,
+    colorblindSafe: []
+  },
+  {
+    id: "okabe-ito",
+    plainName: "Eight Distinct Colours",
+    kind: "categorical",
+    colors: Se,
+    capacity: Se.length,
+    colorblindSafe: b
+  },
+  {
+    id: "tol-vibrant",
+    plainName: "Seven Bright Colours",
+    kind: "categorical",
+    colors: Ne,
+    capacity: Ne.length,
+    colorblindSafe: b
+  },
+  {
+    id: "tol-muted",
+    plainName: "Nine Soft Colours",
+    kind: "categorical",
+    colors: De,
+    capacity: De.length,
+    colorblindSafe: b
+  },
+  {
+    id: "pastel",
+    plainName: "Eight Pale Colours",
+    kind: "categorical",
+    colors: we,
+    capacity: we.length,
+    colorblindSafe: b
+  },
+  {
+    id: "carbon",
+    plainName: "Five Enterprise Colours",
+    kind: "categorical",
+    colors: Oe,
+    capacity: Oe.length,
+    colorblindSafe: []
+  },
+  {
+    id: "purple-green",
+    plainName: "Purple to Green",
+    kind: "diverging",
+    colors: ft,
+    capacity: null,
+    colorblindSafe: b
+  },
+  {
+    id: "blue-orange",
+    plainName: "Blue to Orange",
+    kind: "diverging",
+    colors: bt,
+    capacity: null,
+    colorblindSafe: b
+  },
+  {
+    id: "red-blue",
+    plainName: "Red to Blue",
+    kind: "diverging",
+    colors: yt,
+    capacity: null,
+    colorblindSafe: []
+  },
+  {
+    id: "blue-highlight",
+    plainName: "Blue Highlight",
+    kind: "categorical",
+    colors: [Me.highlighted, Me.muted],
+    capacity: 2,
+    colorblindSafe: b
+  },
+  {
+    id: "green-highlight",
+    plainName: "Green Highlight",
+    kind: "categorical",
+    colors: [Ee.highlighted, Ee.muted],
+    capacity: 2,
+    colorblindSafe: b
+  },
+  {
+    id: "orange-highlight",
+    plainName: "Orange Highlight",
+    kind: "categorical",
+    colors: [Ie.highlighted, Ie.muted],
+    capacity: 2,
+    colorblindSafe: b
+  }
+]);
+function Yi(n) {
+  return ve.find((e) => e.id === n) ?? Xe(n);
+}
+function $i(n) {
+  const e = ve.filter((s) => s.kind === n), t = ze().filter((s) => s.kind === n);
+  return t.length === 0 ? e : [...e, ...t];
+}
+function Ji() {
+  return [...ve, ...ze()].map((n) => String(n.id));
+}
+const x = {
+  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."
+}, R = {
+  name: "midpoint",
+  plainName: "Midpoint",
+  technicalName: "midpoint",
+  type: "number",
+  description: "The value that lands on the middle colour of a diverging palette."
+};
+function Re(n, e, t) {
+  return {
+    name: "bins",
+    plainName: n,
+    technicalName: "bins",
+    type: "integer",
+    default: t,
+    min: 2,
+    max: 20,
+    step: 1,
+    description: e
+  };
+}
+const Pe = [
+  {
+    name: "linear",
+    plainName: "Even Steps",
+    domainKind: "numeric",
+    options: [x, R]
+  },
+  {
+    name: "log",
+    plainName: "By Order of Magnitude",
+    domainKind: "numeric",
+    options: [x, R]
+  },
+  {
+    name: "neglog10",
+    plainName: "By Significance",
+    domainKind: "numeric",
+    options: [x, R]
+  },
+  {
+    name: "sqrt",
+    plainName: "By Area",
+    domainKind: "numeric",
+    options: [x, R]
+  },
+  {
+    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."
+      },
+      x,
+      R
+    ]
+  },
+  {
+    name: "bins",
+    plainName: "Equal Ranges",
+    domainKind: "numeric",
+    options: [
+      Re("Groups", "How many equally wide ranges to cut the values into.", 5),
+      x
+    ]
+  },
+  {
+    name: "quantile",
+    plainName: "Equal Counts",
+    domainKind: "numeric",
+    options: [
+      Re("Groups", "How many groups of equal size to sort the values into.", 4),
+      x
+    ]
+  },
+  {
+    name: "ordinal",
+    plainName: "One Colour per Value",
+    domainKind: "categorical",
+    options: [x]
+  },
+  {
+    name: "passthrough",
+    plainName: "Use the Value As It Is",
+    domainKind: "categorical",
+    options: []
+  }
+];
+function Zi(n) {
+  return Pe.find((e) => e.name === n);
+}
+function Qi(n) {
+  return Pe.filter((e) => e.domainKind === n);
+}
+export {
+  K as A,
+  V as B,
+  $ as C,
+  J as D,
+  Q as F,
+  X as G,
+  ee as K,
+  zi as L,
+  te as M,
+  ie as N,
+  ve as P,
+  ae as R,
+  Pe as S,
+  Ui as U,
+  ye as a,
+  Ki as b,
+  Vi as c,
+  $i as d,
+  Qi as e,
+  le as f,
+  oe as g,
+  de as h,
+  ce as i,
+  se as j,
+  Ji as k,
+  Hi as l,
+  re as m,
+  Y as n,
+  Z as o,
+  Yi as p,
+  ne as q,
+  be as r,
+  Zi as s
+};