@graphty/graphty-element 2.2.3 → 2.2.5

package/dist/graphty.js

@@ -1,6 +1,6 @@
-import { A as e, a as E, b as r, D as O, E as o, d as S, G as R, e as _, I as t, L, N as C, O as A, R as N, S as n, f as I, g as T, h as g, U as i, i as l } from "./chunks/index-COss7yTG.js";
-import { a as p, S as G, b as f } from "./chunks/paletteRegistry-NrWOKT-A.js";
-import { D as y, E as D } from "./chunks/DataSource-DEg3igzS.js";
+import { A as e, a as E, b as r, D as O, E as o, d as S, G as R, e as _, I as t, L, N as C, O as A, R as N, S as n, f as I, g as T, h as g, U as i, i as l } from "./chunks/index-BY1gnMiZ.js";
+import { a as p, S as G, b as f } from "./chunks/paletteRegistry-YSpPryiT.js";
+import { D as y, E as D } from "./chunks/DataSource-Dag8H5US.js";
 import { k as P, l as U, g as c, h as m, A as u, C as x, i as B } from "./chunks/Algorithm-RQ629NLb.js";
 import { e as H, E as b, N as Y, a as F, P as W, R as k, S as K, d as v, b as w, c as Q } from "./chunks/NodeStyle-DKj7HjMJ.js";
 import { A as j, a as q, G as z, i as J, b as Z } from "./chunks/GraphtyError-BwcnblTH.js";

package/dist/session.js

