@graphty/graphty-element 2.0.0 → 2.2.0

package/dist/src/testing/fakeAccelerator.d.ts

@@ -0,0 +1,323 @@
+/**
+ * A deterministic stand-in for a real accelerator, for tests and for stories.
+ *
+ * The element decides "GPU or CPU" once per piece of work and then drives whatever it attached
+ * through the same two seams: `LayoutSimulation` for a layout and the accelerator's algorithm
+ * members for a run. Exercising either seam against a real GPU makes a test depend on a device,
+ * on a driver and on how many frames the browser happened to render. This fake stands in for
+ * the device: it implements the seams, it moves nodes by an exact amount per landed batch, and
+ * it counts what it was asked to do.
+ *
+ * What a landed batch COMPUTES is a choice, because a unit test and a story want opposite things
+ * of it. A test wants an answer it can assert on to the digit, so by default a batch moves every
+ * unfixed node `moveBy * iterations` along x and settling is counted in landed batches rather
+ * than in elapsed time: a node's coordinate after a settle is an exact multiple of `moveBy`
+ * whatever the frame rate.
+ *
+ * A STORY WANTS A PICTURE, AND THAT UNIFORM TRANSLATION HAS NONE. Every unfixed node moves the
+ * same distance in the same direction, and the element frames the camera on whatever it is
+ * given, so the arrangement on screen is the seed scatter no matter how many batches land --
+ * which makes a story named after a layout draw a hairball and a baseline of it mean nothing.
+ * `computes: "layout"` is for that case: the batch runs the CPU simulation of the layout that was
+ * asked for, so the picture is that layout's own arrangement, reached through the accelerator
+ * seam and deterministic under the layout's seed.
+ *
+ * Everything a test observes lives on the ACCELERATOR, aggregated over every simulation it
+ * created ({@link FakeAccelerator.calls}), so a test never has to reach for the simulation to
+ * find out what happened; `simulations` is there for the rare case that needs identity.
+ *
+ * This module is reachable from no entry point: it imports the seam, the CPU simulations it can
+ * stand a device in front of, and the error model, and it ships in the package the way the tests
+ * do.
+ * @module testing/fakeAccelerator
+ */
+import type { IndexedPageRankOptions, LabelResultLike, PageRankResultLike } from "@graphty/algorithms";
+import { type F32, type GraphSnapshot, type NodeMask } from "@graphty/graph-format";
+import { type ForceAtlas2Options, type FruchtermanReingoldOptions, type LayoutSimulation, type SimulationOptions, type SimulationType, type SpringElectricalOptions } from "@graphty/layout";
+import type { AccelerationPrecision, GraphAccelerator } from "../acceleration/types";
+import { type GraphtyErrorCode } from "../errors";
+/**
+ * What the fake has been asked to do, counted across every simulation one accelerator created.
+ *
+ * Each algorithm and layout member counts CALLS of that name. The three simulation counters are
+ * about batches rather than calls, because the seam coalesces: `step` counts SUBMISSIONS, so a
+ * call that landed on a pending promise instead of submitting its own batch does not appear
+ * here; `resolved` counts the batches that have landed; `reheat` counts reheats. `release` lists
+ * the snapshots in call order rather than counting them, because which snapshot was released is
+ * the thing a release test is about.
+ *
+ * Not exported: it is reachable as `FakeAccelerator["calls"]`, and a name nothing imports is a
+ * name knip reports. Export it the day a caller needs to spell it.
+ */
+interface FakeAcceleratorCalls {
+    /** How many `forceAtlas2()` simulations were built. */
+    forceAtlas2: number;
+    /** How many `fruchtermanReingold()` simulations were built. */
+    fruchtermanReingold: number;
+    /** How many `springElectrical()` simulations were built. */
+    springElectrical: number;
+    /** How many PageRank runs were asked for. */
+    pageRank: number;
+    /** How many connected-component runs were asked for. */
+    connectedComponents: number;
+    /** How many weakly-connected-component runs were asked for. */
+    weaklyConnectedComponents: number;
+    /** How many times the ACCELERATOR was disposed; a simulation's own dispose is not counted. */
+    dispose: number;
+    /** The snapshots handed to `release()`, in call order. */
+    release: GraphSnapshot[];
+    /** How many times a simulation was loaded. */
+    load: number;
+    /** How many batches were SUBMITTED; a coalesced `step()` does not count. */
+    step: number;
+    /** How many batches have landed. */
+    resolved: number;
+    /** How many times a simulation was reheated. */
+    reheat: number;
+}
+/**
+ * How to build a fake accelerator.
+ *
+ * Not exported, for the reason above: `Parameters<typeof createFakeAccelerator>[0]` spells it.
+ */
+interface FakeAcceleratorOptions {
+    /** The name it reports in diagnostics. Default `"fake"`. */
+    readonly name?: string;
+    /** The arithmetic it claims. Default `"f32"`, the precision a GPU reports. */
+    readonly precision?: AccelerationPrecision;
+    /** Landed batches after which a simulation reports `settled`. Default 10. */
+    readonly settleAfter?: number;
+    /** Scene units a landed batch moves one unfixed node along x, per iteration. Default 1. */
+    readonly moveBy?: number;
+    /** Batches a simulation accepts before coalescing onto the oldest. Default 2. */
+    readonly maxInFlight?: number;
+    /**
+     * What a landed batch computes: the exact translation, or the layout that was asked for.
+     *
+     * `"translation"` is the default and is what every assertion in this package is written
+     * against. `"layout"` runs the CPU simulation of the layout the caller built -- ForceAtlas2
+     * for `forceAtlas2()`, Fruchterman-Reingold for `fruchtermanReingold()` -- so the arrangement
+     * is that layout's own and a story drawing it draws the thing its name promises. `moveBy` and
+     * `settleAfter` do not apply to it: the simulation settles on its own terms.
+     */
+    readonly computes?: "translation" | "layout";
+    /** A device-loss promise, for the recovery paths. Absent means this backend cannot lose one. */
+    readonly lost?: Promise<{
+        reason: string;
+    }>;
+    /**
+     * What the accelerator's self-check answers when the element asks it, at attach, to prove it
+     * computes correctly.
+     *
+     * Absent -- the default -- gives it no `verify` member at all, which is the shape of a
+     * backend that cannot check itself and is what every accelerator looks like today. `"ok"`
+     * gives it one that resolves. A code gives it one that rejects with that code, which is how a
+     * test stands in for a device that computes wrong answers without owning one:
+     * `verify: "E_DEVICE_INCORRECT"`.
+     */
+    readonly verify?: "ok" | GraphtyErrorCode;
+    /**
+     * Members to add to the accelerator, or to replace on it.
+     *
+     * The element feature-tests a member before it uses it, so setting one to `undefined` is how
+     * a test builds an accelerator that does not implement a capability.
+     */
+    readonly members?: Readonly<Record<string, unknown>>;
+}
+/**
+ * The simulation a {@link FakeAccelerator} hands out: the GPU shape, without a GPU.
+ *
+ * It is the GPU shape in the two ways the element's frame loop cares about. `step()` returns a
+ * promise, so the bridge's fire-and-forget path is what a test exercises rather than the
+ * synchronous CPU path. And a simulation that already has `maxInFlight` batches in flight
+ * returns the OLDEST pending promise instead of submitting another, which is how a real GPU
+ * simulation keeps a frame loop from queueing work faster than the device retires it.
+ *
+ * What it computes depends on `computes`. By default a landed batch adds `moveBy * iterations`
+ * to the x coordinate of every node that is neither fixed nor being dragged and leaves y and z
+ * alone, which is exact and assertable and, on screen, invisible. Under `computes: "layout"` a
+ * batch runs the CPU simulation of the layout this one was built for instead, and every call this
+ * class takes -- `load`, `setFixed`, `setPosition`, `reheat`, `settled` -- is that simulation's.
+ */
+export declare class FakeSimulation implements LayoutSimulation {
+    #private;
+    /** The options this simulation was created with. */
+    readonly options: SimulationOptions;
+    /**
+     * Builds a simulation. The accelerator does this; a test reaches it through `fake.forceAtlas2()`.
+     * @param calls - The accelerator's counter bag, shared by every simulation it creates.
+     * @param defaults - The accelerator's own movement and settling defaults.
+     * @param defaults.moveBy - Scene units a landed batch moves one unfixed node, per iteration.
+     * @param defaults.settleAfter - Landed batches after which the simulation reports `settled`.
+     * @param defaults.maxInFlight - Batches accepted before a step coalesces onto the oldest.
+     * @param defaults.computes - Whether a batch translates the nodes or runs the real layout.
+     * @param type - Which layout this simulation is, which is what `computes: "layout"` runs.
+     * @param options - The simulation options the caller passed to the layout member.
+     */
+    constructor(calls: FakeAcceleratorCalls, defaults: {
+        moveBy: number;
+        settleAfter: number;
+        maxInFlight: number;
+        computes: "translation" | "layout";
+    }, type: SimulationType, options?: SimulationOptions);
+    /**
+     * The snapshot the last `load()` was given, or null before the first one.
+     * @returns The snapshot.
+     */
+    get snapshot(): GraphSnapshot | null;
+    /**
+     * The position array the last `load()` was given, written in place by every landed batch.
+     * @returns The array.
+     */
+    get positions(): F32 | null;
+    /**
+     * How many batches have landed since the last `reheat()`.
+     * @returns The count.
+     */
+    get iterationsDone(): number;
+    /**
+     * True once `settleAfter` batches have landed; false again after a `reheat()`.
+     * @returns Whether it has settled.
+     */
+    get settled(): boolean;
+    /**
+     * How many batches are in flight on this simulation.
+     * @returns The count.
+     */
+    get pending(): number;
+    /**
+     * True once `dispose()` has run.
+     * @returns Whether it was disposed.
+     */
+    get disposed(): boolean;
+    /**
+     * Adopts a snapshot and the owner's position array, which every later batch writes in place.
+     *
+     * Rows no layout has placed read as NaN, which is the element's "not placed yet"; they are
+     * seeded to the origin here, as a real simulation seeds them, so a landed batch moves a
+     * number rather than turning NaN into NaN. Only the snapshot's OWN rows are seeded: the
+     * element's position array outlives any one snapshot and its spare rows belong to nodes this
+     * graph does not have yet, whose NaN means "not placed" and must not become the origin.
+     * @param snapshot - The graph to lay out.
+     * @param positions - The owner's stride-3 scene-unit array.
+     */
+    load(snapshot: GraphSnapshot, positions: F32): void;
+    /**
+     * Submits one batch of `iterations`, or coalesces onto the oldest one already in flight.
+     * @param iterations - Iterations this batch computes. Defaults to the simulation's own.
+     * @returns The batch. Coalesced calls share the promise they landed on.
+     */
+    step(iterations?: number): Promise<void>;
+    /**
+     * Fixes the nodes whose bit is set; a fixed node is not moved by a landed batch.
+     * @param mask - The bitmask, copied rather than held.
+     */
+    setFixed(mask: NodeMask): void;
+    /**
+     * Places one node now, and keeps the next landed batch from moving it.
+     *
+     * That is what a drag needs: the pointer owns the node until the batch that was in flight
+     * when the drag began has landed, and a batch computed before the drag must not slide the
+     * node back.
+     * @param index - The node's dense row.
+     * @param x - The scene-unit x.
+     * @param y - The scene-unit y.
+     * @param z - The scene-unit z.
+     */
+    setPosition(index: number, x: number, y: number, z: number): void;
+    /** Starts the settle count again, so a settled simulation moves once more. */
+    reheat(): void;
+    /**
+     * Makes the NEXT submitted batch reject with this code.
+     * @param code - The code the rejection carries.
+     */
+    fail(code: GraphtyErrorCode): void;
+    /**
+     * Awaits every batch in flight on this simulation.
+     *
+     * A snapshot of the array, awaited once: looping until nothing is in flight never returns while
+     * something keeps submitting, which a story or a browser test with the frame loop running does.
+     */
+    flush(): Promise<void>;
+    /** Releases it. Every later call throws `E_DISPOSED`. */
+    dispose(): void;
+}
+/**
+ * The fake accelerator itself: the layout seam, three algorithm members, residency and the
+ * counters a test reads.
+ */
+export interface FakeAccelerator extends GraphAccelerator {
+    /** What the layout package's `LayoutAccelerator` calls itself. */
+    readonly kind: string;
+    /** Everything the fake was asked to do, aggregated over every simulation it created. */
+    readonly calls: FakeAcceleratorCalls;
+    /** The simulations it has created, oldest first, for the cases that need identity. */
+    readonly simulations: readonly FakeSimulation[];
+    /** How many batches are in flight over every simulation. */
+    readonly pending: number;
+    /**
+     * Builds a ForceAtlas2 simulation.
+     * @param options - The simulation options.
+     * @returns The simulation, also pushed onto `simulations`.
+     */
+    forceAtlas2(options?: ForceAtlas2Options): FakeSimulation;
+    /**
+     * Builds a Fruchterman-Reingold simulation.
+     * @param options - The simulation options.
+     * @returns The simulation, also pushed onto `simulations`.
+     */
+    fruchtermanReingold(options?: FruchtermanReingoldOptions): FakeSimulation;
+    /**
+     * Builds a spring-electrical simulation, which has no CPU implementation.
+     * @param options - The simulation options.
+     * @returns The simulation, also pushed onto `simulations`.
+     */
+    springElectrical(options?: SpringElectricalOptions): FakeSimulation;
+    /**
+     * Scores every node equally, so a caller sees a result shape without a computation.
+     * @param snapshot - The graph.
+     * @param options - Ignored.
+     * @returns Scores of `1 / n`, converged after one iteration.
+     */
+    pageRank(snapshot: GraphSnapshot, options?: IndexedPageRankOptions): Promise<PageRankResultLike>;
+    /**
+     * Puts every node in one component.
+     * @param snapshot - The graph.
+     * @returns One label, one group.
+     */
+    connectedComponents(snapshot: GraphSnapshot): Promise<LabelResultLike>;
+    /**
+     * Puts every node in one component, ignoring direction.
+     * @param snapshot - The graph.
+     * @returns One label, one group.
+     */
+    weaklyConnectedComponents(snapshot: GraphSnapshot): Promise<LabelResultLike>;
+    /**
+     * Records a snapshot as released. A real accelerator frees its device buffers here.
+     * @param snapshot - The snapshot whose residency is dropped.
+     */
+    release(snapshot: GraphSnapshot): void;
+    /** Records that the accelerator was disposed. */
+    dispose(): void;
+    /** Awaits every batch in flight over every simulation. */
+    flush(): Promise<void>;
+    /**
+     * Makes the next submitted batch of every live simulation reject.
+     * @param code - The code the rejection carries; `E_DEVICE_LOST` for the loss paths.
+     */
+    fail(code: GraphtyErrorCode): void;
+}
+/**
+ * Builds a deterministic fake accelerator.
+ * @param options - Its name, precision, movement, settling, coalescing and extra members.
+ * @returns The accelerator, with every member an own property so a feature test finds it.
+ * @example
+ * ```ts
+ * const fake = createFakeAccelerator({ moveBy: 2, settleAfter: 3 });
+ * element.session.setAccelerator(fake);
+ * await fake.flush();
+ * assert.strictEqual(fake.calls.step, fake.calls.resolved);
+ * ```
+ */
+export declare function createFakeAccelerator(options?: FakeAcceleratorOptions): FakeAccelerator;
+export {};

