@graphty/graphty-element 2.3.1 → 2.4.1

package/dist/chunks/{scales-BRwl51k8.js → scales-BXHmwPXC.js}

@@ -1,15 +1,15 @@
-import { arfLayout as Re, bfsLayout as ke, bipartiteLayout as ze, circularLayout as Fe, createSimulation as Le, seedPositions as Pe, resolveNodeVector as Te, kamadaKawaiLayout as We, multipartiteLayout as _e, planarLayout as Ae, randomLayout as Be, shellLayout as qe, spectralLayout as Ge, spiralLayout as je } from "@graphty/layout";
+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 ue, k as Ue, W as He, l as Ee, m as Ke, g as Ce } from "./paletteRegistry-x7WOEKZY.js";
-import { k as u, j as Ve } from "./algorithms-CpX56sUB.js";
-import { forceLink as Ye, forceSimulation as $e, forceManyBody as Je, forceCenter as Ze } from "d3-force-3d";
-import { makeMask as fe, maskSet as le } from "@graphty/graph-format";
-import { C as ce, E as Qe, o as Xe } from "./optionsFromZod-17lkrAJs.js";
-import { G as de } from "./GraphtyError-BwcnblTH.js";
-import et from "ngraph.forcelayout";
-import tt from "ngraph.graph";
-import { V as it, Y as st, g as nt, I as at, B as ot, G as rt, d as lt, O as be, i as ye, T as ve, P as xe, C as Se, h as ct, b as dt, R as ht, a as Ne, c as we, e as De } from "./sequential-Zym81qm7.js";
-const ut = u({
+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-jg9uS7wo.js";
+import { k as u, j as et } from "./algorithms-B87OPYw4.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-DHLLiX_8.js";
+import { G as pe } from "./pluginRegistry-MaTIDh6l.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: {
@@ -49,7 +49,7 @@ const ut = u({
       advanced: !0
     }
   }
-}), mt = i.strictObject({
+}), 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),
@@ -62,7 +62,7 @@ const ut = u({
    * @param opts - Configuration options for the ARF algorithm
    */
   constructor(e) {
-    super(e), this.scalingFactor = 100, this.config = mt.parse(e);
+    super(e), this.scalingFactor = 100, this.config = xt.parse(e);
   }
   /**
    * Get dimension-specific options for ARF layout
@@ -78,7 +78,7 @@ const ut = u({
   doLayout() {
     this.stale = !1;
     const e = () => this._nodes.map((s) => s.id), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
-    this.positions = Re(
+    this.positions = Le(
       { nodes: e, edges: t },
       this.config.pos,
       this.config.scaling,
@@ -88,9 +88,9 @@ const ut = u({
     );
   }
 };
-k.type = "arf", k.maxDimensions = 2, k.zodOptionsSchema = ut;
-let U = k;
-const pt = u({
+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: {
@@ -120,7 +120,7 @@ const pt = u({
       step: 0.1
     }
   }
-}), gt = i.strictObject({
+}), Nt = i.strictObject({
   ...v.shape,
   start: i.number().or(i.string()),
   align: i.enum(["vertical", "horizontal"]).default("vertical"),
@@ -132,7 +132,7 @@ const pt = u({
    * @param opts - Configuration options including start node and alignment
    */
   constructor(e) {
-    super(e), this.scalingFactor = 20, this.config = gt.parse(e);
+    super(e), this.scalingFactor = 20, this.config = Nt.parse(e);
   }
   /**
    * Get dimension-specific options for BFS layout
@@ -148,7 +148,7 @@ const pt = u({
   doLayout() {
     this.stale = !1;
     const e = () => this._nodes.map((s) => s.id), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
-    this.positions = ke(
+    this.positions = Te(
       { nodes: e, edges: t },
       this.config.start,
       this.config.align,
@@ -157,9 +157,9 @@ const pt = u({
     );
   }
 };
-z.type = "bfs", z.maxDimensions = 2, z.zodOptionsSchema = pt;
-let H = z;
-const ft = u({
+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: {
@@ -190,7 +190,7 @@ const ft = u({
       step: 0.1
     }
   }
-}), bt = i.strictObject({
+}), wt = i.strictObject({
   ...v.shape,
   nodes: i.array(i.number().or(i.string())),
   align: i.enum(["vertical", "horizontal"]).default("vertical"),
@@ -203,7 +203,7 @@ const ft = u({
    * @param opts - Configuration options including node partitions and alignment
    */
   constructor(e) {
-    super(e), this.scalingFactor = 40, this.config = bt.parse(e);
+    super(e), this.scalingFactor = 40, this.config = wt.parse(e);
   }
   /**
    * Get dimension-specific options for bipartite layout
@@ -219,7 +219,7 @@ const ft = u({
   doLayout() {
     this.stale = !1;
     const e = () => this._nodes.map((s) => s.id), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
-    this.positions = ze(
+    this.positions = We(
       { nodes: e, edges: t },
       this.config.nodes,
       this.config.align,
@@ -229,9 +229,9 @@ const ft = u({
     );
   }
 };
-F.type = "bipartite", F.maxDimensions = 2, F.zodOptionsSchema = ft;
-let K = F;
-const yt = u({
+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: {
@@ -254,18 +254,18 @@ const yt = u({
       description: "Layout dimensionality (2D or 3D)"
     }
   }
-}), vt = i.strictObject({
+}), 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)
-}), L = class L extends y {
+}), 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 = vt.parse(e);
+    super(e), this.scalingFactor = 80, this.config = Mt.parse(e);
   }
   /**
    * Get dimension-specific options for circular layout
@@ -281,12 +281,12 @@ const yt = u({
   doLayout() {
     this.stale = !1;
     const e = () => this._nodes.map((s) => s.id), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
-    this.positions = Fe({ nodes: e, edges: t }, this.config.scale, this.config.center, this.config.dim);
+    this.positions = Ae({ nodes: e, edges: t }, this.config.scale, this.config.center, this.config.dim);
   }
 };
-L.type = "circular", L.maxDimensions = 3, L.zodOptionsSchema = yt;
-let V = L;
-const xt = u({
+P.type = "circular", P.maxDimensions = 3, P.zodOptionsSchema = Ot;
+let $ = P;
+const Et = u({
   alphaMin: {
     schema: i.number().positive().default(0.1),
     meta: {
@@ -323,29 +323,29 @@ const xt = u({
     }
   }
 });
-function he(n) {
+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 St = i.strictObject({
+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 Nt(n) {
-  return !!(typeof n == "object" && n !== null && Object.hasOwn(n, "index") && "index" in n && typeof n.index == "number" && "source" in n && he(n.source) && "target" in n && he(n.target));
+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 P = class P extends ue {
+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 = St.parse(e);
+    const t = It.parse(e);
     this.d3AlphaMin = t.alphaMin, this.d3AlphaTarget = t.alphaTarget, this.d3AlphaDecay = t.alphaDecay, this.d3VelocityDecay = t.velocityDecay;
-    const s = Ye();
-    s.strength(0.9), this.d3ForceLayout = $e().numDimensions(3).alpha(1).force("link", s).force("charge", Je()).force("center", Ze()).force("dagRadial", null).stop(), this.d3ForceLayout.force("link").id((o) => o.id);
+    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
@@ -371,7 +371,7 @@ const P = class P extends ue {
       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 (!he(r))
+        if (!ge(r))
           throw new Error("Internal error: Node is not settled as a complete D3 Node");
         this.nodeMapping.set(o, r);
       }
@@ -380,7 +380,7 @@ const P = class P extends ue {
       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 (!Nt(r))
+        if (!Ct(r))
           throw new Error("Internal error: Edge is not settled as a complete D3 Edge");
         this.edgeMapping.set(o, r);
       }
@@ -560,9 +560,9 @@ const P = class P extends ue {
     return t;
   }
 };
-P.type = "d3", P.maxDimensions = 3, P.zodOptionsSchema = xt;
-let Y = P;
-const wt = u({
+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: {
@@ -570,7 +570,7 @@ const wt = u({
       description: "Layout dimensionality (2D or 3D)"
     }
   }
-}), Dt = i.strictObject({
+}), kt = i.strictObject({
   ...v.shape,
   dim: i.number().default(3)
 }), T = class T extends y {
@@ -579,7 +579,7 @@ const wt = u({
    * @param opts - Configuration options including dimensions
    */
   constructor(e = {}) {
-    super(e), this.scalingFactor = 1, this.config = Dt.parse(e);
+    super(e), this.scalingFactor = 1, this.config = kt.parse(e);
   }
   /**
    * Add a node and apply its fixed position immediately
@@ -604,20 +604,20 @@ const wt = u({
     this.positions = e;
   }
 };
-T.type = "fixed", T.maxDimensions = 3, T.zodOptionsSchema = wt;
-let $ = T;
-const Ot = 25e4, Mt = 4;
-function Et(n, e, t) {
-  return n !== null ? n : t > Ot ? e * Mt : 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 Ct(n, e) {
+function Lt(n, e) {
   if (n == null || typeof n == "string")
     return null;
   const t = e.outDegree();
-  return Te(n, e, (s) => t[s] + 1);
+  return Ge(n, e, (s) => t[s] + 1);
 }
-const It = 1e-6;
-function Rt(n, e, t, s = null) {
+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];
@@ -634,40 +634,40 @@ function Rt(n, e, t, s = null) {
     Number.isFinite(g) && g > a && (a = g);
   }
   const h = Math.sqrt(a);
-  return { scale: h > It ? t / h : 1, centre: [r, c, l], placed: o };
+  return { scale: h > Tt ? t / h : 1, centre: [r, c, l], placed: o };
 }
-function kt(n) {
+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 zt = {
+const _t = {
   forceatlas2: "forceAtlas2",
   fruchtermanReingold: "fruchtermanReingold",
   spring: "fruchtermanReingold",
   "spring-electrical": "springElectrical"
 };
-function Ft() {
-  return new de({
+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 me extends ue {
-  #M;
-  #S = ce;
+class be extends fe {
+  #I;
+  #N = me;
   #t;
   #h;
-  #E;
+  #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.
    */
-  #N = { src: { x: 0, y: 0, z: 0 }, dst: { x: 0, y: 0, z: 0 } };
+  #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
@@ -678,7 +678,7 @@ class me extends ue {
    */
   #w = null;
   #u = !1;
-  #a = null;
+  #o = null;
   #p = null;
   #g = null;
   /**
@@ -705,7 +705,7 @@ class me extends ue {
   // 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.
-  #D = /* @__PURE__ */ new Set();
+  #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}.
@@ -719,17 +719,21 @@ class me extends ue {
    * 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.
    */
-  #C = /* @__PURE__ */ new WeakSet();
+  #R = /* @__PURE__ */ new WeakSet();
   #r = !1;
   /** The simulation whose failure has already been reported; see `#onError`. */
-  #I = null;
+  #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;
-  #m = 1;
+  /** 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.
    *
@@ -746,8 +750,8 @@ class me extends ue {
     super();
     const t = e;
     if (t.controller === void 0 || t.type === void 0)
-      throw Ft();
-    this.simulationType = t.type, this.#M = t.layoutType ?? t.type, this.capability = zt[t.type], this.#t = t.options, this.#h = t.controller, this.#E = t.report, this.#n = t.dataManager, this.#s = kt(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];
+      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`.
@@ -758,7 +762,7 @@ class me extends ue {
    * @returns The name the consumer set.
    */
   get type() {
-    return this.#M;
+    return this.#I;
   }
   /**
    * The running simulation, or null before the first load and while the bridge is stopped.
@@ -782,7 +786,7 @@ class me extends ue {
    * @returns The precision, which is the CPU's whenever the CPU is running the layout.
    */
   get precision() {
-    return this.#S;
+    return this.#N;
   }
   /**
    * How many iterations this bridge has submitted since the simulation was built. Submitted,
@@ -790,7 +794,7 @@ class me extends ue {
    * @returns The count.
    */
   get iterationsDone() {
-    return this.#y;
+    return this.#v;
   }
   /**
    * The node masses the running simulation was handed, when the element resolved them itself.
@@ -810,7 +814,7 @@ class me extends ue {
    * @returns The mask, or an empty one before the first load.
    */
   get pinnedMask() {
-    return this.#g === null ? fe(0) : this.#g.slice();
+    return this.#g === null ? xe(0) : this.#g.slice();
   }
   /**
    * Whether a different accelerator is attached now than when the simulation was built.
@@ -848,7 +852,7 @@ class me extends ue {
    * attached, or whatever `createSimulation` throws.
    */
   load(e, t) {
-    this.#e?.dispose(), this.#e = null, this.#o(), this.#a = e, this.#p = t, this.#O(e.nodeCount, t), this.#z();
+    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.
@@ -861,16 +865,16 @@ class me extends ue {
    * attached.
    */
   reload(e, t) {
-    if (this.#a === null)
+    if (this.#o === null)
       return;
     const s = this.#e;
-    this.#a = e, this.#p = t;
-    const o = this.#O(e.nodeCount, t), r = this.#h.plan({ capability: this.capability, nodeCount: e.nodeCount }), c = this.#d !== null;
+    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.#L(e.nodeCount), this.#F(e, o), s.load(this.#n.undirected(e).snapshot, o), this.#k();
+    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.
@@ -883,12 +887,12 @@ class me extends ue {
    * the next transition that attaches an accelerator brings it back through this same method.
    */
   replaceSimulation() {
-    if (this.#e?.dispose(), this.#e = null, this.#o(), this.#a === null || this.#p === null) {
+    if (this.#e?.dispose(), this.#e = null, this.#a(), this.#o === null || this.#p === null) {
       this.#r = !1;
       return;
     }
     try {
-      this.#z();
+      this.#P();
     } catch (e) {
       throw this.#r = !0, e;
     }
@@ -908,14 +912,14 @@ class me extends ue {
     const e = this.#e;
     if (e === null || this.#r)
       return;
-    this.#y += this.#m;
+    this.#v += this.#m;
     const t = e.step(this.#m);
-    this.#o(), t !== void 0 && !this.#C.has(t) && (this.#C.add(t), t.then(
+    this.#a(), t !== void 0 && !this.#R.has(t) && (this.#R.add(t), this.#y += 1, t.then(
       () => {
-        this.#o();
+        this.#y -= 1, this.#a();
       },
       (s) => {
-        this.#W(s, e);
+        this.#y -= 1, this.#_(s, e);
       }
     ));
   }
@@ -926,14 +930,30 @@ class me extends ue {
    */
   async stepAsync(e) {
     if (!(this.#e === null || this.#r)) {
-      this.#y += e, this.#o();
+      this.#v += e, this.#a();
       try {
         await this.#e.step(e);
       } finally {
-        this.#o();
+        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.
    *
@@ -953,7 +973,7 @@ class me extends ue {
    * @param n - The node the pointer has taken.
    */
   beginDrag(e) {
-    this.#D.add(e), this.#v(e.index, !0);
+    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.
@@ -966,21 +986,21 @@ class me extends ue {
    * @param pin - True when the drag ends in a pin, so the bit stays set.
    */
   endDrag(e, t) {
-    this.#D.delete(e), this.#v(e.index, t || e.isPinned());
+    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.#v(e.index, !0);
+    this.#x(e.index, !0);
   }
   /**
    * Releases a node the simulation was holding fixed.
    * @param n - The node that was unpinned.
    */
   unpin(e) {
-    this.#v(e.index, !1);
+    this.#x(e.index, !1);
   }
   /**
    * Places one node now. A drag reaches this per pointer move, and `replayPins` once per pin.
@@ -989,7 +1009,7 @@ class me extends ue {
    */
   setNodePosition(e, t) {
     const s = t.z ?? 0;
-    if (!this.#x(e.index) || !Number.isFinite(t.x) || !Number.isFinite(t.y) || !Number.isFinite(s))
+    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;
@@ -1015,7 +1035,7 @@ class me extends ue {
    * @returns The pair, valid until the next call; the origin for an endpoint nothing has placed.
    */
   getEdgePosition(e) {
-    return this.#R(e.srcNode, this.#N.src), this.#R(e.dstNode, this.#N.dst), this.#N;
+    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.
@@ -1030,7 +1050,7 @@ class me extends ue {
    * @param out.y - receives the scene-unit y.
    * @param out.z - receives the scene-unit z.
    */
-  #R(e, t) {
+  #z(e, t) {
     this.readNodePosition(e, t) || (t.x = 0, t.y = 0, t.z = 0);
   }
   /**
@@ -1112,15 +1132,15 @@ class me extends ue {
    * free row left keeps the last map rather than falling back to the identity.
    */
   publishPositions() {
-    const e = this.#a, t = this.#l;
+    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 = Rt(t, e.nodeCount, this.#t.scalingFactor, o);
+    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.#x(h))
+      if (!this.#S(h))
         continue;
       const d = s.isPlaced(h);
       d && this.#c.has(h) || this.writeNodePosition(
@@ -1138,7 +1158,7 @@ class me extends ue {
    * freeze and at shutdown.
    */
   dispose() {
-    this.#e?.dispose(), this.#e = null, this.#o();
+    this.#e?.dispose(), this.#e = null, this.#a();
   }
   /**
    * Tells the controller whether the accelerator is being stepped right now.
@@ -1152,11 +1172,11 @@ class me extends ue {
    * 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 until it resumes and settles: the bridge is not told about a pause, and the
-   * batches it had in flight are still landing when one begins.
+   * 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.
    */
-  #o() {
-    const e = this.#u && this.#e !== null && !this.#r && !this.isSettled;
+  #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();
@@ -1173,30 +1193,30 @@ class me extends ue {
    * 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.
    */
-  #k() {
-    const e = this.#a, t = this.#e;
+  #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 = fe(s), c = /* @__PURE__ */ new Set();
+    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 && (le(r, l, !0), c.add(l));
-    for (const l of this.#D)
-      this.#x(l.index) && (le(r, l.index, !0), c.add(l.index));
+      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.
    */
-  #z() {
-    const e = this.#a, t = this.#p;
+  #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.#O(e.nodeCount, t);
-    this.#w = null, this.#u = !1, this.#S = ce;
+    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 de({
+      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",
@@ -1206,11 +1226,11 @@ class me extends ue {
         }
       });
     const l = this.#n.undirected(e).snapshot;
-    this.#F(e, o), this.#d = this.#P(l), this.#m = this.#L(e.nodeCount), this.#e = Le(
+    this.#L(e, o), this.#d = this.#W(l), this.#m = this.#T(e.nodeCount), this.#e = _e(
       this.simulationType,
-      this.#T(),
-      c === null ? null : Qe(c)
-    ), this.#w = this.#h.accelerator, this.#u = r.accelerated, this.#S = r.accelerated ? r.precision : ce, this.#r = !1, this.#y = 0, this.#e.load(l, o), this.#k();
+      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
@@ -1218,8 +1238,8 @@ class me extends ue {
    * @param undirected - The graph the simulation will be loaded with.
    * @returns The masses, or null when the simulation resolves them itself.
    */
-  #P(e) {
-    return Ct(this.#t.model.nodeMass, e);
+  #W(e) {
+    return Lt(this.#t.model.nodeMass, e);
   }
   /**
    * Gives a coordinate to every row that has none, before the simulation reads them.
@@ -1234,9 +1254,9 @@ class me extends ue {
    * @param snapshot - The graph being loaded.
    * @param positions - The simulation's array, exactly `3 * nodeCount` long.
    */
-  #F(e, t) {
+  #L(e, t) {
     const { seed: s, dim: o, scale: r, center: c } = this.#t.model;
-    Pe(
+    Be(
       e,
       t,
       s ?? null,
@@ -1258,7 +1278,7 @@ class me extends ue {
    * @param positions - The element's array, exactly `3 * nodeCount` long.
    * @returns The simulation's array, holding the element's arrangement in simulation units.
    */
-  #O(e, t) {
+  #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)
@@ -1270,7 +1290,7 @@ class me extends ue {
    * iteration count this load resolved.
    * @returns The options object.
    */
-  #T() {
+  #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 };
   }
@@ -1279,9 +1299,9 @@ class me extends ue {
    * @param nodeCount - The graph this load is over.
    * @returns The iteration count.
    */
-  #L(e) {
+  #T(e) {
     const { iterationsPerStep: t, stepMultiplier: s } = this.#t;
-    return Et(t, s, e);
+    return Pt(t, s, e);
   }
   /**
    * Sets or clears one bit of the fixed mask and tells the simulation.
@@ -1291,9 +1311,9 @@ class me extends ue {
    * @param index - The node's dense row.
    * @param fixed - Whether the simulation must hold it still.
    */
-  #v(e, t) {
+  #x(e, t) {
     const s = this.#g, o = this.#e;
-    s === null || o === null || !this.#x(e) || (le(s, e, t), t ? this.#c.add(e) : this.#c.delete(e), o.setFixed(s));
+    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.
@@ -1304,8 +1324,8 @@ class me extends ue {
    * @param index - The node's dense row, or the sentinel.
    * @returns True when the index addresses a row of the loaded graph.
    */
-  #x(e) {
-    return Number.isInteger(e) && e >= 0 && e < (this.#a?.nodeCount ?? 0);
+  #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.
@@ -1330,9 +1350,9 @@ class me extends ue {
    * @param error - The rejection.
    * @param from - The simulation the batch was submitted on.
    */
-  #W(e, t) {
-    this.#I !== t && (this.#I = t, t === this.#e && (this.#r = !0, this.#o()), this.#E(
-      de.wrap(e, {
+  #_(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 }
@@ -1340,7 +1360,7 @@ class me extends ue {
     ));
   }
 }
-const Lt = u({
+const Gt = u({
   scalingFactor: {
     schema: i.number().min(1).max(1e3).default(100),
     meta: {
@@ -1445,7 +1465,7 @@ const Lt = u({
       advanced: !0
     }
   }
-}), w = class w extends me {
+}), D = class D extends be {
   /**
    * Get dimension-specific options for ForceAtlas2 layout.
    * @param dimension - The desired dimension (2 or 3).
@@ -1455,9 +1475,64 @@ const Lt = u({
     return { dim: e };
   }
 };
-w.type = "forceatlas2", w.simulationType = "forceatlas2", w.maxDimensions = 3, w.honoursWeights = !0, w.zodOptionsSchema = Lt;
-let J = w;
-const Pt = "weight", Tt = u({
+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: {
@@ -1487,7 +1562,7 @@ const Pt = "weight", Tt = u({
       description: "Place strongly connected nodes closer together"
     }
   }
-}), Wt = i.strictObject({
+}), 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),
@@ -1501,7 +1576,7 @@ const Pt = "weight", Tt = u({
    * @param opts - Configuration options including scale and dimensions
    */
   constructor(e) {
-    super(e), this.scalingFactor = 50, this.config = Wt.parse(e);
+    super(e), this.scalingFactor = 50, this.config = Kt.parse(e);
   }
   /**
    * Get dimension-specific options for Kamada-Kawai layout
@@ -1526,23 +1601,23 @@ const Pt = "weight", Tt = u({
     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(Ue(r, c));
+      const l = o.get(Ze(r, c));
       if (l !== void 0)
-        return 1 / Math.max(l, He);
-    }), this.positions = We(
+        return 1 / Math.max(l, Qe);
+    }), this.positions = je(
       s,
       this.config.dist,
       this.config.pos,
-      Pt,
+      Ut,
       this.config.scale,
       this.config.center,
       this.config.dim
     );
   }
 };
-M.type = "kamada-kawai", M.maxDimensions = 3, M.honoursWeights = !0, M.zodOptionsSchema = Tt;
-let Z = M;
-const _t = u({
+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: {
@@ -1565,20 +1640,20 @@ const _t = u({
       step: 0.1
     }
   }
-}), At = i.strictObject({
+}), 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)
-}), W = class W extends y {
+}), 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 = At.parse(e);
+    super(e), this.scalingFactor = 40, this.config = Yt.parse(e);
   }
   /**
    * Get dimension-specific options for multipartite layout
@@ -1594,7 +1669,7 @@ const _t = u({
   doLayout() {
     this.stale = !1;
     const e = () => this._nodes.map((s) => s.id), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
-    this.positions = _e(
+    this.positions = Ue(
       { nodes: e, edges: t },
       this.config.subsetKey,
       this.config.align,
@@ -1603,12 +1678,12 @@ const _t = u({
     );
   }
 };
-W.type = "multipartite", W.maxDimensions = 2, W.zodOptionsSchema = _t;
-let Q = W;
-var I = { exports: {} }, Oe;
-function Bt() {
-  if (Oe) return I.exports;
-  Oe = 1, I.exports = n, I.exports.random = n, I.exports.randomIterator = l;
+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);
@@ -1664,16 +1739,16 @@ function Bt() {
       return a;
     }
     function N(p) {
-      var g, O, re;
+      var g, O, he;
       for (g = a.length - 1; g > 0; --g)
-        O = d.next(g + 1), re = a[O], a[O] = a[g], a[g] = re, p(re);
+        O = d.next(g + 1), he = a[O], a[O] = a[g], a[g] = he, p(he);
       a.length && p(a[0]);
     }
   }
-  return I.exports;
+  return C.exports;
 }
-var qt = Bt();
-const Gt = /* @__PURE__ */ Ve(qt), jt = u({
+var Jt = $t();
+const Zt = /* @__PURE__ */ et(Jt), Qt = u({
   dim: {
     schema: i.number().int().min(2).max(3).default(3),
     meta: {
@@ -1739,17 +1814,17 @@ const Gt = /* @__PURE__ */ Ve(qt), jt = u({
       advanced: !0
     }
   }
-}), _ = class _ extends ue {
+}), _ = 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.ngraph = tt();
+    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), t.seed !== void 0 && typeof t.seed == "number" && (s.random = Gt(t.seed)), this.ngraphLayout = et(this.ngraph, s);
+    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
@@ -1803,7 +1878,11 @@ const Gt = /* @__PURE__ */ Ve(qt), jt = u({
    */
   addNode(e) {
     const t = this.ngraph.addNode(e.id, { parentNode: e });
-    this.nodeMapping.set(e, t), this._settled = !1, this._stepCount = 0, this._lastMoves = [];
+    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
@@ -1918,9 +1997,9 @@ const Gt = /* @__PURE__ */ Ve(qt), jt = u({
     return t;
   }
 };
-_.type = "ngraph", _.maxDimensions = 3, _.zodOptionsSchema = jt;
-let X = _;
-const Ut = u({
+_.type = "ngraph", _.maxDimensions = 3, _.zodOptionsSchema = Qt;
+let ie = _;
+const Xt = u({
   scalingFactor: {
     schema: i.number().min(1).max(1e3).default(70),
     meta: {
@@ -1951,19 +2030,19 @@ const Ut = u({
       advanced: !0
     }
   }
-}), Ht = i.strictObject({
+}), 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)
-}), A = class A extends y {
+}), 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 = Ht.parse(e);
+    super(e), this.scalingFactor = 70, this.config = ei.parse(e);
   }
   /**
    * Get dimension-specific options for planar layout
@@ -1979,7 +2058,7 @@ const Ut = u({
   doLayout() {
     this.stale = !1;
     const e = () => this._nodes.map((s) => s.id), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
-    this.positions = Ae(
+    this.positions = He(
       { nodes: e, edges: t },
       this.config.scale,
       this.config.center,
@@ -1988,9 +2067,64 @@ const Ut = u({
     );
   }
 };
-A.type = "planar", A.maxDimensions = 2, A.zodOptionsSchema = Ut;
-let ee = A;
-const Kt = u({
+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: {
@@ -2006,25 +2140,25 @@ const Kt = u({
     }
   },
   seed: {
-    schema: i.number().positive().nullable().default(null),
+    schema: i.number().positive().nullable().default(Fe),
     meta: {
       label: "Random Seed",
       description: "Seed for reproducible random positions",
       advanced: !0
     }
   }
-}), Vt = i.strictObject({
+}), 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(null)
-}), B = class B extends y {
+  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 = Vt.parse(e);
+    super(e), this.scalingFactor = 100, this.config = ni.parse(e);
   }
   /**
    * Get dimension-specific options for random layout
@@ -2040,12 +2174,12 @@ const Kt = u({
   doLayout() {
     this.stale = !1;
     const e = () => this._nodes.map((s) => s.id), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
-    this.positions = Be({ nodes: e, edges: t }, this.config.center, this.config.dim, this.config.seed);
+    this.positions = Ve({ nodes: e, edges: t }, this.config.center, this.config.dim, this.config.seed);
   }
 };
-B.type = "random", B.maxDimensions = 3, B.zodOptionsSchema = Kt;
-let te = B;
-const Yt = u({
+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: {
@@ -2068,19 +2202,19 @@ const Yt = u({
       description: "Layout dimensionality (2D only for shell)"
     }
   }
-}), $t = i.strictObject({
+}), 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)
-}), q = class q extends y {
+}), 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 = $t.parse(e);
+    super(e), this.scalingFactor = 100, this.config = oi.parse(e);
   }
   /**
    * Get dimension-specific options for shell layout
@@ -2096,7 +2230,7 @@ const Yt = u({
   doLayout() {
     this.stale = !1;
     const e = () => this._nodes.map((s) => s.id), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
-    this.positions = qe(
+    this.positions = Ye(
       { nodes: e, edges: t },
       this.config.nlist,
       this.config.scale,
@@ -2105,9 +2239,9 @@ const Yt = u({
     );
   }
 };
-q.type = "shell", q.maxDimensions = 2, q.zodOptionsSchema = Yt;
-let ie = q;
-const Jt = u({
+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: {
@@ -2130,18 +2264,18 @@ const Jt = u({
       description: "Layout dimensionality (2D only for spectral)"
     }
   }
-}), Zt = i.strictObject({
+}), 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)
-}), G = class G extends y {
+}), 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 = Zt.parse(e);
+    super(e), this.scalingFactor = 100, this.config = li.parse(e);
   }
   /**
    * Get dimension-specific options for spectral layout
@@ -2157,12 +2291,12 @@ const Jt = u({
   doLayout() {
     this.stale = !1;
     const e = () => this._nodes.map((s) => s.id), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
-    this.positions = Ge({ nodes: e, edges: t }, this.config.scale, this.config.center, this.config.dim);
+    this.positions = $e({ nodes: e, edges: t }, this.config.scale, this.config.center, this.config.dim);
   }
 };
-G.type = "spectral", G.maxDimensions = 2, G.zodOptionsSchema = Jt;
-let se = G;
-const Qt = u({
+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: {
@@ -2202,20 +2336,20 @@ const Qt = u({
       advanced: !0
     }
   }
-}), Xt = i.strictObject({
+}), 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)
-}), j = class j extends y {
+}), 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 = Xt.parse(e);
+    super(e), this.scalingFactor = 80, this.config = di.parse(e);
   }
   /**
    * Get dimension-specific options for spiral layout
@@ -2231,7 +2365,7 @@ const Qt = u({
   doLayout() {
     this.stale = !1;
     const e = () => this._nodes.map((s) => s.id), t = () => this._edges.map((s) => [s.srcId, s.dstId]);
-    this.positions = je(
+    this.positions = Je(
       { nodes: e, edges: t },
       this.config.scale,
       this.config.center,
@@ -2241,9 +2375,9 @@ const Qt = u({
     );
   }
 };
-j.type = "spiral", j.maxDimensions = 2, j.zodOptionsSchema = Qt;
-let ne = j;
-const ei = u({
+H.type = "spiral", H.maxDimensions = 2, H.zodOptionsSchema = ci;
+let le = H;
+const hi = u({
   springLength: {
     schema: i.number().positive().default(10),
     meta: {
@@ -2309,7 +2443,7 @@ const ei = u({
       advanced: !0
     }
   }
-}), E = class E extends me {
+}), E = class E extends be {
   /**
    * Get dimension-specific options for the spring-electrical layout.
    * @param dimension - The desired dimension (2 or 3).
@@ -2319,9 +2453,9 @@ const ei = u({
     return { dim: e };
   }
 };
-E.type = "spring-electrical", E.simulationType = "spring-electrical", E.maxDimensions = 3, E.zodOptionsSchema = ei;
-let ae = E;
-const ti = u({
+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: {
@@ -2367,7 +2501,7 @@ const ti = u({
       advanced: !0
     }
   }
-}), C = class C extends me {
+}), I = class I extends be {
   /**
    * Get dimension-specific options for spring layout.
    * @param dimension - The desired dimension (2 or 3).
@@ -2377,15 +2511,15 @@ const ti = u({
     return { dim: e };
   }
 };
-C.type = "spring", C.simulationType = "spring", C.maxDimensions = 3, C.zodOptionsSchema = ti;
-let oe = C;
-const D = {
+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 Xe(n, { overrides: e });
+  return ot(n, { overrides: e });
 }
-function b(n, e, t = []) {
+function f(n, e, t = []) {
   return {
     descriptor: {
       ...n,
@@ -2399,162 +2533,180 @@ function b(n, e, t = []) {
     ]
   };
 }
-const ii = {
+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(X.zodOptionsSchema, D),
-  honoursWeights: X.honoursWeights
-}, si = {
+  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(Y.zodOptionsSchema),
-  honoursWeights: Y.honoursWeights
-}, ni = {
+  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(J.zodOptionsSchema, D),
-  honoursWeights: J.honoursWeights
-}, ai = {
+  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(oe.zodOptionsSchema, D),
-  honoursWeights: oe.honoursWeights
-}, oi = {
+  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(ae.zodOptionsSchema, D),
-  honoursWeights: ae.honoursWeights,
+  options: m(ce.zodOptionsSchema, w),
+  honoursWeights: ce.honoursWeights,
   requires: { accelerator: !0 }
-}, ri = {
+}, 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(Z.zodOptionsSchema),
-  honoursWeights: Z.honoursWeights
-}, li = {
+  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(U.zodOptionsSchema, D),
-  honoursWeights: U.honoursWeights
-}, ci = {
+  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(V.zodOptionsSchema),
-  honoursWeights: V.honoursWeights
-}, di = {
+  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(ie.zodOptionsSchema),
-  honoursWeights: ie.honoursWeights
-}, hi = {
+  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(ne.zodOptionsSchema),
-  honoursWeights: ne.honoursWeights
-}, ui = {
+  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(se.zodOptionsSchema),
-  honoursWeights: se.honoursWeights
-}, mi = {
+  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(ee.zodOptionsSchema, D),
-  honoursWeights: ee.honoursWeights
-}, pi = {
+  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(H.zodOptionsSchema),
-  honoursWeights: H.honoursWeights
-}, gi = {
+  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(K.zodOptionsSchema),
-  honoursWeights: K.honoursWeights
-}, fi = {
+  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(Q.zodOptionsSchema),
-  honoursWeights: Q.honoursWeights
-}, bi = {
+  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($.zodOptionsSchema),
-  honoursWeights: $.honoursWeights
-}, yi = {
+  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(te.zodOptionsSchema, D),
-  honoursWeights: te.honoursWeights
-}, pe = [
-  b(
+  options: m(ae.zodOptionsSchema, w),
+  honoursWeights: ae.honoursWeights
+}, ye = [
+  f(
     {
       id: "force",
       plainName: "Spread Out",
@@ -2566,10 +2718,10 @@ const ii = {
       sizeRating: "any",
       structuralInputs: []
     },
-    ii,
-    [si, ni, ai, ri, oi]
+    mi,
+    [pi, gi, fi, yi, bi]
   ),
-  b(
+  f(
     {
       id: "force-2d",
       plainName: "Spread Out, Flat",
@@ -2581,9 +2733,9 @@ const ii = {
       sizeRating: 2e3,
       structuralInputs: []
     },
-    li
+    vi
   ),
-  b(
+  f(
     {
       id: "circular",
       plainName: "Ring",
@@ -2595,9 +2747,37 @@ const ii = {
       sizeRating: "any",
       structuralInputs: []
     },
-    ci
+    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
   ),
-  b(
+  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",
@@ -2609,9 +2789,9 @@ const ii = {
       sizeRating: "any",
       structuralInputs: ["partition"]
     },
-    di
+    Si
   ),
-  b(
+  f(
     {
       id: "spiral",
       plainName: "Spiral",
@@ -2623,9 +2803,9 @@ const ii = {
       sizeRating: "any",
       structuralInputs: []
     },
-    hi
+    wi
   ),
-  b(
+  f(
     {
       id: "spectral",
       plainName: "Natural Grouping",
@@ -2637,9 +2817,9 @@ const ii = {
       sizeRating: 2e3,
       structuralInputs: []
     },
-    ui
+    Oi
   ),
-  b(
+  f(
     {
       id: "planar",
       plainName: "No Crossings",
@@ -2651,9 +2831,9 @@ const ii = {
       sizeRating: 2e3,
       structuralInputs: []
     },
-    mi
+    Mi
   ),
-  b(
+  f(
     {
       id: "random",
       plainName: "Scattered",
@@ -2665,9 +2845,9 @@ const ii = {
       sizeRating: "any",
       structuralInputs: []
     },
-    yi
+    ki
   ),
-  b(
+  f(
     {
       id: "hierarchical",
       plainName: "Tree",
@@ -2679,9 +2859,9 @@ const ii = {
       sizeRating: "any",
       structuralInputs: ["node"]
     },
-    pi
+    Ei
   ),
-  b(
+  f(
     {
       id: "bipartite",
       plainName: "Two Columns",
@@ -2693,9 +2873,9 @@ const ii = {
       sizeRating: "any",
       structuralInputs: ["partition"]
     },
-    gi
+    Ii
   ),
-  b(
+  f(
     {
       id: "layers",
       plainName: "Columns by Group",
@@ -2707,9 +2887,9 @@ const ii = {
       sizeRating: "any",
       structuralInputs: ["partition"]
     },
-    fi
+    Ci
   ),
-  b(
+  f(
     {
       id: "fixed",
       plainName: "Keep Positions",
@@ -2721,38 +2901,29 @@ const ii = {
       sizeRating: "any",
       structuralInputs: []
     },
-    bi
+    Ri
   )
-], vi = pe.map((n) => n.descriptor), ki = [
-  {
-    id: "radial",
-    reason: "No engine arranges a graph in rings by distance from a chosen node. The spiral layout winds outward but orders nodes by position in the list, not by the graph, so it answers a different question and is published under its own name instead."
-  },
-  {
-    id: "grid",
-    reason: "No engine places nodes on a regular lattice."
-  }
-];
-function zi(n) {
-  return vi.find((e) => e.id === n) ?? Ee(n)?.descriptor;
+], zi = ye.map((n) => n.descriptor), Ui = [];
+function Hi(n) {
+  return zi.find((e) => e.id === n) ?? ke(n)?.descriptor;
 }
-function Fi(n) {
-  return pe.find((e) => e.descriptor.id === n);
+function Ki(n) {
+  return ye.find((e) => e.descriptor.id === n);
 }
-function Li(n) {
-  const e = pe.find(
+function Vi(n) {
+  const e = ye.find(
     (t) => t.implementations.some((s) => s.engine === n)
   );
-  return e !== void 0 ? e.descriptor.id : Ee(n)?.descriptor.id;
+  return e !== void 0 ? e.descriptor.id : ke(n)?.descriptor.id;
 }
-const f = ["deuteranopia", "protanopia", "tritanopia"], ge = Object.freeze([
+const b = ["deuteranopia", "protanopia", "tritanopia"], ve = Object.freeze([
   {
     id: "viridis",
     plainName: "Purple to Yellow",
     kind: "sequential",
-    colors: it,
+    colors: ct,
     capacity: null,
-    colorblindSafe: f
+    colorblindSafe: b
   },
   // Paul Tol, "Colour Schemes" (2021): YlOrBr, trimmed to the steps that stand off a light
   // background. The default for a measurement.
@@ -2760,39 +2931,39 @@ const f = ["deuteranopia", "protanopia", "tritanopia"], ge = Object.freeze([
     id: "ylorbr",
     plainName: "Orange to Brown",
     kind: "sequential",
-    colors: st,
+    colors: dt,
     capacity: null,
-    colorblindSafe: f
+    colorblindSafe: b
   },
   {
     id: "plasma",
     plainName: "Blue to Yellow",
     kind: "sequential",
-    colors: nt,
+    colors: ht,
     capacity: null,
-    colorblindSafe: f
+    colorblindSafe: b
   },
   {
     id: "inferno",
     plainName: "Black to Yellow",
     kind: "sequential",
-    colors: at,
+    colors: ut,
     capacity: null,
-    colorblindSafe: f
+    colorblindSafe: b
   },
   {
     id: "blues",
     plainName: "Shades of Blue",
     kind: "sequential",
-    colors: ot,
+    colors: mt,
     capacity: null,
-    colorblindSafe: f
+    colorblindSafe: b
   },
   {
     id: "greens",
     plainName: "Shades of Green",
     kind: "sequential",
-    colors: rt,
+    colors: pt,
     capacity: null,
     colorblindSafe: []
   },
@@ -2800,7 +2971,7 @@ const f = ["deuteranopia", "protanopia", "tritanopia"], ge = Object.freeze([
     id: "oranges",
     plainName: "Shades of Orange",
     kind: "sequential",
-    colors: lt,
+    colors: gt,
     capacity: null,
     colorblindSafe: []
   },
@@ -2808,63 +2979,63 @@ const f = ["deuteranopia", "protanopia", "tritanopia"], ge = Object.freeze([
     id: "okabe-ito",
     plainName: "Eight Distinct Colours",
     kind: "categorical",
-    colors: be,
-    capacity: be.length,
-    colorblindSafe: f
+    colors: Se,
+    capacity: Se.length,
+    colorblindSafe: b
   },
   {
     id: "tol-vibrant",
     plainName: "Seven Bright Colours",
     kind: "categorical",
-    colors: ye,
-    capacity: ye.length,
-    colorblindSafe: f
+    colors: Ne,
+    capacity: Ne.length,
+    colorblindSafe: b
   },
   {
     id: "tol-muted",
     plainName: "Nine Soft Colours",
     kind: "categorical",
-    colors: ve,
-    capacity: ve.length,
-    colorblindSafe: f
+    colors: De,
+    capacity: De.length,
+    colorblindSafe: b
   },
   {
     id: "pastel",
     plainName: "Eight Pale Colours",
     kind: "categorical",
-    colors: xe,
-    capacity: xe.length,
-    colorblindSafe: f
+    colors: we,
+    capacity: we.length,
+    colorblindSafe: b
   },
   {
     id: "carbon",
     plainName: "Five Enterprise Colours",
     kind: "categorical",
-    colors: Se,
-    capacity: Se.length,
+    colors: Oe,
+    capacity: Oe.length,
     colorblindSafe: []
   },
   {
     id: "purple-green",
     plainName: "Purple to Green",
     kind: "diverging",
-    colors: ct,
+    colors: ft,
     capacity: null,
-    colorblindSafe: f
+    colorblindSafe: b
   },
   {
     id: "blue-orange",
     plainName: "Blue to Orange",
     kind: "diverging",
-    colors: dt,
+    colors: bt,
     capacity: null,
-    colorblindSafe: f
+    colorblindSafe: b
   },
   {
     id: "red-blue",
     plainName: "Red to Blue",
     kind: "diverging",
-    colors: ht,
+    colors: yt,
     capacity: null,
     colorblindSafe: []
   },
@@ -2872,36 +3043,36 @@ const f = ["deuteranopia", "protanopia", "tritanopia"], ge = Object.freeze([
     id: "blue-highlight",
     plainName: "Blue Highlight",
     kind: "categorical",
-    colors: [Ne.highlighted, Ne.muted],
+    colors: [Me.highlighted, Me.muted],
     capacity: 2,
-    colorblindSafe: f
+    colorblindSafe: b
   },
   {
     id: "green-highlight",
     plainName: "Green Highlight",
     kind: "categorical",
-    colors: [we.highlighted, we.muted],
+    colors: [Ee.highlighted, Ee.muted],
     capacity: 2,
-    colorblindSafe: f
+    colorblindSafe: b
   },
   {
     id: "orange-highlight",
     plainName: "Orange Highlight",
     kind: "categorical",
-    colors: [De.highlighted, De.muted],
+    colors: [Ie.highlighted, Ie.muted],
     capacity: 2,
-    colorblindSafe: f
+    colorblindSafe: b
   }
 ]);
-function Pi(n) {
-  return ge.find((e) => e.id === n) ?? Ke(n);
+function Yi(n) {
+  return ve.find((e) => e.id === n) ?? Xe(n);
 }
-function Ti(n) {
-  const e = ge.filter((s) => s.kind === n), t = Ce().filter((s) => s.kind === 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 Wi() {
-  return [...ge, ...Ce()].map((n) => String(n.id));
+function Ji() {
+  return [...ve, ...ze()].map((n) => String(n.id));
 }
 const x = {
   name: "reverse",
@@ -2917,7 +3088,7 @@ const x = {
   type: "number",
   description: "The value that lands on the middle colour of a diverging palette."
 };
-function Me(n, e, t) {
+function Re(n, e, t) {
   return {
     name: "bins",
     plainName: n,
@@ -2930,7 +3101,7 @@ function Me(n, e, t) {
     description: e
   };
 }
-const Ie = [
+const Pe = [
   {
     name: "linear",
     plainName: "Even Steps",
@@ -2980,7 +3151,7 @@ const Ie = [
     plainName: "Equal Ranges",
     domainKind: "numeric",
     options: [
-      Me("Groups", "How many equally wide ranges to cut the values into.", 5),
+      Re("Groups", "How many equally wide ranges to cut the values into.", 5),
       x
     ]
   },
@@ -2989,7 +3160,7 @@ const Ie = [
     plainName: "Equal Counts",
     domainKind: "numeric",
     options: [
-      Me("Groups", "How many groups of equal size to sort the values into.", 4),
+      Re("Groups", "How many groups of equal size to sort the values into.", 4),
       x
     ]
   },
@@ -3006,42 +3177,44 @@ const Ie = [
     options: []
   }
 ];
-function _i(n) {
-  return Ie.find((e) => e.name === n);
+function Zi(n) {
+  return Pe.find((e) => e.name === n);
 }
-function Ai(n) {
-  return Ie.filter((e) => e.domainKind === n);
+function Qi(n) {
+  return Pe.filter((e) => e.domainKind === n);
 }
 export {
-  U as A,
-  H as B,
-  V as C,
-  Y as D,
-  J as F,
-  Z as K,
-  vi as L,
-  Q as M,
-  X as N,
-  ge as P,
-  te as R,
-  Ie as S,
-  ki as U,
-  pe as a,
-  Fi as b,
-  Li as c,
-  Ti as d,
-  Ai as e,
-  ne as f,
-  ie as g,
-  oe as h,
-  ae as i,
-  ee as j,
-  Wi as k,
-  zi as l,
-  se as m,
-  K as n,
-  $ as o,
-  Pi as p,
-  me as q,
-  _i as s
+  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
 };