@@ -1,26 +1,11 @@
-import { R as A, e as R } from "./chunks/types-B7bX5c0K.js";
-import { A as _, a as C, G as g, i as m, b as L } from "./chunks/GraphtyError-BwcnblTH.js";
-import { g as U, h as I, i as N } from "./chunks/Algorithm-RQ629NLb.js";
-import { D as h } from "./chunks/GraphSession-DDrQWABb.js";
-import { a as y, b as D, c as w, Q as b, R as v, d as G, e as x, S as z, T as F, f as M, i as j, g as H, h as Y, j as k } from "./chunks/GraphSession-DDrQWABb.js";
-import { R as Q, w as X, x as B, y as J, z as K, A as V } from "./chunks/paletteRegistry-NrWOKT-A.js";
-import { a as n } from "./chunks/scales-DKsbJE2L.js";
-const u = Object.freeze({
-  /** Above this node count the element draws less visual detail. A shipped default, not measured. */
-  largeGraphThreshold: 1e4,
-  /** The most nodes this machine is expected to draw at an interactive frame rate. A shipped default, not measured. */
-  renderCeiling: 2e5,
-  /** The most elements one selection will hold before it refuses to grow. A shipped default, not measured. */
-  selectionCap: h,
-  /** The most edges drawn at once; beyond it edges are hidden until the view narrows. A shipped default, not measured. */
-  edgesDrawn: 5e5,
-  /**
-   * Above this NODE COUNT an approximable algorithm is approximated rather than computed
-   * exactly. A shipped default, not measured. Not to be confused with the cost gate's
-   * `exactComputationSeconds`, which is a duration and answers a different question.
-   */
-  approximateAboveNodes: 2e3
-}), l = [
+import { R, e as _ } from "./chunks/types-B7bX5c0K.js";
+import { A as c, a as C, G as p, i as m, b as g } from "./chunks/GraphtyError-BwcnblTH.js";
+import { g as O, h as U, i as I } from "./chunks/Algorithm-RQ629NLb.js";
+import { D as h } from "./chunks/GraphSession-mfo75G0q.js";
+import { a as N, b as y, c as D, d as v, Q as w, R as G, e as b, f as x, S as F, T as M, g as z, i as k, h as H, j as Y, k as j } from "./chunks/GraphSession-mfo75G0q.js";
+import { R as Q, t as X, u as B, v as J, w as K, x as V } from "./chunks/paletteRegistry-YSpPryiT.js";
+import { L as s } from "./chunks/scales-DOpwlWuz.js";
+const u = [
   {
     id: "fixed",
     fires: ({ statistics: e, placedNodes: a }) => e.nodeCount > 0 && a >= e.nodeCount,
@@ -42,60 +27,60 @@ const u = Object.freeze({
     reason: "Connected nodes are pulled together and unconnected ones pushed apart, which is the arrangement that shows this graph's structure without being told anything about it."
   }
 ];
-function s(e, a) {
+function n(e, a) {
   return e.structuralInputs.length > 0 ? !1 : e.sizeRating === "any" || a <= e.sizeRating;
 }
-function f(e, a = {}) {
+function T(e, a = {}) {
   const i = {
     statistics: e,
     placedNodes: a.placedNodes ?? 0,
-    largeGraphThreshold: a.largeGraphThreshold ?? u.largeGraphThreshold
+    largeGraphThreshold: a.largeGraphThreshold ?? h.largeGraphThreshold
   };
-  for (const r of l) {
+  for (const r of u) {
     if (!r.fires(i))
       continue;
-    const o = n.find((d) => d.id === r.id);
-    if (o !== void 0 && s(o, e.nodeCount))
+    const o = s.find((d) => d.id === r.id);
+    if (o !== void 0 && n(o, e.nodeCount))
       return Object.freeze({ layout: o, reason: r.reason });
   }
-  const t = n.find((r) => s(r, e.nodeCount));
+  const t = s.find((r) => n(r, e.nodeCount));
   return t === void 0 ? void 0 : Object.freeze({
     layout: t,
     reason: "The first arrangement this element can place a graph of this size with."
   });
 }
 export {
-  _ as ACCELERATION_ERROR_CODES,
-  U as ACCELERATION_POLICIES,
-  I as ACCELERATION_POLICY_DEFAULT,
-  y as DEFAULT_COST_GATE_LIMITS,
-  D as DEFAULT_EXACT_COMPUTATION_CAP_SECONDS,
-  u as DEFAULT_LIMITS,
-  w as DEFAULT_SCOPE_SAMPLE,
-  h as DEFAULT_SELECTION_CAP,
+  c as ACCELERATION_ERROR_CODES,
+  O as ACCELERATION_POLICIES,
+  U as ACCELERATION_POLICY_DEFAULT,
+  N as DEFAULT_COST_GATE_LIMITS,
+  y as DEFAULT_EXACT_COMPUTATION_CAP_SECONDS,
+  h as DEFAULT_LIMITS,
+  D as DEFAULT_SCOPE_SAMPLE,
+  v as DEFAULT_SELECTION_CAP,
   C as GRAPHTY_ERROR_CODES,
-  g as GraphtyError,
-  b as QUEUE_POLICIES,
+  p as GraphtyError,
+  w as QUEUE_POLICIES,
   Q as RESULT_FIELD_NAMES,
   X as RESULT_ROOT,
-  A as RESULT_SHAPES,
+  R as RESULT_SHAPES,
   B as RESULT_SHAPE_CONTRACTS,
-  v as RUN_ID_PATTERN,
-  G as RUN_PHASES,
+  G as RUN_ID_PATTERN,
+  b as RUN_PHASES,
   x as RUN_STATUSES,
-  z as SET_OPS,
-  F as TERMINAL_RUN_STATUSES,
-  M as createGraphSession,
+  F as SET_OPS,
+  M as TERMINAL_RUN_STATUSES,
+  z as createGraphSession,
   J as defaultReading,
-  N as isAccelerationPolicy,
-  j as isAlgorithmRunCommand,
+  I as isAccelerationPolicy,
+  k as isAlgorithmRunCommand,
   m as isGraphtyError,
-  L as isGraphtyErrorCode,
-  R as isResultShape,
+  g as isGraphtyErrorCode,
+  _ as isResultShape,
   H as isRunId,
   Y as isRunStatus,
-  k as isTerminalRunStatus,
+  j as isTerminalRunStatus,
   K as quotePath,
-  f as recommendLayout,
+  T as recommendLayout,
   V as resultPath
 };

package/dist/src/Graph.d.ts

@@ -350,6 +350,9 @@ export declare class Graph implements GraphContext {
      * present each time a host re-assigned the property -- and a host that re-renders on state
      * change re-assigns it constantly. The old drop guard was silently doing this job; deleting the
      * guard without this would have turned "assign the same edges twice" into "hold them twice".
+     *
+     * A set past the render ceiling is refused with `E_TOO_LARGE` before an edge is removed, so
+     * the graph keeps the edges it had.
      * @param edges - the edges the graph should hold afterwards
      * @param options - The endpoint expressions, the repeat policy, and queue ordering
      * @returns Promise that resolves once the graph holds exactly these edges

package/dist/src/acceleration/AccelerationController.d.ts

@@ -92,6 +92,17 @@ interface AccelerationControllerOptions {
     readonly recoverOnDeviceLoss?: boolean;
     /** How many consecutive recovery attempts to make before giving up. Defaults to 3. */
     readonly maxRecoveryAttempts?: number;
+    /**
+     * Opens a span around every call-shaped accelerated run, returning what closes it.
+     *
+     * The element hands in its render manager's `holdFrames`: a GPU readback is delivered as a
+     * task and waits behind whatever frame the host is drawing, so a run that is a few
+     * milliseconds on the device came back a frame or two later through the element (issue
+     * #390). The span covers exactly the accelerated call -- not the decision before it, and not
+     * the CPU path -- and is closed however the call ends. A simulation, which steps every frame
+     * through {@link AccelerationController.beginWork}, never opens one: it needs the frames.
+     */
+    readonly whileRunning?: () => () => void;
 }
 /**
  * Owns hardware acceleration for one session: whether there is any, what it is, and whether a

package/dist/src/ai/input/VoiceInputAdapter.d.ts

@@ -47,6 +47,10 @@ declare global {
 }
 /** Callback for voice input start/error events */
 export type VoiceStartCallback = (started: boolean, error?: string) => void;
+/** Why a voice session ended: stopped by the caller, ended by the recogniser, or failed. */
+type VoiceEndReason = "user" | "timeout" | "error";
+/** Callback for a voice session starting (`active` true) or ending (`active` false, with a reason). */
+type VoiceActiveCallback = (active: boolean, reason?: VoiceEndReason) => void;
 /**
  * Voice input adapter using the Web Speech API.
  * Provides voice-to-text functionality with support for interim and final results.
@@ -57,6 +61,8 @@ export declare class VoiceInputAdapter implements InputAdapter {
     private _isActive;
     private callbacks;
     private startCallbacks;
+    private activeCallbacks;
+    private failed;
     private SpeechRecognitionCtor;
     /**
      * Creates a new VoiceInputAdapter instance.
@@ -92,10 +98,22 @@ export declare class VoiceInputAdapter implements InputAdapter {
      * @param callback - Function called with (started: boolean, error?: string)
      */
     onStart(callback: VoiceStartCallback): void;
+    /**
+     * Register a callback for every voice session starting and ending.
+     * Unlike {@link VoiceInputAdapter.onStart} it stays registered across sessions.
+     * @param callback - Called with (true) on start and (false, reason) on end
+     */
+    onActiveChange(callback: VoiceActiveCallback): void;
     /**
      * Clean up resources and remove all callbacks.
      */
     dispose(): void;
+    /**
+     * Notify active-change callbacks.
+     * @param active - Whether a session is now running
+     * @param reason - Why it ended, when it did
+     */
+    private notifyActive;
     /**
      * Notify start callbacks and clear them (one-shot).
      * @param started - Whether voice input started successfully

package/dist/src/data/ingest.d.ts

@@ -1,4 +1,17 @@
 import type { GraphStore } from "./GraphStore";
+/**
+ * Whether a value may be used as a graph-format node id.
+ *
+ * graph-format accepts a string or a FINITE number and throws `E_INVALID_ID` for anything else
+ * (`graph-format/src/ids/node-id-map.ts`). The element is looser: a node id is whatever the
+ * configured JMESPath expression returns, which is `null` for a record that does not carry the
+ * key at all, and the element has always let such a record through and rendered it. So the id is
+ * CHECKED here rather than thrown on -- an unusable id leaves the render object exactly as it is
+ * today and keeps it out of the store, which is the one place the id has to be real.
+ * @param id - the extracted id
+ * @returns true when graph-format will accept it
+ */
+export declare function isStorableId(id: unknown): id is string | number;
 /**
  * Push one node record into the element's builder and seed its import position.
  *

package/dist/src/managers/DataManager.d.ts

@@ -423,6 +423,36 @@ export declare class DataManager implements Manager {
      * @returns the edges, oldest first; empty when there are none
      */
     getEdgesBetween(srcNodeId: NodeIdType, dstNodeId: NodeIdType): readonly Edge[];
+    /**
+     * Replace every built edge with a new set, or leave the graph exactly as it was.
+     *
+     * The ceiling is decided BEFORE anything is removed. Removing first and letting `addEdges`
+     * refuse would leave a host that assigned too many edges with its old edges gone and none of
+     * the new ones held, which is neither the graph it had nor the one it asked for. The new
+     * batch is counted against an emptied graph, since the old edges are what it replaces; a
+     * pending edge, whose endpoints have not arrived, survives the replace as it always has.
+     * @param edges - the edges the graph should hold afterwards
+     * @param options - the endpoint expressions and the repeat policy for this call
+     * @throws A `GraphtyError` with `E_TOO_LARGE` when the new set is past the ceiling, and
+     *     whatever `addEdges` throws.
+     */
+    setEdges(edges: Record<string | number, unknown>[], options?: AddEdgesOptions): void;
+    /**
+     * How many edges a batch would add, by the same tests the ingest loop applies.
+     *
+     * A record whose endpoint ids graph-format will not store adds nothing (the loop rejects it).
+     * Under the `keep` policy every other record is an edge. Under a folding policy a record that
+     * repeats an edge the graph holds, or a record earlier in the same batch, folds into it and
+     * adds nothing; a repeat is named the way `knownEdgeFor` names it, by record id when one is
+     * configured and stored, else by the ordered endpoint pair.
+     * @param edges - the batch
+     * @param endpoints - the batch's endpoint expressions
+     * @param policy - the repeat policy the batch is under
+     * @param replacing - true when every held edge is about to be removed, so none of them can be
+     *     repeated
+     * @returns the number of edges the batch would add
+     */
+    private edgesAdded;
     /**
      * Removes an edge from the graph
      * @param edgeId - Edge identifier to remove
@@ -467,6 +497,27 @@ export declare class DataManager implements Manager {
      * @returns the node and edge counts the graph holds
      */
     private heldCounts;
+    /**
+     * Refuse to grow past what the renderer can draw, instead of freezing the tab.
+     *
+     * WHY A REFUSAL AND NOT A DEGRADED DRAW. The design says that above the render ceiling the
+     * element draws a smaller render set, and above `edgesDrawn` it hides edges until the view
+     * narrows. Neither exists yet. What exists is a renderer that, past these counts, exhausts
+     * the renderer process and produces no further frame -- measured for issue #405 at 18,000
+     * nodes / 180,000 edges on an RTX 4070 SUPER, where the renderer process reached 4.7 GB and
+     * died while 17,000 / 170,000 loaded in 17 s. Until the degraded draw lands, the honest
+     * behaviour at the ceiling is a coded error the consumer can show, so `DEFAULT_LIMITS` is
+     * the number the element enforces rather than a number it merely publishes.
+     *
+     * `E_TOO_LARGE` is the code because the ceiling is a hard limit of this renderer, and the
+     * caller's remedy is the one that code names: load a subset.
+     * @param of - what is being counted
+     * @param held - how many the graph holds already
+     * @param adding - how many this call would add
+     * @param limit - the most the renderer can draw
+     * @throws A `GraphtyError` with `E_TOO_LARGE` when `held + adding` is past the limit
+     */
+    private refuseAboveCeiling;
     /**
      * Clear all data
      */

package/dist/src/managers/RenderManager.d.ts

@@ -22,6 +22,8 @@ export declare class RenderManager implements Manager {
     graphRoot: TransformNode;
     private renderLoopActive;
     private updateCallback?;
+    /** How many callers currently hold the frames back; see {@link holdFrames}. */
+    private frameHolds;
     private resizeHandler;
     /**
      * Stands in for Babylon's own pointer handling, which calls preventDefault and then
@@ -54,6 +56,25 @@ export declare class RenderManager implements Manager {
      * Stop the render loop
      */
     stopRenderLoop(): void;
+    /**
+     * Keeps the render loop from drawing until the returned function is called.
+     *
+     * A FRAME IS WHAT A GPU READBACK WAITS BEHIND. Drawing a scene of thousands of meshes keeps
+     * the main thread for tens to hundreds of milliseconds, and a promise the GPU resolves --
+     * the mapped buffer at the end of a traversal, the frontier count between its levels -- is
+     * delivered as a task, which cannot run until the frame that was drawing has finished. A
+     * breadth-first search that costs 7 ms on the device came back after 225 ms through the
+     * element at 1,000 nodes and after 8.6 s at 10,000, two frames per readback (issue #390).
+     * Measured apart, the CPU update of a frame is 2.5 ms and is not what the readback waits on;
+     * the draw is 48 ms at 1,000 nodes and is.
+     *
+     * So a call-shaped accelerated run holds the frames for as long as it is on the device, and
+     * the picture stands still for those milliseconds instead of the run stretching to seconds.
+     * Holds nest: the frames resume when the last holder releases, and releasing twice is a
+     * no-op, so a `finally` cannot over-release.
+     * @returns Releases this hold.
+     */
+    holdFrames(): () => void;
     /**
      * Update the background color
      * @param color - Hex color string (e.g., "#FFFFFF")

package/dist/src/managers/UpdateManager.d.ts

@@ -1,5 +1,8 @@
+import type { Vector3 } from "@babylonjs/core";
 import type { CameraManager } from "../cameras/CameraManager";
 import type { EdgeId, NodeId } from "../catalog/types";
+import { Edge } from "../Edge";
+import type { Node } from "../Node";
 import type { ElementMask } from "../session/scope/index";
 import type { DataManager } from "./DataManager";
 import type { EventManager } from "./EventManager";
@@ -7,6 +10,34 @@ import type { GraphContext } from "./GraphContext";
 import type { Manager } from "./interfaces";
 import type { LayoutManager } from "./LayoutManager";
 import type { StatsManager } from "./StatsManager";
+/** The corners of a box in world space. */
+interface FramingBox {
+    min: Vector3;
+    max: Vector3;
+}
+/**
+ * The box the nodes alone occupy: every visible node, where it is in world space, out to its size.
+ * This is what the 2D/3D view-mode switch frames. Zoom-to-fit frames {@link framingBox}, which
+ * grows this one by the labels.
+ *
+ * NO MARGIN on top. A fixed one is paid by every graph, labelled or not, and on a small graph it is
+ * most of the picture: one world unit on each side moved a two-node graph's camera from 6.0 to 8.6
+ * units out. The cameras pad the fit themselves.
+ * @param nodes - The nodes to frame; hidden ones are skipped.
+ * @returns The corners, or undefined when no node is visible.
+ */
+export declare function nodeFramingBox(nodes: Iterable<Node>): FramingBox | undefined;
+/**
+ * The box zoom-to-fit frames: {@link nodeFramingBox} grown by every label on a visible node and
+ * every label and arrow caption on a visible edge, so no label is cut off by the edge of the
+ * viewport. A label's size depends on its text and font, which is why framing runs on data loads
+ * and layout changes and NOT on label edits: see `Graph`, which asks for a framing only from
+ * those.
+ * @param nodes - The nodes to frame; hidden ones and their labels are skipped.
+ * @param edges - The edges whose labels to frame; hidden ones are skipped.
+ * @returns The corners, or undefined when no node is visible.
+ */
+export declare function framingBox(nodes: Iterable<Node>, edges: Iterable<Edge>): FramingBox | undefined;
 /**
  * One set of elements the renderer honours, as the session holds it.
  *
@@ -366,32 +397,17 @@ export declare class UpdateManager implements Manager {
      */
     private largestMove;
     /**
-     * Update all nodes, and measure the graph when the camera is about to be framed on it.
-     * @param measure - Whether this frame's bounding box will be used. False skips the
-     *     measurement entirely, which is most frames.
-     * @returns Object containing minimum and maximum bounding box vectors
+     * Update all nodes.
      */
     private updateNodes;
     /**
-     * Update bounding box for a single axis
-     * @param pos - Position vector
-     * @param min - Minimum bounds vector
-     * @param max - Maximum bounds vector
-     * @param size - Node size
-     * @param axis - Axis to update (x, y, or z)
-     */
-    private updateBoundingBoxAxis;
-    /**
-     * Expand bounding box to include a label mesh
-     * @param labelMesh - The label mesh to include
-     * @param min - Minimum bounds vector
-     * @param max - Maximum bounds vector
+     * Measure the graph the camera is about to be framed on. Taken AFTER the nodes and edges have
+     * updated, so the labels are where this frame's positions put them.
+     * @returns The box, or undefined when nothing is visible.
      */
-    private expandBoundingBoxForLabel;
+    private measure;
     /**
-     * Update all edges and expand bounding box for edge labels
-     * @param boundingBoxMin - Minimum bounds (optional)
-     * @param boundingBoxMax - Maximum bounds (optional)
+     * Update all edges.
      */
     private updateEdges;
     /**
@@ -405,8 +421,7 @@ export declare class UpdateManager implements Manager {
     private willZoomToFit;
     /**
      * Frame the camera on a box {@link UpdateManager.willZoomToFit} has already approved.
-     * @param boundingBoxMin - Minimum bounds (optional)
-     * @param boundingBoxMax - Maximum bounds (optional)
+     * @param box - The box to frame, or undefined when there is nothing to frame.
      */
     private applyZoomToFit;
     /**

package/dist/src/session/limits.d.ts

@@ -7,11 +7,30 @@
  * large-graph threshold of its own, ten times the element's, with nothing between the two to
  * notice they disagreed.
  *
- * So these are published as what they are: SHIPPED DEFAULTS, not measurements. Every one of them
- * is the fallback the element API design's Performance defaults table names for the case where the
- * probe cannot run, and none of them describes the machine this code is running on. When
- * `calibrate()` lands it replaces them and `Capabilities.calibration.basis` turns from
- * `"defaults"` into `"probe"`, which is how a consumer can tell which kind of number it is holding.
+ * So these are published as what they are: SHIPPED DEFAULTS, not measurements of the machine this
+ * code is running on. When `calibrate()` lands it replaces them and `Capabilities.calibration.basis`
+ * turns from `"defaults"` into `"probe"`, which is how a consumer can tell which kind of number it
+ * is holding.
+ *
+ * TWO OF THEM ARE ENFORCED, AND WERE MEASURED ONCE. `renderCeiling` and `edgesDrawn` used to be
+ * the design table's figures, 200,000 nodes and 500,000 edges, and nothing checked them. The
+ * renderer could not reach either: at 18,000 nodes / 180,000 edges the page stopped producing
+ * frames (issue #405). The measurement behind the numbers below, taken 2026-09-26 in headless
+ * Chromium on an RTX 4070 SUPER with `layout="random"`, ten edges per node and the default
+ * style, found that the wall is not the GPU. It is V8's heap: `performance.memory.jsHeapSizeLimit`
+ * is 3.5 GB in that Chromium and the renderer draws every edge as two Babylon meshes plus, on
+ * the default arrow-headed style, a ShaderMaterial of its own, which costs about 20 KB of heap
+ * per edge and 10 KB per node. The heap was at its limit from 15,000 / 150,000 up (every load
+ * past that point is garbage-collection bound: 12.6 s, then 19.4 s at 17,000) and the renderer
+ * process died at 18,000 / 180,000. Nodes alone are cheap: 200,000 with no edges used 2.0 GB.
+ *
+ * The ceilings below keep the worst case they allow together, 50,000 nodes AND 100,000 edges,
+ * at 2.7 GB of heap (74 % of the limit, loaded in 8.0 s), which leaves room for a layout and a
+ * run to allocate. 100,000 nodes with the same edges reached 84 % and 11.4 s, which is why the
+ * node ceiling is the lower of the two measured figures. `DataManager` refuses a load past
+ * either with `E_TOO_LARGE`; see `refuseAboveCeiling` there for why a refusal and not a
+ * degraded draw. When the arrowheads share one material (pull request #394 in flight) the
+ * per-edge cost falls and the same measurement should be repeated to raise these.
  *
  * ONE OF THE SIX FIELDS IS ABSENT, and it is worth saying why the other five are not.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphty/graphty-element",
-  "version": "2.2.3",
+  "version": "2.2.5",
   "description": "A Web Component library for 3D/2D graph visualization built with Lit and Babylon.js",
   "type": "module",
   "customElements": "./dist/custom-elements.json",
@@ -134,7 +134,7 @@
     "vitepress": "^1.6.3",
     "vitest": "^3.2.4",
     "@graphty/remote-logger": "^1.3.7",
-    "@graphty/webgpu-graph-algorithms": "^0.6.4"
+    "@graphty/webgpu-graph-algorithms": "^0.6.5"
   },
   "peerDependencies": {
     "@ai-sdk/anthropic": "^2.0.50",
@@ -146,7 +146,7 @@
     "ai": "^5.0.104",
     "encrypt-storage": "^2.14.7",
     "lit": "^3.0.0",
-    "@graphty/webgpu-graph-algorithms": "^0.6.4"
+    "@graphty/webgpu-graph-algorithms": "^0.6.5"
   },
   "peerDependenciesMeta": {
     "@ai-sdk/anthropic": {
@@ -184,9 +184,9 @@
     "papaparse": "^5.5.3",
     "toposort": "^2.0.2",
     "zod": "^3.25.28",
+    "@graphty/algorithms": "^2.0.3",
     "@graphty/graph-format": "^1.0.5",
-    "@graphty/layout": "^1.9.1",
-    "@graphty/algorithms": "^2.0.3"
+    "@graphty/layout": "^1.9.1"
   },
   "overrides": {
     "storybook": "$storybook"