package/dist/webgpu.d.ts

@@ -9,7 +9,8 @@
  * Importing this module registers a WebGPU accelerator factory with the element and does
  * nothing else. After that line the element probes for an adapter, requests a context, builds
  * the accelerator, attaches it, watches for device loss, applies the `acceleration.minNodes`
- * threshold and publishes what it found. A consumer writes no probe, no construction, no
+ * threshold and publishes what it found. A software adapter is refused under `auto` and
+ * accepted under `required` (`acceptSoftware`). A consumer writes no probe, no construction, no
  * injection and no device-loss code, because every one of those would be the same code in every
  * application that wanted a GPU.
  *
@@ -24,6 +25,27 @@
  * and the rest stay on this side of the boundary; what crosses is a {@link GraphAccelerator},
  * which is plain names and functions, and failures arrive as codes on a `GraphtyError`.
  *
+ * ## A GPU that answers, and answers wrongly
+ *
+ * An adapter being present is not the same as an adapter being right. The software renderer that
+ * ships with Windows miscomputes shaders that pass a value across a workgroup barrier, so every
+ * multi-workgroup prefix sum -- and the sort, the histogram and the grid layout tier above one --
+ * comes back wrong, with plausible numbers and no error anywhere.
+ *
+ * So the accelerator this file builds implements `verify()`, and the element calls it at ATTACH,
+ * before any of the graph goes near the device: {@link checkDeviceComputes} runs the peer's own
+ * self-check, a real prefix sum of known numbers scanned through the shipped primitive and
+ * checked on the host, and turns a wrong word into `E_DEVICE_INCORRECT`. The element then
+ * reports acceleration unavailable with that code and draws the graph on the CPU. The peer
+ * memoises the result per device, so the 14 to 20 milliseconds are paid once and the accelerated
+ * runs that follow re-use the answer.
+ *
+ * That is detection, not a fallback: the decision is made before any accelerated work starts.
+ * The peer also guards its own compute entry points, so a device that somehow gets past the
+ * check still refuses rather than returning wrong numbers -- and the element lets go of it and
+ * republishes rather than finishing that work anywhere else. Recorded in
+ * `docs/decisions/device-computes-incorrectly.md`.
+ *
  * ## Detection is not a fallback
  *
  * Finding out, before anything runs, that this host has no WebGPU and letting the element take

package/dist/webgpu.js

@@ -1,71 +1,109 @@
-import { EXACT_MAX_NODES as c, createAccelerator as i } from "@graphty/webgpu-graph-algorithms";
-import { probeBrowserWebGpu as p, requestGpuContext as l } from "@graphty/webgpu-graph-algorithms/browser";
-import { r as d } from "./chunks/registry-DU-e49Y2.js";
-import { G as n } from "./chunks/GraphtyError-B3eKs4yg.js";
-const a = "webgpu-graph-algorithms", u = /* @__PURE__ */ new Set(["kind", "ctx", "options", "dispose"]);
-function h(o, r) {
-  for (const [e, t] of Object.entries(o))
-    u.has(e) || typeof t != "function" || (r[e] = t.bind(o));
+import { EXACT_MAX_NODES as n, createAccelerator as p, verifyDevice as u } from "@graphty/webgpu-graph-algorithms";
+import { probeBrowserWebGpu as l, requestGpuContext as d } from "@graphty/webgpu-graph-algorithms/browser";
+import { r as h } from "./chunks/registry-CSba5QGJ.js";
+import { G as s } from "./chunks/GraphtyError-BwcnblTH.js";
+const a = "webgpu-graph-algorithms", w = /* @__PURE__ */ new Set(["kind", "ctx", "options", "dispose", "verify"]);
+function b(o, e) {
+  for (const [r, t] of Object.entries(o))
+    w.has(r) || typeof t != "function" || (e[r] = t.bind(o));
 }
-function b(o, r) {
+function m(o, e) {
   const t = {
     E_NO_WEBGPU: typeof globalThis.isSecureContext == "boolean" && !globalThis.isSecureContext ? "WebGPU requires a secure context (https or localhost)" : "this browser has no WebGPU",
     E_NO_ADAPTER: "WebGPU is present but no graphics adapter would answer",
     E_SOFTWARE_ONLY: "the only WebGPU adapter here is a software renderer, which is slower than the CPU path"
   };
-  return new n({
+  return new s({
     code: o,
     message: t[o],
     source: "acceleration",
     recoverable: !1,
-    details: r === null ? { accelerator: a } : { accelerator: a, probe: r }
+    details: e === null ? { accelerator: a } : { accelerator: a, probe: e }
   });
 }
-function w(o, r) {
-  const { caps: e } = o, t = {
+async function f(o) {
+  const e = await u(o), { mismatch: r } = e;
+  if (r === null)
+    return;
+  const t = r.poison ? `${r.where} was never written at all` : `${r.where} came back as ${String(r.actual)} where ${String(r.expected)} was required`;
+  throw new s({
+    code: "E_DEVICE_INCORRECT",
+    message: `this GPU computes multi-workgroup shaders incorrectly: a prefix sum of ${String(e.count)} known numbers came back wrong -- ${t}. The graph is being computed on the processor instead, because every number this device produced would be unreliable`,
+    source: "acceleration",
+    recoverable: !1,
+    details: {
+      accelerator: a,
+      check: e.check,
+      where: r.where,
+      expected: r.expected,
+      actual: r.actual,
+      poison: r.poison,
+      count: e.count,
+      blocks: e.blocks,
+      workgroupSize: e.workgroupSize,
+      ms: e.ms,
+      adapter: {
+        vendor: e.vendor,
+        architecture: e.architecture,
+        description: e.description
+      }
+    }
+  });
+}
+function g(o, e) {
+  const { caps: r } = o, t = {
     name: a,
     backend: "webgpu",
     device: {
-      vendor: e.vendor,
-      architecture: e.architecture,
-      description: e.description === "" ? e.device : e.description
+      vendor: r.vendor,
+      architecture: r.architecture,
+      description: r.description === "" ? r.device : r.description
     },
     // Every GPU kernel in the peer computes in single precision, which is why a run that
     // used one is labelled f32 and the same run on the CPU path is labelled f64.
     precision: "f32",
     // The element watches this. A device the element itself destroyed also resolves it, and
     // the controller ignores a loss reported for an accelerator it has already released.
-    lost: o.lost.then((s) => ({ reason: s.message === "" ? s.reason : s.message })),
+    lost: o.lost.then((c) => ({ reason: c.message === "" ? c.reason : c.message })),
+    // The element calls this once, before it attaches this accelerator and before any of the
+    // graph reaches the device. `NOT_FORWARDED` is what keeps the forwarding pass below from
+    // replacing it.
+    verify: () => f(o),
     dispose: () => {
-      r.dispose();
+      e.dispose();
     }
   };
-  return h(r, t), t;
+  return b(e, t), t;
 }
 async function E(o) {
-  const { exactMaxNodes: r } = o ?? {};
-  if (r !== void 0 && r > c)
-    throw new n({
+  const { exactMaxNodes: e } = o ?? {};
+  if (e !== void 0 && e > n)
+    throw new s({
       code: "E_TOO_LARGE",
-      message: `the WebGPU accelerator computes exactly up to ${String(c)} nodes, not ${String(r)}`,
+      message: `the WebGPU accelerator computes exactly up to ${String(n)} nodes, not ${String(e)}`,
       source: "acceleration",
-      details: { accelerator: a, exactMaxNodes: r, limit: c }
+      details: { accelerator: a, exactMaxNodes: e, limit: n }
     });
-  const e = await p();
-  if (!e.ok || e.code !== "OK")
-    throw b(e.code === "OK" ? "E_NO_ADAPTER" : e.code, e.reason);
-  const t = await l(e.adapter === null ? {} : { adapter: e.adapter });
+  const r = !(o?.acceptSoftware ?? !1), t = await l({ rejectSoftware: r });
+  if (!t.ok || t.code !== "OK")
+    throw m(t.code === "OK" ? "E_NO_ADAPTER" : t.code, t.reason);
+  const c = await d(
+    t.adapter === null ? { rejectSoftware: r } : { adapter: t.adapter, rejectSoftware: r }
+  );
   try {
-    return w(t, i(t));
-  } catch (s) {
-    throw t.dispose(), n.wrap(s, {
+    return g(
+      c,
+      p(c, e === void 0 ? void 0 : { layout: { exactMaxNodes: e } })
+    );
+  } catch (i) {
+    throw c.dispose(), s.wrap(i, {
       code: "E_INTERNAL",
       source: "acceleration",
       details: { accelerator: a }
     });
   }
 }
-d({
+h({
   name: a,
   backend: "webgpu",
   factory: E

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphty/graphty-element",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "A Web Component library for 3D/2D graph visualization built with Lit and Babylon.js",
   "type": "module",
   "customElements": "./dist/custom-elements.json",
@@ -60,6 +60,7 @@
     "./dist/graphty.bundle.js",
     "./dist/webgpu.js",
     "./dist/chunks/*.js",
+    "./webgpu.ts",
     "./src/algorithms/index.ts",
     "./src/data/index.ts",
     "./src/layout/index.ts",
@@ -112,6 +113,7 @@
     "@types/hammerjs": "^2.0.46",
     "@types/jmespath": "^0.15.2",
     "@types/lodash": "^4.17.19",
+    "@types/papaparse": "^5.5.0",
     "@types/toposort": "^2.0.7",
     "ai": "^5.0.104",
     "encrypt-storage": "^2.14.7",
@@ -119,6 +121,8 @@
     "fast-check": "^4.2.0",
     "iwer": "^2.1.1",
     "lit": "^3.3.1",
+    "lodash": "^4.17.21",
+    "ngraph.random": "^1.2.0",
     "pngjs": "^7.0.0",
     "storybook": "^9.1.20",
     "typedoc": "^0.28.15",
@@ -128,7 +132,9 @@
     "vite-plugin-cem": "^0.8.2",
     "vite-plugin-eslint": "^1.8.1",
     "vitepress": "^1.6.3",
-    "vitest": "^3.2.4"
+    "vitest": "^3.2.4",
+    "@graphty/remote-logger": "^1.3.6",
+    "@graphty/webgpu-graph-algorithms": "^0.6.3"
   },
   "peerDependencies": {
     "@ai-sdk/anthropic": "^2.0.50",
@@ -136,11 +142,11 @@
     "@ai-sdk/openai": "^2.0.74",
     "@babylonjs/core": "^8.0.0",
     "@graphty/graph-format": "^1.0.0",
-    "@graphty/webgpu-graph-algorithms": "^0.2.0",
     "@mlc-ai/web-llm": ">=0.2.0",
     "ai": "^5.0.104",
     "encrypt-storage": "^2.14.7",
-    "lit": "^3.0.0"
+    "lit": "^3.0.0",
+    "@graphty/webgpu-graph-algorithms": "^0.6.3"
   },
   "peerDependenciesMeta": {
     "@ai-sdk/anthropic": {
@@ -167,23 +173,20 @@
   },
   "dependencies": {
     "@jsonhero/schema-infer": "^0.1.5",
-    "@types/papaparse": "^5.5.0",
     "colorjs.io": "^0.5.2",
     "d3-force-3d": "^3.0.6",
     "fast-xml-parser": "^5.3.1",
     "hammerjs": "^2.0.8",
     "jmespath": "^0.16.0",
-    "lodash": "^4.17.21",
     "ngraph.forcelayout": "^3.3.1",
     "ngraph.graph": "^20.0.1",
     "p-queue": "^8.1.1",
     "papaparse": "^5.5.3",
     "toposort": "^2.0.2",
     "zod": "^3.25.28",
-    "@graphty/graph-format": "^1.0.2",
-    "@graphty/algorithms": "^2.0.0",
-    "@graphty/layout": "^1.8.1",
-    "@graphty/remote-logger": "^1.3.4"
+    "@graphty/algorithms": "^2.0.2",
+    "@graphty/graph-format": "^1.0.4",
+    "@graphty/layout": "^1.9.0"
   },
   "overrides": {
     "storybook": "$storybook"
@@ -241,7 +244,8 @@
     "coverage:shard:storybook:4": "COVERAGE_DIR=.coverage-parts/storybook-4 vitest run --project=storybook --shard=4/4 --coverage",
     "coverage:fast": "vitest run --project=default --coverage",
     "coverage:preview": "npx serve coverage -p ${PORT:?start it through servherd, which sets PORT}",
-    "lint": "eslint && tsc --noEmit",
+    "lint": "eslint && tsc --noEmit && npm run typecheck:strict-consumer",
+    "typecheck:strict-consumer": "tsc -p tsconfig.strict-consumer.json",
     "lint:fix": "eslint --fix",
     "lint:knip": "cd .. && ./tools/run-knip.sh --workspace graphty-element",
     "dev": "vite --force --mode development --port ${PORT:?start it through servherd, which sets PORT} --strictPort",