@memnest/ui-core 0.0.0

package/dist/index.cjs

@@ -0,0 +1,2398 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CLUSTER_THRESHOLD: () => CLUSTER_THRESHOLD,
+  DEFAULT_GRAPH_FILTER: () => DEFAULT_GRAPH_FILTER,
+  DEFAULT_TRACE_BUDGET: () => DEFAULT_TRACE_BUDGET,
+  GRAPH_LOAD_LIMIT: () => GRAPH_LOAD_LIMIT,
+  IDENTITY_VIEWPORT: () => IDENTITY_VIEWPORT,
+  WORKER_LAYOUT_THRESHOLD: () => WORKER_LAYOUT_THRESHOLD,
+  ZOOM_LIMITS: () => ZOOM_LIMITS,
+  boundsOf: () => boundsOf,
+  buildGraphScene: () => buildGraphScene,
+  buildTimeline: () => buildTimeline,
+  buildTraceRows: () => buildTraceRows,
+  clamp: () => clamp,
+  clusterNodes: () => clusterNodes,
+  clusterRadius: () => clusterRadius,
+  computeLayout: () => computeLayout,
+  createDetailController: () => createDetailController,
+  createFinderController: () => createFinderController,
+  createGraphController: () => createGraphController,
+  createHitIndex: () => createHitIndex,
+  createLineageController: () => createLineageController,
+  createSequencer: () => createSequencer,
+  createStore: () => createStore,
+  createTimelineController: () => createTimelineController,
+  createTraceController: () => createTraceController,
+  createWorkerLayoutRunner: () => createWorkerLayoutRunner,
+  createWorkspace: () => createWorkspace,
+  documentRadius: () => documentRadius,
+  drawScene: () => drawScene,
+  fitViewport: () => fitViewport,
+  forceLayout: () => forceLayout,
+  inlineLayoutRunner: () => inlineLayoutRunner,
+  layeredLayout: () => layeredLayout,
+  layoutLineage: () => layoutLineage,
+  matchesFilter: () => matchesFilter,
+  nodeRadius: () => nodeRadius,
+  panBy: () => panBy,
+  runLayoutRequest: () => runLayoutRequest,
+  seededRandom: () => seededRandom,
+  serveLayoutRequests: () => serveLayoutRequests,
+  shorten: () => shorten,
+  timeTicks: () => timeTicks,
+  toScreen: () => toScreen,
+  toWorld: () => toWorld,
+  versionChain: () => versionChain,
+  zoomAt: () => zoomAt
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/store.ts
+function createStore(initial) {
+  let state = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    set(patch) {
+      const next = typeof patch === "function" ? patch(state) : patch;
+      state = { ...state, ...next };
+      for (const listener of [...listeners]) listener();
+    }
+  };
+}
+function createSequencer() {
+  let current = 0;
+  return {
+    next: () => ++current,
+    isCurrent: (token) => token === current,
+    /** Invalidates everything in flight (dispose). */
+    cancel: () => {
+      current++;
+    }
+  };
+}
+var errorText = (error) => error instanceof Error ? error.message : String(error);
+
+// src/geometry.ts
+var IDENTITY_VIEWPORT = { x: 0, y: 0, k: 1 };
+var ZOOM_LIMITS = { min: 0.02, max: 8 };
+function boundsOf(circles) {
+  let bounds = null;
+  for (const { x: x3, y: y3, r = 0 } of circles) {
+    if (!bounds) bounds = { minX: x3 - r, minY: y3 - r, maxX: x3 + r, maxY: y3 + r };
+    else {
+      bounds.minX = Math.min(bounds.minX, x3 - r);
+      bounds.minY = Math.min(bounds.minY, y3 - r);
+      bounds.maxX = Math.max(bounds.maxX, x3 + r);
+      bounds.maxY = Math.max(bounds.maxY, y3 + r);
+    }
+  }
+  return bounds;
+}
+function fitViewport(bounds, size, padding = 60, maxK = 2.5) {
+  if (!bounds || size.width <= 0 || size.height <= 0) return { x: size.width / 2, y: size.height / 2, k: 1 };
+  const width = Math.max(bounds.maxX - bounds.minX, 1);
+  const height = Math.max(bounds.maxY - bounds.minY, 1);
+  const k = clamp(
+    Math.min((size.width - padding * 2) / width, (size.height - padding * 2) / height),
+    ZOOM_LIMITS.min,
+    maxK
+  );
+  const cx = (bounds.minX + bounds.maxX) / 2;
+  const cy = (bounds.minY + bounds.maxY) / 2;
+  return { x: size.width / 2 - cx * k, y: size.height / 2 - cy * k, k };
+}
+function zoomAt(viewport, screen, factor) {
+  const k = clamp(viewport.k * factor, ZOOM_LIMITS.min, ZOOM_LIMITS.max);
+  const world = toWorld(viewport, screen);
+  return { x: screen.x - world.x * k, y: screen.y - world.y * k, k };
+}
+var panBy = (viewport, dx, dy) => ({ ...viewport, x: viewport.x + dx, y: viewport.y + dy });
+var toWorld = (viewport, screen) => ({ x: (screen.x - viewport.x) / viewport.k, y: (screen.y - viewport.y) / viewport.k });
+var toScreen = (viewport, world) => ({ x: world.x * viewport.k + viewport.x, y: world.y * viewport.k + viewport.y });
+var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+
+// ../../node_modules/.pnpm/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/add.js
+function add_default(d) {
+  const x3 = +this._x.call(null, d), y3 = +this._y.call(null, d);
+  return add(this.cover(x3, y3), x3, y3, d);
+}
+function add(tree, x3, y3, d) {
+  if (isNaN(x3) || isNaN(y3)) return tree;
+  var parent, node = tree._root, leaf = { data: d }, x0 = tree._x0, y0 = tree._y0, x1 = tree._x1, y1 = tree._y1, xm, ym, xp, yp, right, bottom, i, j;
+  if (!node) return tree._root = leaf, tree;
+  while (node.length) {
+    if (right = x3 >= (xm = (x0 + x1) / 2)) x0 = xm;
+    else x1 = xm;
+    if (bottom = y3 >= (ym = (y0 + y1) / 2)) y0 = ym;
+    else y1 = ym;
+    if (parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree;
+  }
+  xp = +tree._x.call(null, node.data);
+  yp = +tree._y.call(null, node.data);
+  if (x3 === xp && y3 === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree;
+  do {
+    parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4);
+    if (right = x3 >= (xm = (x0 + x1) / 2)) x0 = xm;
+    else x1 = xm;
+    if (bottom = y3 >= (ym = (y0 + y1) / 2)) y0 = ym;
+    else y1 = ym;
+  } while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | xp >= xm));
+  return parent[j] = node, parent[i] = leaf, tree;
+}
+function addAll(data) {
+  var d, i, n = data.length, x3, y3, xz = new Array(n), yz = new Array(n), x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (i = 0; i < n; ++i) {
+    if (isNaN(x3 = +this._x.call(null, d = data[i])) || isNaN(y3 = +this._y.call(null, d))) continue;
+    xz[i] = x3;
+    yz[i] = y3;
+    if (x3 < x0) x0 = x3;
+    if (x3 > x1) x1 = x3;
+    if (y3 < y0) y0 = y3;
+    if (y3 > y1) y1 = y3;
+  }
+  if (x0 > x1 || y0 > y1) return this;
+  this.cover(x0, y0).cover(x1, y1);
+  for (i = 0; i < n; ++i) {
+    add(this, xz[i], yz[i], data[i]);
+  }
+  return this;
+}
+
+// ../../node_modules/.pnpm/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/cover.js
+function cover_default(x3, y3) {
+  if (isNaN(x3 = +x3) || isNaN(y3 = +y3)) return this;
+  var x0 = this._x0, y0 = this._y0, x1 = this._x1, y1 = this._y1;
+  if (isNaN(x0)) {
+    x1 = (x0 = Math.floor(x3)) + 1;
+    y1 = (y0 = Math.floor(y3)) + 1;
+  } else {
+    var z = x1 - x0 || 1, node = this._root, parent, i;
+    while (x0 > x3 || x3 >= x1 || y0 > y3 || y3 >= y1) {
+      i = (y3 < y0) << 1 | x3 < x0;
+      parent = new Array(4), parent[i] = node, node = parent, z *= 2;
+      switch (i) {
+        case 0:
+          x1 = x0 + z, y1 = y0 + z;
+          break;
+        case 1:
+          x0 = x1 - z, y1 = y0 + z;
+          break;
+        case 2:
+          x1 = x0 + z, y0 = y1 - z;
+          break;
+        case 3:
+          x0 = x1 - z, y0 = y1 - z;
+          break;
+      }
+    }
+    if (this._root && this._root.length) this._root = node;
+  }
+  this._x0 = x0;
+  this._y0 = y0;
+  this._x1 = x1;
+  this._y1 = y1;
+  return this;
+}
+
+// ../../node_modules/.pnpm/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/data.js
+function data_default() {
+  var data = [];
+  this.visit(function(node) {
+    if (!node.length) do
+      data.push(node.data);
+    while (node = node.next);
+  });
+  return data;
+}
+
+// ../../node_modules/.pnpm/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/extent.js
+function extent_default(_) {
+  return arguments.length ? this.cover(+_[0][0], +_[0][1]).cover(+_[1][0], +_[1][1]) : isNaN(this._x0) ? void 0 : [[this._x0, this._y0], [this._x1, this._y1]];
+}
+
+// ../../node_modules/.pnpm/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/quad.js
+function quad_default(node, x0, y0, x1, y1) {
+  this.node = node;
+  this.x0 = x0;
+  this.y0 = y0;
+  this.x1 = x1;
+  this.y1 = y1;
+}
+
+// ../../node_modules/.pnpm/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/find.js
+function find_default(x3, y3, radius) {
+  var data, x0 = this._x0, y0 = this._y0, x1, y1, x22, y22, x32 = this._x1, y32 = this._y1, quads = [], node = this._root, q, i;
+  if (node) quads.push(new quad_default(node, x0, y0, x32, y32));
+  if (radius == null) radius = Infinity;
+  else {
+    x0 = x3 - radius, y0 = y3 - radius;
+    x32 = x3 + radius, y32 = y3 + radius;
+    radius *= radius;
+  }
+  while (q = quads.pop()) {
+    if (!(node = q.node) || (x1 = q.x0) > x32 || (y1 = q.y0) > y32 || (x22 = q.x1) < x0 || (y22 = q.y1) < y0) continue;
+    if (node.length) {
+      var xm = (x1 + x22) / 2, ym = (y1 + y22) / 2;
+      quads.push(
+        new quad_default(node[3], xm, ym, x22, y22),
+        new quad_default(node[2], x1, ym, xm, y22),
+        new quad_default(node[1], xm, y1, x22, ym),
+        new quad_default(node[0], x1, y1, xm, ym)
+      );
+      if (i = (y3 >= ym) << 1 | x3 >= xm) {
+        q = quads[quads.length - 1];
+        quads[quads.length - 1] = quads[quads.length - 1 - i];
+        quads[quads.length - 1 - i] = q;
+      }
+    } else {
+      var dx = x3 - +this._x.call(null, node.data), dy = y3 - +this._y.call(null, node.data), d2 = dx * dx + dy * dy;
+      if (d2 < radius) {
+        var d = Math.sqrt(radius = d2);
+        x0 = x3 - d, y0 = y3 - d;
+        x32 = x3 + d, y32 = y3 + d;
+        data = node.data;
+      }
+    }
+  }
+  return data;
+}
+
+// ../../node_modules/.pnpm/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/remove.js
+function remove_default(d) {
+  if (isNaN(x3 = +this._x.call(null, d)) || isNaN(y3 = +this._y.call(null, d))) return this;
+  var parent, node = this._root, retainer, previous, next, x0 = this._x0, y0 = this._y0, x1 = this._x1, y1 = this._y1, x3, y3, xm, ym, right, bottom, i, j;
+  if (!node) return this;
+  if (node.length) while (true) {
+    if (right = x3 >= (xm = (x0 + x1) / 2)) x0 = xm;
+    else x1 = xm;
+    if (bottom = y3 >= (ym = (y0 + y1) / 2)) y0 = ym;
+    else y1 = ym;
+    if (!(parent = node, node = node[i = bottom << 1 | right])) return this;
+    if (!node.length) break;
+    if (parent[i + 1 & 3] || parent[i + 2 & 3] || parent[i + 3 & 3]) retainer = parent, j = i;
+  }
+  while (node.data !== d) if (!(previous = node, node = node.next)) return this;
+  if (next = node.next) delete node.next;
+  if (previous) return next ? previous.next = next : delete previous.next, this;
+  if (!parent) return this._root = next, this;
+  next ? parent[i] = next : delete parent[i];
+  if ((node = parent[0] || parent[1] || parent[2] || parent[3]) && node === (parent[3] || parent[2] || parent[1] || parent[0]) && !node.length) {
+    if (retainer) retainer[j] = node;
+    else this._root = node;
+  }
+  return this;
+}
+function removeAll(data) {
+  for (var i = 0, n = data.length; i < n; ++i) this.remove(data[i]);
+  return this;
+}
+
+// ../../node_modules/.pnpm/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/root.js
+function root_default() {
+  return this._root;
+}
+
+// ../../node_modules/.pnpm/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/size.js
+function size_default() {
+  var size = 0;
+  this.visit(function(node) {
+    if (!node.length) do
+      ++size;
+    while (node = node.next);
+  });
+  return size;
+}
+
+// ../../node_modules/.pnpm/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/visit.js
+function visit_default(callback) {
+  var quads = [], q, node = this._root, child, x0, y0, x1, y1;
+  if (node) quads.push(new quad_default(node, this._x0, this._y0, this._x1, this._y1));
+  while (q = quads.pop()) {
+    if (!callback(node = q.node, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1) && node.length) {
+      var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;
+      if (child = node[3]) quads.push(new quad_default(child, xm, ym, x1, y1));
+      if (child = node[2]) quads.push(new quad_default(child, x0, ym, xm, y1));
+      if (child = node[1]) quads.push(new quad_default(child, xm, y0, x1, ym));
+      if (child = node[0]) quads.push(new quad_default(child, x0, y0, xm, ym));
+    }
+  }
+  return this;
+}
+
+// ../../node_modules/.pnpm/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/visitAfter.js
+function visitAfter_default(callback) {
+  var quads = [], next = [], q;
+  if (this._root) quads.push(new quad_default(this._root, this._x0, this._y0, this._x1, this._y1));
+  while (q = quads.pop()) {
+    var node = q.node;
+    if (node.length) {
+      var child, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;
+      if (child = node[0]) quads.push(new quad_default(child, x0, y0, xm, ym));
+      if (child = node[1]) quads.push(new quad_default(child, xm, y0, x1, ym));
+      if (child = node[2]) quads.push(new quad_default(child, x0, ym, xm, y1));
+      if (child = node[3]) quads.push(new quad_default(child, xm, ym, x1, y1));
+    }
+    next.push(q);
+  }
+  while (q = next.pop()) {
+    callback(q.node, q.x0, q.y0, q.x1, q.y1);
+  }
+  return this;
+}
+
+// ../../node_modules/.pnpm/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/x.js
+function defaultX(d) {
+  return d[0];
+}
+function x_default(_) {
+  return arguments.length ? (this._x = _, this) : this._x;
+}
+
+// ../../node_modules/.pnpm/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/y.js
+function defaultY(d) {
+  return d[1];
+}
+function y_default(_) {
+  return arguments.length ? (this._y = _, this) : this._y;
+}
+
+// ../../node_modules/.pnpm/d3-quadtree@3.0.1/node_modules/d3-quadtree/src/quadtree.js
+function quadtree(nodes, x3, y3) {
+  var tree = new Quadtree(x3 == null ? defaultX : x3, y3 == null ? defaultY : y3, NaN, NaN, NaN, NaN);
+  return nodes == null ? tree : tree.addAll(nodes);
+}
+function Quadtree(x3, y3, x0, y0, x1, y1) {
+  this._x = x3;
+  this._y = y3;
+  this._x0 = x0;
+  this._y0 = y0;
+  this._x1 = x1;
+  this._y1 = y1;
+  this._root = void 0;
+}
+function leaf_copy(leaf) {
+  var copy = { data: leaf.data }, next = copy;
+  while (leaf = leaf.next) next = next.next = { data: leaf.data };
+  return copy;
+}
+var treeProto = quadtree.prototype = Quadtree.prototype;
+treeProto.copy = function() {
+  var copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1), node = this._root, nodes, child;
+  if (!node) return copy;
+  if (!node.length) return copy._root = leaf_copy(node), copy;
+  nodes = [{ source: node, target: copy._root = new Array(4) }];
+  while (node = nodes.pop()) {
+    for (var i = 0; i < 4; ++i) {
+      if (child = node.source[i]) {
+        if (child.length) nodes.push({ source: child, target: node.target[i] = new Array(4) });
+        else node.target[i] = leaf_copy(child);
+      }
+    }
+  }
+  return copy;
+};
+treeProto.add = add_default;
+treeProto.addAll = addAll;
+treeProto.cover = cover_default;
+treeProto.data = data_default;
+treeProto.extent = extent_default;
+treeProto.find = find_default;
+treeProto.remove = remove_default;
+treeProto.removeAll = removeAll;
+treeProto.root = root_default;
+treeProto.size = size_default;
+treeProto.visit = visit_default;
+treeProto.visitAfter = visitAfter_default;
+treeProto.x = x_default;
+treeProto.y = y_default;
+
+// ../../node_modules/.pnpm/d3-force@3.0.0/node_modules/d3-force/src/constant.js
+function constant_default(x3) {
+  return function() {
+    return x3;
+  };
+}
+
+// ../../node_modules/.pnpm/d3-force@3.0.0/node_modules/d3-force/src/jiggle.js
+function jiggle_default(random) {
+  return (random() - 0.5) * 1e-6;
+}
+
+// ../../node_modules/.pnpm/d3-force@3.0.0/node_modules/d3-force/src/collide.js
+function x(d) {
+  return d.x + d.vx;
+}
+function y(d) {
+  return d.y + d.vy;
+}
+function collide_default(radius) {
+  var nodes, radii, random, strength = 1, iterations = 1;
+  if (typeof radius !== "function") radius = constant_default(radius == null ? 1 : +radius);
+  function force() {
+    var i, n = nodes.length, tree, node, xi, yi, ri, ri2;
+    for (var k = 0; k < iterations; ++k) {
+      tree = quadtree(nodes, x, y).visitAfter(prepare);
+      for (i = 0; i < n; ++i) {
+        node = nodes[i];
+        ri = radii[node.index], ri2 = ri * ri;
+        xi = node.x + node.vx;
+        yi = node.y + node.vy;
+        tree.visit(apply);
+      }
+    }
+    function apply(quad, x0, y0, x1, y1) {
+      var data = quad.data, rj = quad.r, r = ri + rj;
+      if (data) {
+        if (data.index > node.index) {
+          var x3 = xi - data.x - data.vx, y3 = yi - data.y - data.vy, l = x3 * x3 + y3 * y3;
+          if (l < r * r) {
+            if (x3 === 0) x3 = jiggle_default(random), l += x3 * x3;
+            if (y3 === 0) y3 = jiggle_default(random), l += y3 * y3;
+            l = (r - (l = Math.sqrt(l))) / l * strength;
+            node.vx += (x3 *= l) * (r = (rj *= rj) / (ri2 + rj));
+            node.vy += (y3 *= l) * r;
+            data.vx -= x3 * (r = 1 - r);
+            data.vy -= y3 * r;
+          }
+        }
+        return;
+      }
+      return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r;
+    }
+  }
+  function prepare(quad) {
+    if (quad.data) return quad.r = radii[quad.data.index];
+    for (var i = quad.r = 0; i < 4; ++i) {
+      if (quad[i] && quad[i].r > quad.r) {
+        quad.r = quad[i].r;
+      }
+    }
+  }
+  function initialize() {
+    if (!nodes) return;
+    var i, n = nodes.length, node;
+    radii = new Array(n);
+    for (i = 0; i < n; ++i) node = nodes[i], radii[node.index] = +radius(node, i, nodes);
+  }
+  force.initialize = function(_nodes, _random) {
+    nodes = _nodes;
+    random = _random;
+    initialize();
+  };
+  force.iterations = function(_) {
+    return arguments.length ? (iterations = +_, force) : iterations;
+  };
+  force.strength = function(_) {
+    return arguments.length ? (strength = +_, force) : strength;
+  };
+  force.radius = function(_) {
+    return arguments.length ? (radius = typeof _ === "function" ? _ : constant_default(+_), initialize(), force) : radius;
+  };
+  return force;
+}
+
+// ../../node_modules/.pnpm/d3-force@3.0.0/node_modules/d3-force/src/link.js
+function index(d) {
+  return d.index;
+}
+function find(nodeById, nodeId) {
+  var node = nodeById.get(nodeId);
+  if (!node) throw new Error("node not found: " + nodeId);
+  return node;
+}
+function link_default(links) {
+  var id = index, strength = defaultStrength, strengths, distance = constant_default(30), distances, nodes, count, bias, random, iterations = 1;
+  if (links == null) links = [];
+  function defaultStrength(link) {
+    return 1 / Math.min(count[link.source.index], count[link.target.index]);
+  }
+  function force(alpha) {
+    for (var k = 0, n = links.length; k < iterations; ++k) {
+      for (var i = 0, link, source, target, x3, y3, l, b; i < n; ++i) {
+        link = links[i], source = link.source, target = link.target;
+        x3 = target.x + target.vx - source.x - source.vx || jiggle_default(random);
+        y3 = target.y + target.vy - source.y - source.vy || jiggle_default(random);
+        l = Math.sqrt(x3 * x3 + y3 * y3);
+        l = (l - distances[i]) / l * alpha * strengths[i];
+        x3 *= l, y3 *= l;
+        target.vx -= x3 * (b = bias[i]);
+        target.vy -= y3 * b;
+        source.vx += x3 * (b = 1 - b);
+        source.vy += y3 * b;
+      }
+    }
+  }
+  function initialize() {
+    if (!nodes) return;
+    var i, n = nodes.length, m2 = links.length, nodeById = new Map(nodes.map((d, i2) => [id(d, i2, nodes), d])), link;
+    for (i = 0, count = new Array(n); i < m2; ++i) {
+      link = links[i], link.index = i;
+      if (typeof link.source !== "object") link.source = find(nodeById, link.source);
+      if (typeof link.target !== "object") link.target = find(nodeById, link.target);
+      count[link.source.index] = (count[link.source.index] || 0) + 1;
+      count[link.target.index] = (count[link.target.index] || 0) + 1;
+    }
+    for (i = 0, bias = new Array(m2); i < m2; ++i) {
+      link = links[i], bias[i] = count[link.source.index] / (count[link.source.index] + count[link.target.index]);
+    }
+    strengths = new Array(m2), initializeStrength();
+    distances = new Array(m2), initializeDistance();
+  }
+  function initializeStrength() {
+    if (!nodes) return;
+    for (var i = 0, n = links.length; i < n; ++i) {
+      strengths[i] = +strength(links[i], i, links);
+    }
+  }
+  function initializeDistance() {
+    if (!nodes) return;
+    for (var i = 0, n = links.length; i < n; ++i) {
+      distances[i] = +distance(links[i], i, links);
+    }
+  }
+  force.initialize = function(_nodes, _random) {
+    nodes = _nodes;
+    random = _random;
+    initialize();
+  };
+  force.links = function(_) {
+    return arguments.length ? (links = _, initialize(), force) : links;
+  };
+  force.id = function(_) {
+    return arguments.length ? (id = _, force) : id;
+  };
+  force.iterations = function(_) {
+    return arguments.length ? (iterations = +_, force) : iterations;
+  };
+  force.strength = function(_) {
+    return arguments.length ? (strength = typeof _ === "function" ? _ : constant_default(+_), initializeStrength(), force) : strength;
+  };
+  force.distance = function(_) {
+    return arguments.length ? (distance = typeof _ === "function" ? _ : constant_default(+_), initializeDistance(), force) : distance;
+  };
+  return force;
+}
+
+// ../../node_modules/.pnpm/d3-dispatch@3.0.1/node_modules/d3-dispatch/src/dispatch.js
+var noop = { value: () => {
+} };
+function dispatch() {
+  for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) {
+    if (!(t = arguments[i] + "") || t in _ || /[\s.]/.test(t)) throw new Error("illegal type: " + t);
+    _[t] = [];
+  }
+  return new Dispatch(_);
+}
+function Dispatch(_) {
+  this._ = _;
+}
+function parseTypenames(typenames, types) {
+  return typenames.trim().split(/^|\s+/).map(function(t) {
+    var name = "", i = t.indexOf(".");
+    if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);
+    if (t && !types.hasOwnProperty(t)) throw new Error("unknown type: " + t);
+    return { type: t, name };
+  });
+}
+Dispatch.prototype = dispatch.prototype = {
+  constructor: Dispatch,
+  on: function(typename, callback) {
+    var _ = this._, T = parseTypenames(typename + "", _), t, i = -1, n = T.length;
+    if (arguments.length < 2) {
+      while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;
+      return;
+    }
+    if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback);
+    while (++i < n) {
+      if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback);
+      else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null);
+    }
+    return this;
+  },
+  copy: function() {
+    var copy = {}, _ = this._;
+    for (var t in _) copy[t] = _[t].slice();
+    return new Dispatch(copy);
+  },
+  call: function(type, that) {
+    if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2];
+    if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type);
+    for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);
+  },
+  apply: function(type, that, args) {
+    if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type);
+    for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);
+  }
+};
+function get(type, name) {
+  for (var i = 0, n = type.length, c2; i < n; ++i) {
+    if ((c2 = type[i]).name === name) {
+      return c2.value;
+    }
+  }
+}
+function set(type, name, callback) {
+  for (var i = 0, n = type.length; i < n; ++i) {
+    if (type[i].name === name) {
+      type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1));
+      break;
+    }
+  }
+  if (callback != null) type.push({ name, value: callback });
+  return type;
+}
+var dispatch_default = dispatch;
+
+// ../../node_modules/.pnpm/d3-timer@3.0.1/node_modules/d3-timer/src/timer.js
+var frame = 0;
+var timeout = 0;
+var interval = 0;
+var pokeDelay = 1e3;
+var taskHead;
+var taskTail;
+var clockLast = 0;
+var clockNow = 0;
+var clockSkew = 0;
+var clock = typeof performance === "object" && performance.now ? performance : Date;
+var setFrame = typeof window === "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f) {
+  setTimeout(f, 17);
+};
+function now() {
+  return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);
+}
+function clearNow() {
+  clockNow = 0;
+}
+function Timer() {
+  this._call = this._time = this._next = null;
+}
+Timer.prototype = timer.prototype = {
+  constructor: Timer,
+  restart: function(callback, delay, time) {
+    if (typeof callback !== "function") throw new TypeError("callback is not a function");
+    time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);
+    if (!this._next && taskTail !== this) {
+      if (taskTail) taskTail._next = this;
+      else taskHead = this;
+      taskTail = this;
+    }
+    this._call = callback;
+    this._time = time;
+    sleep();
+  },
+  stop: function() {
+    if (this._call) {
+      this._call = null;
+      this._time = Infinity;
+      sleep();
+    }
+  }
+};
+function timer(callback, delay, time) {
+  var t = new Timer();
+  t.restart(callback, delay, time);
+  return t;
+}
+function timerFlush() {
+  now();
+  ++frame;
+  var t = taskHead, e;
+  while (t) {
+    if ((e = clockNow - t._time) >= 0) t._call.call(void 0, e);
+    t = t._next;
+  }
+  --frame;
+}
+function wake() {
+  clockNow = (clockLast = clock.now()) + clockSkew;
+  frame = timeout = 0;
+  try {
+    timerFlush();
+  } finally {
+    frame = 0;
+    nap();
+    clockNow = 0;
+  }
+}
+function poke() {
+  var now2 = clock.now(), delay = now2 - clockLast;
+  if (delay > pokeDelay) clockSkew -= delay, clockLast = now2;
+}
+function nap() {
+  var t0, t1 = taskHead, t2, time = Infinity;
+  while (t1) {
+    if (t1._call) {
+      if (time > t1._time) time = t1._time;
+      t0 = t1, t1 = t1._next;
+    } else {
+      t2 = t1._next, t1._next = null;
+      t1 = t0 ? t0._next = t2 : taskHead = t2;
+    }
+  }
+  taskTail = t0;
+  sleep(time);
+}
+function sleep(time) {
+  if (frame) return;
+  if (timeout) timeout = clearTimeout(timeout);
+  var delay = time - clockNow;
+  if (delay > 24) {
+    if (time < Infinity) timeout = setTimeout(wake, time - clock.now() - clockSkew);
+    if (interval) interval = clearInterval(interval);
+  } else {
+    if (!interval) clockLast = clock.now(), interval = setInterval(poke, pokeDelay);
+    frame = 1, setFrame(wake);
+  }
+}
+
+// ../../node_modules/.pnpm/d3-force@3.0.0/node_modules/d3-force/src/lcg.js
+var a = 1664525;
+var c = 1013904223;
+var m = 4294967296;
+function lcg_default() {
+  let s = 1;
+  return () => (s = (a * s + c) % m) / m;
+}
+
+// ../../node_modules/.pnpm/d3-force@3.0.0/node_modules/d3-force/src/simulation.js
+function x2(d) {
+  return d.x;
+}
+function y2(d) {
+  return d.y;
+}
+var initialRadius = 10;
+var initialAngle = Math.PI * (3 - Math.sqrt(5));
+function simulation_default(nodes) {
+  var simulation, alpha = 1, alphaMin = 1e-3, alphaDecay = 1 - Math.pow(alphaMin, 1 / 300), alphaTarget = 0, velocityDecay = 0.6, forces = /* @__PURE__ */ new Map(), stepper = timer(step), event = dispatch_default("tick", "end"), random = lcg_default();
+  if (nodes == null) nodes = [];
+  function step() {
+    tick();
+    event.call("tick", simulation);
+    if (alpha < alphaMin) {
+      stepper.stop();
+      event.call("end", simulation);
+    }
+  }
+  function tick(iterations) {
+    var i, n = nodes.length, node;
+    if (iterations === void 0) iterations = 1;
+    for (var k = 0; k < iterations; ++k) {
+      alpha += (alphaTarget - alpha) * alphaDecay;
+      forces.forEach(function(force) {
+        force(alpha);
+      });
+      for (i = 0; i < n; ++i) {
+        node = nodes[i];
+        if (node.fx == null) node.x += node.vx *= velocityDecay;
+        else node.x = node.fx, node.vx = 0;
+        if (node.fy == null) node.y += node.vy *= velocityDecay;
+        else node.y = node.fy, node.vy = 0;
+      }
+    }
+    return simulation;
+  }
+  function initializeNodes() {
+    for (var i = 0, n = nodes.length, node; i < n; ++i) {
+      node = nodes[i], node.index = i;
+      if (node.fx != null) node.x = node.fx;
+      if (node.fy != null) node.y = node.fy;
+      if (isNaN(node.x) || isNaN(node.y)) {
+        var radius = initialRadius * Math.sqrt(0.5 + i), angle = i * initialAngle;
+        node.x = radius * Math.cos(angle);
+        node.y = radius * Math.sin(angle);
+      }
+      if (isNaN(node.vx) || isNaN(node.vy)) {
+        node.vx = node.vy = 0;
+      }
+    }
+  }
+  function initializeForce(force) {
+    if (force.initialize) force.initialize(nodes, random);
+    return force;
+  }
+  initializeNodes();
+  return simulation = {
+    tick,
+    restart: function() {
+      return stepper.restart(step), simulation;
+    },
+    stop: function() {
+      return stepper.stop(), simulation;
+    },
+    nodes: function(_) {
+      return arguments.length ? (nodes = _, initializeNodes(), forces.forEach(initializeForce), simulation) : nodes;
+    },
+    alpha: function(_) {
+      return arguments.length ? (alpha = +_, simulation) : alpha;
+    },
+    alphaMin: function(_) {
+      return arguments.length ? (alphaMin = +_, simulation) : alphaMin;
+    },
+    alphaDecay: function(_) {
+      return arguments.length ? (alphaDecay = +_, simulation) : +alphaDecay;
+    },
+    alphaTarget: function(_) {
+      return arguments.length ? (alphaTarget = +_, simulation) : alphaTarget;
+    },
+    velocityDecay: function(_) {
+      return arguments.length ? (velocityDecay = 1 - _, simulation) : 1 - velocityDecay;
+    },
+    randomSource: function(_) {
+      return arguments.length ? (random = _, forces.forEach(initializeForce), simulation) : random;
+    },
+    force: function(name, _) {
+      return arguments.length > 1 ? (_ == null ? forces.delete(name) : forces.set(name, initializeForce(_)), simulation) : forces.get(name);
+    },
+    find: function(x3, y3, radius) {
+      var i = 0, n = nodes.length, dx, dy, d2, node, closest;
+      if (radius == null) radius = Infinity;
+      else radius *= radius;
+      for (i = 0; i < n; ++i) {
+        node = nodes[i];
+        dx = x3 - node.x;
+        dy = y3 - node.y;
+        d2 = dx * dx + dy * dy;
+        if (d2 < radius) closest = node, radius = d2;
+      }
+      return closest;
+    },
+    on: function(name, _) {
+      return arguments.length > 1 ? (event.on(name, _), simulation) : event.on(name);
+    }
+  };
+}
+
+// ../../node_modules/.pnpm/d3-force@3.0.0/node_modules/d3-force/src/manyBody.js
+function manyBody_default() {
+  var nodes, node, random, alpha, strength = constant_default(-30), strengths, distanceMin2 = 1, distanceMax2 = Infinity, theta2 = 0.81;
+  function force(_) {
+    var i, n = nodes.length, tree = quadtree(nodes, x2, y2).visitAfter(accumulate);
+    for (alpha = _, i = 0; i < n; ++i) node = nodes[i], tree.visit(apply);
+  }
+  function initialize() {
+    if (!nodes) return;
+    var i, n = nodes.length, node2;
+    strengths = new Array(n);
+    for (i = 0; i < n; ++i) node2 = nodes[i], strengths[node2.index] = +strength(node2, i, nodes);
+  }
+  function accumulate(quad) {
+    var strength2 = 0, q, c2, weight = 0, x3, y3, i;
+    if (quad.length) {
+      for (x3 = y3 = i = 0; i < 4; ++i) {
+        if ((q = quad[i]) && (c2 = Math.abs(q.value))) {
+          strength2 += q.value, weight += c2, x3 += c2 * q.x, y3 += c2 * q.y;
+        }
+      }
+      quad.x = x3 / weight;
+      quad.y = y3 / weight;
+    } else {
+      q = quad;
+      q.x = q.data.x;
+      q.y = q.data.y;
+      do
+        strength2 += strengths[q.data.index];
+      while (q = q.next);
+    }
+    quad.value = strength2;
+  }
+  function apply(quad, x1, _, x22) {
+    if (!quad.value) return true;
+    var x3 = quad.x - node.x, y3 = quad.y - node.y, w = x22 - x1, l = x3 * x3 + y3 * y3;
+    if (w * w / theta2 < l) {
+      if (l < distanceMax2) {
+        if (x3 === 0) x3 = jiggle_default(random), l += x3 * x3;
+        if (y3 === 0) y3 = jiggle_default(random), l += y3 * y3;
+        if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);
+        node.vx += x3 * quad.value * alpha / l;
+        node.vy += y3 * quad.value * alpha / l;
+      }
+      return true;
+    } else if (quad.length || l >= distanceMax2) return;
+    if (quad.data !== node || quad.next) {
+      if (x3 === 0) x3 = jiggle_default(random), l += x3 * x3;
+      if (y3 === 0) y3 = jiggle_default(random), l += y3 * y3;
+      if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);
+    }
+    do
+      if (quad.data !== node) {
+        w = strengths[quad.data.index] * alpha / l;
+        node.vx += x3 * w;
+        node.vy += y3 * w;
+      }
+    while (quad = quad.next);
+  }
+  force.initialize = function(_nodes, _random) {
+    nodes = _nodes;
+    random = _random;
+    initialize();
+  };
+  force.strength = function(_) {
+    return arguments.length ? (strength = typeof _ === "function" ? _ : constant_default(+_), initialize(), force) : strength;
+  };
+  force.distanceMin = function(_) {
+    return arguments.length ? (distanceMin2 = _ * _, force) : Math.sqrt(distanceMin2);
+  };
+  force.distanceMax = function(_) {
+    return arguments.length ? (distanceMax2 = _ * _, force) : Math.sqrt(distanceMax2);
+  };
+  force.theta = function(_) {
+    return arguments.length ? (theta2 = _ * _, force) : Math.sqrt(theta2);
+  };
+  return force;
+}
+
+// ../../node_modules/.pnpm/d3-force@3.0.0/node_modules/d3-force/src/x.js
+function x_default2(x3) {
+  var strength = constant_default(0.1), nodes, strengths, xz;
+  if (typeof x3 !== "function") x3 = constant_default(x3 == null ? 0 : +x3);
+  function force(alpha) {
+    for (var i = 0, n = nodes.length, node; i < n; ++i) {
+      node = nodes[i], node.vx += (xz[i] - node.x) * strengths[i] * alpha;
+    }
+  }
+  function initialize() {
+    if (!nodes) return;
+    var i, n = nodes.length;
+    strengths = new Array(n);
+    xz = new Array(n);
+    for (i = 0; i < n; ++i) {
+      strengths[i] = isNaN(xz[i] = +x3(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);
+    }
+  }
+  force.initialize = function(_) {
+    nodes = _;
+    initialize();
+  };
+  force.strength = function(_) {
+    return arguments.length ? (strength = typeof _ === "function" ? _ : constant_default(+_), initialize(), force) : strength;
+  };
+  force.x = function(_) {
+    return arguments.length ? (x3 = typeof _ === "function" ? _ : constant_default(+_), initialize(), force) : x3;
+  };
+  return force;
+}
+
+// ../../node_modules/.pnpm/d3-force@3.0.0/node_modules/d3-force/src/y.js
+function y_default2(y3) {
+  var strength = constant_default(0.1), nodes, strengths, yz;
+  if (typeof y3 !== "function") y3 = constant_default(y3 == null ? 0 : +y3);
+  function force(alpha) {
+    for (var i = 0, n = nodes.length, node; i < n; ++i) {
+      node = nodes[i], node.vy += (yz[i] - node.y) * strengths[i] * alpha;
+    }
+  }
+  function initialize() {
+    if (!nodes) return;
+    var i, n = nodes.length;
+    strengths = new Array(n);
+    yz = new Array(n);
+    for (i = 0; i < n; ++i) {
+      strengths[i] = isNaN(yz[i] = +y3(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);
+    }
+  }
+  force.initialize = function(_) {
+    nodes = _;
+    initialize();
+  };
+  force.strength = function(_) {
+    return arguments.length ? (strength = typeof _ === "function" ? _ : constant_default(+_), initialize(), force) : strength;
+  };
+  force.y = function(_) {
+    return arguments.length ? (y3 = typeof _ === "function" ? _ : constant_default(+_), initialize(), force) : y3;
+  };
+  return force;
+}
+
+// src/layout/force.ts
+function seededRandom(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function forceLayout(nodes, edges, options = {}) {
+  const initial = options.initial instanceof Map ? options.initial : new Map(options.initial ?? []);
+  const scatter = seededRandom((options.seed ?? 1) * 7919);
+  const disk = Math.sqrt(nodes.length) * ((options.linkDistance ?? 36) * 0.9);
+  const simNodes = nodes.map((n2) => {
+    const start = initial.get(n2.id);
+    if (start) return { id: n2.id, r: n2.r ?? 6, x: start.x, y: start.y };
+    const angle = scatter() * Math.PI * 2;
+    const radius = Math.sqrt(scatter()) * disk;
+    return { id: n2.id, r: n2.r ?? 6, x: Math.cos(angle) * radius, y: Math.sin(angle) * radius };
+  });
+  const ids = new Set(simNodes.map((n2) => n2.id));
+  const links = edges.filter((e) => ids.has(e.from) && ids.has(e.to) && e.from !== e.to).map((e) => ({ source: e.from, target: e.to }));
+  const n = simNodes.length;
+  const iterations = options.iterations ?? (n > 1e3 ? 240 : 300);
+  const simulation = simulation_default(simNodes).randomSource(seededRandom(options.seed ?? 1)).alphaDecay(1 - Math.pow(1e-3, 1 / iterations)).force(
+    "link",
+    link_default(links).id((d) => d.id).distance(options.linkDistance ?? 36).strength(0.6)
+  ).force("charge", manyBody_default().strength(options.charge ?? -40).theta(0.9)).force("collide", collide_default((d) => d.r + (options.collidePadding ?? 2)).iterations(options.collideIterations ?? 1)).force("x", x_default2(0).strength(0.04)).force("y", y_default2(0).strength(0.04)).stop();
+  for (let i = 0; i < iterations; i++) simulation.tick();
+  const positions = /* @__PURE__ */ new Map();
+  for (const node of simNodes) positions.set(node.id, { x: Math.round(node.x * 10) / 10, y: Math.round(node.y * 10) / 10 });
+  return positions;
+}
+
+// src/layout/layered.ts
+function layeredLayout(nodes, edges, options = {}) {
+  const layerGap = options.layerGap ?? 220;
+  const nodeGap = options.nodeGap ?? 84;
+  const sweeps = options.sweeps ?? 6;
+  const ids = nodes.map((n) => n.id);
+  const known = new Set(ids);
+  const out = new Map(ids.map((id) => [id, []]));
+  const incoming = new Map(ids.map((id) => [id, []]));
+  for (const { from, to } of edges) {
+    if (!known.has(from) || !known.has(to) || from === to) continue;
+    out.get(from).push(to);
+    incoming.get(to).push(from);
+  }
+  const layer = new Map(ids.map((id) => [id, 0]));
+  const remaining = new Map(ids.map((id) => [id, incoming.get(id).length]));
+  const queue = ids.filter((id) => remaining.get(id) === 0);
+  const acyclicOut = new Map(ids.map((id) => [id, []]));
+  for (let i = 0; i < queue.length; i++) {
+    const id = queue[i];
+    for (const to of out.get(id)) {
+      layer.set(to, Math.max(layer.get(to), layer.get(id) + 1));
+      acyclicOut.get(id).push(to);
+      remaining.set(to, remaining.get(to) - 1);
+      if (remaining.get(to) === 0) queue.push(to);
+    }
+  }
+  const layers = [];
+  for (const id of ids) {
+    const l = layer.get(id);
+    (layers[l] ??= []).push(id);
+  }
+  const predecessors = new Map(ids.map((id) => [id, []]));
+  for (const [from, tos] of acyclicOut) for (const to of tos) predecessors.get(to).push(from);
+  const position = /* @__PURE__ */ new Map();
+  const index2 = () => layers.forEach((members) => members.forEach((id, i) => position.set(id, i)));
+  index2();
+  const barycentre = (neighbours, fallback) => neighbours.length === 0 ? fallback : neighbours.reduce((sum, n) => sum + position.get(n), 0) / neighbours.length;
+  for (let sweep = 0; sweep < sweeps; sweep++) {
+    const down = sweep % 2 === 0;
+    const order = down ? layers.slice(1) : layers.slice(0, -1).reverse();
+    for (const members of order) {
+      const keyed = members.map((id, i) => ({
+        id,
+        i,
+        key: barycentre(down ? predecessors.get(id) : acyclicOut.get(id), position.get(id))
+      }));
+      keyed.sort((a2, z) => a2.key - z.key || a2.i - z.i);
+      members.splice(0, members.length, ...keyed.map((k) => k.id));
+      members.forEach((id, i) => position.set(id, i));
+    }
+  }
+  const positions = /* @__PURE__ */ new Map();
+  layers.forEach((members, l) => {
+    members.forEach((id, i) => positions.set(id, { x: l * layerGap, y: (i - (members.length - 1) / 2) * nodeGap }));
+  });
+  return positions;
+}
+
+// src/layout/index.ts
+function computeLayout(nodes, edges, opts) {
+  return opts.algorithm === "layered" ? layeredLayout(nodes, edges, opts) : forceLayout(nodes, edges, opts);
+}
+function runLayoutRequest(request) {
+  return request.algorithm === "layered" ? layeredLayout(request.nodes, request.edges, request.options) : forceLayout(request.nodes, request.edges, request.options);
+}
+
+// src/layout/runner.ts
+var WORKER_LAYOUT_THRESHOLD = 500;
+var inlineLayoutRunner = {
+  run: async (request) => {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    return runLayoutRequest(request);
+  }
+};
+function encodePositions(positions) {
+  const ids = [...positions.keys()];
+  const coords = new Float64Array(ids.length * 2);
+  ids.forEach((id, i) => {
+    const p = positions.get(id);
+    coords[i * 2] = p.x;
+    coords[i * 2 + 1] = p.y;
+  });
+  return { ids, coords };
+}
+function decodePositions(ids, coords) {
+  const positions = /* @__PURE__ */ new Map();
+  ids.forEach((id, i) => positions.set(id, { x: coords[i * 2], y: coords[i * 2 + 1] }));
+  return positions;
+}
+function serveLayoutRequests(port) {
+  const listener = (event) => {
+    const { id, request } = event.data;
+    try {
+      const { ids, coords } = encodePositions(runLayoutRequest(request));
+      port.postMessage({ id, ids, coords });
+    } catch (error) {
+      port.postMessage({ id, error: error instanceof Error ? error.message : String(error) });
+    }
+  };
+  port.addEventListener("message", listener);
+  return () => port.removeEventListener("message", listener);
+}
+function createWorkerLayoutRunner(port, options = {}) {
+  const threshold = options.threshold ?? WORKER_LAYOUT_THRESHOLD;
+  const pending = /* @__PURE__ */ new Map();
+  let nextId = 0;
+  const listener = (event) => {
+    const reply = event.data;
+    const waiter = pending.get(reply.id);
+    if (!waiter) return;
+    pending.delete(reply.id);
+    if ("error" in reply) waiter.reject(new Error(reply.error));
+    else waiter.resolve(decodePositions(reply.ids, reply.coords));
+  };
+  port.addEventListener("message", listener);
+  return {
+    run(request) {
+      if (request.nodes.length < threshold) return inlineLayoutRunner.run(request);
+      const id = ++nextId;
+      return new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject });
+        port.postMessage({ id, request });
+      });
+    },
+    dispose() {
+      port.removeEventListener("message", listener);
+      for (const waiter of pending.values()) waiter.reject(new Error("layout runner disposed"));
+      pending.clear();
+      port.terminate?.();
+    }
+  };
+}
+
+// src/cluster.ts
+var import_core = require("@memnest/core");
+var CATCH_ALL = "cluster:*";
+var usable = (term) => term.length >= 3 && !/^\d+$/.test(term);
+function clusterNodes(nodes, edges, options = {}) {
+  const maxClusters = Math.max(2, options.maxClusters ?? 48);
+  const exclude = new Set(options.exclude?.flatMap((t) => (0, import_core.queryTerms)(t)) ?? []);
+  const termsOf = nodes.map((node) => (0, import_core.queryTerms)(node.content).filter((t) => usable(t) && !exclude.has(t)));
+  const df = /* @__PURE__ */ new Map();
+  for (const terms of termsOf) for (const t of terms) df.set(t, (df.get(t) ?? 0) + 1);
+  const ceiling = Math.max(2, Math.floor(nodes.length * 0.6));
+  const keyOf = termsOf.map((terms) => {
+    let best;
+    for (const t of terms) {
+      const count = df.get(t);
+      if (count < 2 || count > ceiling) continue;
+      const bestCount = best === void 0 ? -1 : df.get(best);
+      if (count > bestCount || count === bestCount && t < best) best = t;
+    }
+    return best ?? "";
+  });
+  const sizes = /* @__PURE__ */ new Map();
+  for (const key of keyOf) if (key) sizes.set(key, (sizes.get(key) ?? 0) + 1);
+  const kept = new Set(
+    [...sizes.entries()].sort(([a2, x3], [b, y3]) => y3 - x3 || (a2 < b ? -1 : 1)).slice(0, maxClusters - 1).map(([key]) => key)
+  );
+  const byId = /* @__PURE__ */ new Map();
+  const clusterOf = /* @__PURE__ */ new Map();
+  nodes.forEach((node, i) => {
+    const key = kept.has(keyOf[i]) ? keyOf[i] : "";
+    const id = key ? `cluster:${key}` : CATCH_ALL;
+    let cluster = byId.get(id);
+    if (!cluster) {
+      cluster = {
+        id,
+        key,
+        label: key || "other",
+        count: 0,
+        kinds: Object.fromEntries(import_core.MEMORY_KINDS.map((k) => [k, 0])),
+        inactive: 0,
+        memberIds: []
+      };
+      byId.set(id, cluster);
+    }
+    cluster.count++;
+    cluster.kinds[node.kind]++;
+    if (!node.isLatest || node.forgotten) cluster.inactive++;
+    cluster.memberIds.push(node.id);
+    clusterOf.set(node.id, id);
+  });
+  const weights = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const from = clusterOf.get(edge.from);
+    const to = clusterOf.get(edge.to);
+    if (!from || !to || from === to) continue;
+    const pair = from < to ? `${from}\0${to}` : `${to}\0${from}`;
+    weights.set(pair, (weights.get(pair) ?? 0) + 1);
+  }
+  return {
+    clusters: [...byId.values()].sort((a2, z) => z.count - a2.count || (a2.key < z.key ? -1 : 1)),
+    edges: [...weights.entries()].map(([pair, weight]) => {
+      const [from, to] = pair.split("\0");
+      return { from, to, weight };
+    }),
+    clusterOf
+  };
+}
+
+// src/hit.ts
+function createHitIndex(circles) {
+  const tree = quadtree(
+    [...circles],
+    (c2) => c2.x,
+    (c2) => c2.y
+  );
+  const maxR = circles.reduce((max, c2) => Math.max(max, c2.r), 0);
+  return {
+    size: circles.length,
+    pick(world, slop = 0) {
+      const candidate = tree.find(world.x, world.y, maxR + slop);
+      if (candidate && Math.hypot(candidate.x - world.x, candidate.y - world.y) <= candidate.r + slop) return candidate;
+      let best = null;
+      let bestDistance = Infinity;
+      tree.visit((node, x0, y0, x1, y1) => {
+        if (!node.length) {
+          for (let leaf = node; leaf; leaf = leaf.next) {
+            const c2 = leaf.data;
+            const d = Math.hypot(c2.x - world.x, c2.y - world.y);
+            if (d <= c2.r + slop && d < bestDistance) {
+              best = c2;
+              bestDistance = d;
+            }
+          }
+        }
+        const reach = maxR + slop;
+        return x0 > world.x + reach || x1 < world.x - reach || y0 > world.y + reach || y1 < world.y - reach;
+      });
+      return best;
+    }
+  };
+}
+
+// src/encoding.ts
+var nodeRadius = (node) => 5 + Math.min(11, 2.5 * Math.sqrt(Math.max(0, node.reinforcementCount - 1)));
+var clusterRadius = (count) => 14 + Math.min(70, 3.2 * Math.sqrt(count));
+var documentRadius = 7;
+function shorten(text, max = 48) {
+  if (text.length <= max) return text;
+  const cut = text.slice(0, max - 1);
+  const space = cut.lastIndexOf(" ");
+  return `${space > max * 0.6 ? cut.slice(0, space) : cut}\u2026`;
+}
+
+// src/draw.ts
+function seedOf(text) {
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i++) hash = Math.imul(hash ^ text.charCodeAt(i), 16777619);
+  hash = Math.imul(hash ^ hash >>> 16, 2246822507);
+  hash = Math.imul(hash ^ hash >>> 13, 3266489909);
+  return ((hash ^ hash >>> 16) >>> 0) / 4294967296;
+}
+function buildGraphScene(state, theme) {
+  const { positions, selectedId, lineage } = state;
+  const circles = [];
+  const lines = [];
+  if (state.mode === "clusters") {
+    for (const edge of state.clusterEdges) {
+      const a2 = positions.get(edge.from);
+      const b = positions.get(edge.to);
+      if (!a2 || !b) continue;
+      lines.push({
+        x1: a2.x,
+        y1: a2.y,
+        x2: b.x,
+        y2: b.y,
+        to: edge.to,
+        color: theme.edges.aggregate,
+        width: Math.min(6, 1 + Math.log2(edge.weight)),
+        alpha: 0.5,
+        dash: null,
+        arrow: null,
+        seed: seedOf(`${edge.from} ${edge.to}`)
+      });
+    }
+    for (const cluster of state.clusters) {
+      const p = positions.get(cluster.id);
+      if (!p) continue;
+      circles.push({
+        id: cluster.id,
+        x: p.x,
+        y: p.y,
+        r: clusterRadius(cluster.count),
+        fill: theme.cluster,
+        stroke: theme.clusterStroke,
+        strokeWidth: 1,
+        // Translucent, so the glow behind shows through.
+        alpha: 0.62,
+        glow: 0.45 + Math.min(0.4, Math.log10(cluster.count) / 8),
+        selected: false,
+        seed: seedOf(cluster.id),
+        label: `${cluster.label} \xB7 ${cluster.count.toLocaleString("en")}`,
+        priority: cluster.count
+      });
+    }
+    return { circles, lines };
+  }
+  const radius = new Map(state.nodes.map((n) => [n.id, nodeRadius(n)]));
+  const lineageEdges = new Set(lineage?.edges.map((e) => `${e.from} ${e.to}`) ?? []);
+  for (const edge of state.edges) {
+    const a2 = positions.get(edge.from);
+    const b = positions.get(edge.to);
+    if (!a2 || !b) continue;
+    const inLineage = lineageEdges.has(`${edge.from} ${edge.to}`);
+    lines.push({
+      x1: a2.x,
+      y1: a2.y,
+      x2: b.x,
+      y2: b.y,
+      to: edge.to,
+      color: inLineage ? theme.lineage : edge.relation === "updates" ? theme.edges.updates : theme.edges.extends,
+      width: inLineage ? 2.5 : 1.25,
+      alpha: lineage && !inLineage ? 0.25 : 0.9,
+      // updates: solid with an arrow to the replaced fact; extends: dotted, no arrow.
+      dash: edge.relation === "extends" ? [0.5, 4] : null,
+      arrow: edge.relation === "updates" ? radius.get(edge.to) ?? 6 : null,
+      seed: seedOf(`${edge.from} ${edge.to}`)
+    });
+  }
+  for (const node of state.nodes) {
+    const p = positions.get(node.id);
+    if (!p) continue;
+    const selected = node.id === selectedId;
+    const inLineage = lineage?.memoryIds.has(node.id) ?? false;
+    const dimmed = Boolean(lineage) && !inLineage && !selected;
+    const base = node.forgotten ? theme.forgottenAlpha : node.isLatest ? 1 : theme.supersededAlpha;
+    const glow = node.forgotten ? 0 : node.isLatest ? 0.55 + Math.min(0.45, 0.12 * (node.reinforcementCount - 1)) : 0.22;
+    circles.push({
+      id: node.id,
+      x: p.x,
+      y: p.y,
+      r: radius.get(node.id),
+      fill: node.forgotten ? null : theme.kinds[node.kind],
+      stroke: selected ? theme.selection : inLineage ? theme.lineage : node.forgotten ? theme.kinds[node.kind] : null,
+      strokeWidth: selected ? 3 : inLineage || node.forgotten ? 2 : 0,
+      alpha: dimmed ? base * 0.35 : base,
+      glow: dimmed ? glow * 0.3 : selected ? 1 : glow,
+      selected,
+      seed: seedOf(node.id),
+      label: shorten(node.content, 42),
+      priority: (selected ? 1e9 : 0) + (inLineage ? 1e6 : 0) + node.reinforcementCount * 10 + (node.isLatest ? 5 : 0)
+    });
+  }
+  return { circles, lines };
+}
+var TAU = Math.PI * 2;
+var TOPIC_RADIUS = 17;
+function parseHex(color) {
+  let hex = color.trim();
+  if (!hex.startsWith("#")) return null;
+  hex = hex.slice(1);
+  if (hex.length === 3) hex = hex.replace(/./g, (c2) => c2 + c2);
+  if (!/^[0-9a-f]{6}$/i.test(hex)) return null;
+  const n = Number.parseInt(hex, 16);
+  return [n >> 16, n >> 8 & 255, n & 255];
+}
+function withAlpha(color, alpha) {
+  const rgb = parseHex(color);
+  if (!rgb) return alpha <= 0 ? "rgba(0,0,0,0)" : color;
+  return `rgba(${rgb[0]},${rgb[1]},${rgb[2]},${alpha})`;
+}
+function mix(color, toward, t) {
+  const a2 = parseHex(color);
+  const b = parseHex(toward);
+  if (!a2 || !b) return color;
+  const channel = (i) => Math.round(a2[i] + (b[i] - a2[i]) * t);
+  return `rgb(${channel(0)},${channel(1)},${channel(2)})`;
+}
+var spriteCache = /* @__PURE__ */ new WeakMap();
+function unitGradient(ctx, key, stops) {
+  let cache = spriteCache.get(ctx);
+  if (!cache) spriteCache.set(ctx, cache = /* @__PURE__ */ new Map());
+  let gradient = cache.get(key);
+  if (!gradient) {
+    gradient = ctx.createRadialGradient(0, 0, 0, 0, 0, 1);
+    for (const [offset, color] of stops()) gradient.addColorStop(offset, color);
+    cache.set(key, gradient);
+  }
+  return gradient;
+}
+var haloGradient = (ctx, color, ground) => unitGradient(
+  ctx,
+  `halo ${ground} ${color}`,
+  () => ground === "dark" ? [
+    [0, withAlpha(color, 0.6)],
+    [0.22, withAlpha(color, 0.26)],
+    [0.55, withAlpha(color, 0.07)],
+    [1, withAlpha(color, 0)]
+  ] : (
+    // A soft tint: on a light ground a strong halo reads as a stain, not a glow.
+    [
+      [0, withAlpha(color, 0.34)],
+      [0.25, withAlpha(color, 0.15)],
+      [0.6, withAlpha(color, 0.04)],
+      [1, withAlpha(color, 0)]
+    ]
+  )
+);
+var coreGradient = (ctx, color, ground) => unitGradient(
+  ctx,
+  `core ${ground} ${color}`,
+  () => ground === "dark" ? [
+    [0, mix(color, "#ffffff", 0.9)],
+    [0.3, mix(color, "#ffffff", 0.45)],
+    [0.75, color],
+    [1, mix(color, "#000000", 0.3)]
+  ] : (
+    // A softer highlight and a firmer edge, so the neuron keeps its shape against white.
+    [
+      [0, mix(color, "#ffffff", 0.6)],
+      [0.45, mix(color, "#ffffff", 0.12)],
+      [0.85, color],
+      [1, mix(color, "#000000", 0.2)]
+    ]
+  )
+);
+var sparkGradient = (ctx, color, core) => unitGradient(ctx, `spark ${color} ${core}`, () => [
+  [0, withAlpha(core, 1)],
+  [0.15, withAlpha(mix(color, core, 0.5), 0.9)],
+  [0.4, withAlpha(color, 0.3)],
+  [1, withAlpha(color, 0)]
+]);
+function drawScene(ctx, scene, viewport, size, theme, options = {}) {
+  const ratio = options.pixelRatio ?? 1;
+  const live = options.time !== void 0;
+  const time = options.time ?? 0;
+  const { k } = viewport;
+  const glow = theme.ground === "dark" ? "lighter" : "source-over";
+  ctx.save();
+  ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
+  ctx.globalCompositeOperation = "source-over";
+  ctx.globalAlpha = 1;
+  ctx.fillStyle = theme.background;
+  ctx.fillRect(0, 0, size.width, size.height);
+  const world = () => ctx.setTransform(ratio * k, 0, 0, ratio * k, ratio * viewport.x, ratio * viewport.y);
+  const place = (x3, y3, r) => {
+    const scale = ratio * k * r;
+    ctx.setTransform(scale, 0, 0, scale, ratio * (viewport.x + x3 * k), ratio * (viewport.y + y3 * k));
+  };
+  const margin = 80 / k;
+  const minX = -viewport.x / k - margin;
+  const minY = -viewport.y / k - margin;
+  const maxX = (size.width - viewport.x) / k + margin;
+  const maxY = (size.height - viewport.y) / k + margin;
+  const visible = (x3, y3) => x3 >= minX && x3 <= maxX && y3 >= minY && y3 <= maxY;
+  world();
+  ctx.globalCompositeOperation = glow;
+  ctx.lineCap = "round";
+  ctx.lineJoin = "round";
+  const flashes = /* @__PURE__ */ new Map();
+  const sparks = [];
+  const lines = scene.lines.filter((line) => visible(line.x1, line.y1) || visible(line.x2, line.y2));
+  const density = Math.min(1, 12 / Math.sqrt(lines.length || 1));
+  for (const line of lines) {
+    const dx = line.x2 - line.x1;
+    const dy = line.y2 - line.y1;
+    const length = Math.hypot(dx, dy) || 1;
+    const bend = (line.seed - 0.5) * 0.4 * length;
+    const cx = (line.x1 + line.x2) / 2 - dy / length * bend;
+    const cy = (line.y1 + line.y2) / 2 + dx / length * bend;
+    ctx.strokeStyle = line.color;
+    ctx.beginPath();
+    ctx.moveTo(line.x1, line.y1);
+    ctx.quadraticCurveTo(cx, cy, line.x2, line.y2);
+    ctx.setLineDash([]);
+    ctx.globalAlpha = line.alpha * 0.1 * density;
+    ctx.lineWidth = line.width * 4 / k;
+    ctx.stroke();
+    ctx.setLineDash(line.dash ? line.dash.map((d) => d / k) : []);
+    ctx.globalAlpha = line.alpha * (0.25 + 0.35 * density);
+    ctx.lineWidth = line.width / k;
+    ctx.stroke();
+    if (line.arrow !== null) {
+      const angle = Math.atan2(line.y2 - cy, line.x2 - cx);
+      const tipX = line.x2 - Math.cos(angle) * (line.arrow + 1.5 / k);
+      const tipY = line.y2 - Math.sin(angle) * (line.arrow + 1.5 / k);
+      const head = Math.min(6, Math.max(2, line.arrow * k)) / k;
+      ctx.setLineDash([]);
+      ctx.fillStyle = line.color;
+      ctx.beginPath();
+      ctx.moveTo(tipX, tipY);
+      ctx.lineTo(tipX - Math.cos(angle - 0.45) * head, tipY - Math.sin(angle - 0.45) * head);
+      ctx.lineTo(tipX - Math.cos(angle + 0.45) * head, tipY - Math.sin(angle + 0.45) * head);
+      ctx.fill();
+    }
+    if (live) {
+      const period = 2800 + line.seed * 6e3;
+      const travel = Math.min(2400, Math.max(700, length * 9));
+      const u = (time + line.seed * 9973) % period / travel;
+      if (u <= 1) {
+        const e = u < 0.5 ? 2 * u * u : 1 - (2 - 2 * u) ** 2 / 2;
+        const inv = 1 - e;
+        sparks.push({
+          x: inv * inv * line.x1 + 2 * inv * e * cx + e * e * line.x2,
+          y: inv * inv * line.y1 + 2 * inv * e * cy + e * e * line.y2,
+          color: line.color,
+          strength: Math.min(1, line.alpha * 1.1) * Math.sin(Math.PI * Math.min(1, u * 1.15 + 0.08))
+        });
+      } else if (line.to && u < 1.5) {
+        flashes.set(line.to, Math.max(flashes.get(line.to) ?? 0, 1 - (u - 1) / 0.5));
+      }
+    }
+  }
+  ctx.setLineDash([]);
+  for (const spark of sparks) {
+    place(spark.x, spark.y, Math.min(9, Math.max(4, 3 * k)) / k);
+    ctx.globalAlpha = Math.max(0, spark.strength);
+    ctx.fillStyle = sparkGradient(ctx, spark.color, theme.spark);
+    ctx.fillRect(-1, -1, 2, 2);
+  }
+  const shown = scene.circles.filter((c2) => visible(c2.x, c2.y));
+  const crowd = Math.min(1, 22 / Math.sqrt(shown.length || 1));
+  for (const circle of shown) {
+    const color = circle.fill ?? circle.stroke;
+    const flash = flashes.get(circle.id) ?? 0;
+    const pulse = live ? 0.75 + 0.25 * Math.sin(time / (1100 + circle.seed * 1400) + circle.seed * TAU) : 1;
+    const strength = Math.min(1, circle.glow * (pulse * crowd + flash * 0.55));
+    if (!color || strength <= 0.01) continue;
+    place(circle.x, circle.y, Math.max(circle.r * (3 + flash * 0.8), 7 / k));
+    ctx.globalAlpha = strength;
+    ctx.fillStyle = haloGradient(ctx, color, theme.ground);
+    ctx.fillRect(-1, -1, 2, 2);
+  }
+  ctx.globalCompositeOperation = "source-over";
+  const labelled = [];
+  for (const circle of shown) {
+    place(circle.x, circle.y, circle.r);
+    const ghost = circle.fill !== null && circle.alpha < 1 && circle.r < TOPIC_RADIUS;
+    ctx.globalCompositeOperation = ghost ? glow : "source-over";
+    ctx.globalAlpha = ghost ? circle.alpha * 0.45 : circle.alpha;
+    ctx.beginPath();
+    ctx.arc(0, 0, 1, 0, TAU);
+    if (circle.fill) {
+      ctx.fillStyle = coreGradient(ctx, circle.fill, theme.ground);
+      ctx.fill();
+    }
+    if (circle.stroke && circle.strokeWidth > 0) {
+      ctx.globalAlpha = circle.alpha;
+      ctx.strokeStyle = circle.stroke;
+      ctx.lineWidth = circle.strokeWidth / (k * circle.r);
+      ctx.stroke();
+    } else if (ghost) {
+      ctx.globalAlpha = Math.min(1, circle.alpha * 2);
+      ctx.strokeStyle = circle.fill;
+      ctx.lineWidth = 1 / (k * circle.r);
+      ctx.stroke();
+    }
+    if (circle.label && (circle.r * k >= 9 || circle.priority >= 1e6)) labelled.push(circle);
+  }
+  ctx.globalCompositeOperation = glow;
+  world();
+  if (live) {
+    for (const circle of shown) {
+      if (!circle.selected) continue;
+      const phase = time % 2400 / 2400;
+      ctx.globalAlpha = 0.6 * (1 - phase);
+      ctx.strokeStyle = circle.stroke ?? theme.selection;
+      ctx.lineWidth = 1.5 / k;
+      ctx.beginPath();
+      ctx.arc(circle.x, circle.y, circle.r * (1.3 + phase * 2.2), 0, TAU);
+      ctx.stroke();
+    }
+  }
+  ctx.globalCompositeOperation = "source-over";
+  labelled.sort((a2, z) => z.priority - a2.priority);
+  ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
+  ctx.font = theme.font;
+  ctx.textAlign = "center";
+  ctx.textBaseline = "top";
+  ctx.lineJoin = "round";
+  const taken = [];
+  for (const circle of labelled.slice(0, options.maxLabels ?? 160)) {
+    const x3 = circle.x * k + viewport.x;
+    const y3 = (circle.y + circle.r) * k + viewport.y + 6;
+    const width = circle.label.length * 6.2;
+    const box = [x3 - width / 2, y3, x3 + width / 2, y3 + 14];
+    if (taken.some(([x0, y0, x1, y1]) => box[0] < x1 && box[2] > x0 && box[1] < y1 && box[3] > y0)) continue;
+    taken.push(box);
+    ctx.globalAlpha = Math.max(circle.alpha, 0.7);
+    ctx.strokeStyle = theme.labelHalo;
+    ctx.lineWidth = 4;
+    ctx.strokeText(circle.label, x3, y3);
+    ctx.fillStyle = theme.label;
+    ctx.fillText(circle.label, x3, y3);
+  }
+  ctx.restore();
+}
+
+// src/controllers/graph.ts
+var import_core2 = require("@memnest/core");
+var CLUSTER_THRESHOLD = 2e3;
+var GRAPH_LOAD_LIMIT = 1e4;
+var DEFAULT_GRAPH_FILTER = { kinds: [], includeSuperseded: true, includeForgotten: false, search: "" };
+function matchesFilter(node, filter) {
+  if (filter.kinds.length > 0 && !filter.kinds.includes(node.kind)) return false;
+  if (!node.isLatest && !filter.includeSuperseded) return false;
+  if (node.forgotten && !filter.includeForgotten) return false;
+  const search = filter.search.trim().toLowerCase();
+  if (!search) return true;
+  if (node.id === filter.search.trim()) return true;
+  const content = node.content.toLowerCase();
+  return search.split(/\s+/).every((word) => content.includes(word));
+}
+function createGraphController(options) {
+  const { client } = options;
+  const scope = (0, import_core2.scopeOf)(options.containerTag);
+  const runner = options.layout ?? inlineLayoutRunner;
+  const threshold = options.clusterThreshold ?? CLUSTER_THRESHOLD;
+  const limit = options.limit ?? GRAPH_LOAD_LIMIT;
+  const store = createStore({
+    containerTag: scope.containerTag,
+    status: "idle",
+    error: null,
+    filter: { ...DEFAULT_GRAPH_FILTER, ...options.filter },
+    mode: "nodes",
+    totalMemories: 0,
+    loaded: 0,
+    truncated: false,
+    matching: 0,
+    nodes: [],
+    edges: [],
+    clusters: [],
+    clusterEdges: [],
+    positions: /* @__PURE__ */ new Map(),
+    selectedId: null,
+    lineage: null,
+    viewport: IDENTITY_VIEWPORT,
+    size: { width: 0, height: 0 },
+    layoutMs: null,
+    hover: null
+  });
+  const loads = createSequencer();
+  const layouts = createSequencer();
+  let snapshot = null;
+  let hits = createHitIndex([]);
+  let userMoved = false;
+  let disposed = false;
+  async function recompute() {
+    if (!snapshot) return;
+    const token = layouts.next();
+    const { filter, lineage, positions: previous, mode: previousMode } = store.getState();
+    let nodes = snapshot.nodes.filter((n) => matchesFilter(n, filter));
+    const matching = nodes.length;
+    if (lineage) {
+      const present = new Set(nodes.map((n) => n.id));
+      nodes = nodes.concat(snapshot.nodes.filter((n) => lineage.memoryIds.has(n.id) && !present.has(n.id)));
+    }
+    const ids = new Set(nodes.map((n) => n.id));
+    const edges = snapshot.edges.filter((e) => ids.has(e.from) && ids.has(e.to));
+    const mode = nodes.length > threshold ? "clusters" : "nodes";
+    let clusters = [];
+    let clusterEdges = [];
+    let layoutNodes;
+    let layoutEdges;
+    if (mode === "clusters") {
+      ({ clusters, edges: clusterEdges } = clusterNodes(nodes, edges, { exclude: filter.search ? [filter.search] : [] }));
+      layoutNodes = clusters.map((c2) => ({ id: c2.id, r: clusterRadius(c2.count) }));
+      layoutEdges = clusterEdges;
+    } else {
+      layoutNodes = nodes.map((n) => ({ id: n.id, r: nodeRadius(n) }));
+      layoutEdges = edges;
+    }
+    store.set({ status: "layout", hover: null, matching, mode, nodes: mode === "nodes" ? nodes : [], edges: mode === "nodes" ? edges : [], clusters, clusterEdges });
+    const started = performance.now();
+    let positions;
+    const laidOut = new Set(layoutNodes.map((n) => n.id));
+    try {
+      positions = await runner.run({
+        algorithm: "force",
+        nodes: layoutNodes,
+        edges: layoutEdges,
+        options: {
+          initial: [...previous].filter(([id]) => laidOut.has(id)),
+          // Clusters are big circles that must not overlap; a handful of nodes needs room for labels.
+          ...mode === "clusters" ? { linkDistance: 180, charge: -900, collidePadding: 28, collideIterations: 4 } : layoutNodes.length <= 40 ? { linkDistance: 90, charge: -320, collidePadding: 24 } : {}
+        }
+      });
+    } catch (error) {
+      if (layouts.isCurrent(token) && !disposed) store.set({ status: "error", error: errorText(error) });
+      return;
+    }
+    if (!layouts.isCurrent(token) || disposed) return;
+    const radius = new Map(layoutNodes.map((n) => [n.id, n.r]));
+    const circles = [...positions].map(([id, p]) => ({ id, x: p.x, y: p.y, r: radius.get(id) ?? 6 }));
+    hits = createHitIndex(circles);
+    const state = store.getState();
+    const refit = !userMoved || previousMode !== mode;
+    store.set({
+      status: "ready",
+      error: null,
+      positions,
+      layoutMs: Math.round(performance.now() - started),
+      ...refit ? { viewport: fitViewport(boundsOf(circles), state.size) } : {}
+    });
+    if (refit) userMoved = false;
+  }
+  const controller = {
+    getState: store.getState,
+    subscribe: store.subscribe,
+    async load() {
+      const token = loads.next();
+      store.set({ status: "loading", error: null });
+      try {
+        const loaded = await client.graph(scope, { limit, includeSuperseded: true, includeForgotten: true });
+        if (!loads.isCurrent(token) || disposed) return;
+        snapshot = loaded;
+        const { selectedId, lineage } = store.getState();
+        const present = new Set(loaded.nodes.map((n) => n.id));
+        store.set({
+          totalMemories: loaded.totalMemories,
+          loaded: loaded.nodes.length,
+          truncated: loaded.truncated,
+          selectedId: selectedId && present.has(selectedId) ? selectedId : null,
+          lineage: lineage && present.has(lineage.rootId) ? lineage : null
+        });
+        await recompute();
+      } catch (error) {
+        if (loads.isCurrent(token) && !disposed) store.set({ status: "error", error: errorText(error) });
+      }
+    },
+    setFilter(patch) {
+      store.set((s) => ({ filter: { ...s.filter, ...patch } }));
+      void recompute();
+    },
+    select(memoryId) {
+      if (store.getState().selectedId === memoryId) return;
+      store.set({ selectedId: memoryId });
+      options.onSelect?.(memoryId);
+    },
+    async expandLineage(memoryId) {
+      const token = loads.next();
+      try {
+        const graph = await client.getLineage(scope, memoryId);
+        if (!loads.isCurrent(token) || disposed) return;
+        if (!graph) {
+          store.set({ lineage: null });
+          return;
+        }
+        store.set({
+          lineage: {
+            rootId: memoryId,
+            memoryIds: new Set(graph.memories.map((m2) => m2.id)),
+            edges: graph.edges.filter((e) => e.relation !== "source")
+          }
+        });
+        const { mode } = store.getState();
+        if (mode === "clusters") store.set((s) => ({ filter: { ...s.filter, search: memoryId } }));
+        await recompute();
+      } catch (error) {
+        if (loads.isCurrent(token) && !disposed) store.set({ status: "error", error: errorText(error) });
+      }
+    },
+    collapseLineage() {
+      if (!store.getState().lineage) return;
+      store.set({ lineage: null });
+      void recompute();
+    },
+    expandCluster(clusterId) {
+      const cluster = store.getState().clusters.find((c2) => c2.id === clusterId);
+      if (!cluster || !cluster.key) return;
+      const current = store.getState().filter.search.trim();
+      controller.setFilter({ search: current ? `${current} ${cluster.key}` : cluster.key });
+    },
+    setSize(width, height) {
+      const { size, viewport } = store.getState();
+      if (size.width === width && size.height === height) return;
+      const first = size.width === 0 || size.height === 0;
+      const next = first ? viewport : panBy(viewport, (width - size.width) / 2, (height - size.height) / 2);
+      store.set({ size: { width, height }, viewport: next });
+      if (first && !userMoved) controller.fit();
+    },
+    panBy(dx, dy) {
+      userMoved = true;
+      store.set((s) => ({ viewport: panBy(s.viewport, dx, dy), hover: null }));
+    },
+    zoomAt(screen, factor) {
+      userMoved = true;
+      store.set((s) => ({ viewport: zoomAt(s.viewport, screen, factor), hover: null }));
+    },
+    fit() {
+      const { positions, size, mode, clusters, nodes } = store.getState();
+      const radius = new Map(
+        mode === "clusters" ? clusters.map((c2) => [c2.id, clusterRadius(c2.count)]) : nodes.map((n) => [n.id, nodeRadius(n)])
+      );
+      userMoved = false;
+      store.set({ viewport: fitViewport(boundsOf([...positions].map(([id, p]) => ({ ...p, r: radius.get(id) ?? 6 }))), size) });
+    },
+    pick(screen) {
+      const { viewport, mode, clusters } = store.getState();
+      const hit = hits.pick(toWorld(viewport, screen), 4 / viewport.k);
+      if (!hit) return null;
+      if (mode === "clusters") {
+        const cluster = clusters.find((c2) => c2.id === hit.id);
+        return cluster ? { type: "cluster", id: cluster.id, key: cluster.key } : null;
+      }
+      return { type: "node", id: hit.id };
+    },
+    hover(screen) {
+      const previous = store.getState().hover;
+      const pick = screen ? controller.pick(screen) : null;
+      if (!pick) {
+        if (previous) store.set({ hover: null });
+        return;
+      }
+      if (previous && previous.pick.id === pick.id) return;
+      const { viewport, positions } = store.getState();
+      const p = positions.get(pick.id);
+      store.set({ hover: { pick, x: p.x * viewport.k + viewport.x, y: p.y * viewport.k + viewport.y } });
+    },
+    dispose() {
+      disposed = true;
+      loads.cancel();
+      layouts.cancel();
+    }
+  };
+  if (options.autoload !== false) void controller.load();
+  return controller;
+}
+
+// src/controllers/lineage.ts
+var import_core3 = require("@memnest/core");
+function layoutLineage(graph) {
+  const nodes = [
+    ...graph.memories.map((m2) => ({ id: m2.id, r: nodeRadius(m2) })),
+    ...graph.documents.map((d) => ({ id: d.id, r: documentRadius }))
+  ];
+  const positions = layeredLayout(nodes, graph.edges, { layerGap: 190, nodeGap: 96 });
+  const radius = new Map(nodes.map((n) => [n.id, n.r]));
+  return { positions, bounds: boundsOf([...positions].map(([id, p]) => ({ ...p, r: radius.get(id) + 90 }))) };
+}
+function createLineageController(options) {
+  const scope = (0, import_core3.scopeOf)(options.containerTag);
+  const store = createStore({ status: "idle", error: null, rootId: null, graph: null, positions: /* @__PURE__ */ new Map(), bounds: null });
+  const seq = createSequencer();
+  const controller = {
+    getState: store.getState,
+    subscribe: store.subscribe,
+    async load(memoryId) {
+      const token = seq.next();
+      store.set({ status: "loading", error: null, rootId: memoryId });
+      try {
+        const graph = await options.client.getLineage(scope, memoryId);
+        if (!seq.isCurrent(token)) return;
+        if (!graph) {
+          store.set({ status: "not-found", graph: null, positions: /* @__PURE__ */ new Map(), bounds: null });
+          return;
+        }
+        store.set({ status: "ready", graph, ...layoutLineage(graph) });
+      } catch (error) {
+        if (seq.isCurrent(token)) store.set({ status: "error", error: errorText(error) });
+      }
+    },
+    async reload() {
+      const { rootId } = store.getState();
+      if (rootId) await controller.load(rootId);
+    },
+    clear() {
+      seq.cancel();
+      store.set({ status: "idle", error: null, rootId: null, graph: null, positions: /* @__PURE__ */ new Map(), bounds: null });
+    },
+    dispose: () => seq.cancel()
+  };
+  return controller;
+}
+
+// src/controllers/detail.ts
+var import_core4 = require("@memnest/core");
+function versionChain(graph, rootId) {
+  const byId = new Map(graph.memories.map((m2) => [m2.id, m2]));
+  const newerOf = /* @__PURE__ */ new Map();
+  for (const m2 of graph.memories) if (m2.supersedes) newerOf.set(m2.supersedes, m2);
+  const root = byId.get(rootId);
+  if (!root) return [];
+  const chain = [root];
+  const seen = /* @__PURE__ */ new Set([root.id]);
+  for (let older = root.supersedes ? byId.get(root.supersedes) : void 0; older && !seen.has(older.id); older = older.supersedes ? byId.get(older.supersedes) : void 0) {
+    chain.unshift(older);
+    seen.add(older.id);
+  }
+  for (let newer = newerOf.get(root.id); newer && !seen.has(newer.id); newer = newerOf.get(newer.id)) {
+    chain.push(newer);
+    seen.add(newer.id);
+  }
+  return chain;
+}
+var EMPTY = {
+  status: "idle",
+  error: null,
+  memoryId: null,
+  memory: null,
+  versions: [],
+  extends: [],
+  extendedBy: [],
+  sources: [],
+  forget: "idle",
+  forgetError: null
+};
+function createDetailController(options) {
+  const { client } = options;
+  const scope = (0, import_core4.scopeOf)(options.containerTag);
+  const store = createStore(EMPTY);
+  const seq = createSequencer();
+  const updateSource = (documentId, patch) => store.set((s) => ({ sources: s.sources.map((source) => source.document.id === documentId ? { ...source, ...patch } : source) }));
+  const controller = {
+    getState: store.getState,
+    subscribe: store.subscribe,
+    async load(memoryId) {
+      const token = seq.next();
+      store.set({ ...EMPTY, status: "loading", memoryId });
+      try {
+        const [memory, graph] = await Promise.all([client.getMemory(scope, memoryId), client.getLineage(scope, memoryId)]);
+        if (!seq.isCurrent(token)) return;
+        if (!memory || !graph) {
+          store.set({ status: "not-found" });
+          return;
+        }
+        const byId = new Map(graph.memories.map((m2) => [m2.id, m2]));
+        const sourceIds = new Set(graph.edges.filter((e) => e.relation === "source" && e.from === memoryId).map((e) => e.to));
+        store.set({
+          status: "ready",
+          memory,
+          versions: versionChain(graph, memoryId),
+          extends: memory.extendsIds.flatMap((id) => byId.has(id) ? [byId.get(id)] : []),
+          extendedBy: graph.memories.filter((m2) => m2.extendsIds.includes(memoryId)),
+          sources: graph.documents.filter((d) => sourceIds.has(d.id)).map((document) => ({ document, content: null, chunks: null, loading: false, error: null }))
+        });
+      } catch (error) {
+        if (seq.isCurrent(token)) store.set({ status: "error", error: errorText(error) });
+      }
+    },
+    async reload() {
+      const { memoryId } = store.getState();
+      if (memoryId) await controller.load(memoryId);
+    },
+    clear() {
+      seq.cancel();
+      store.set(EMPTY);
+    },
+    async loadSource(documentId) {
+      const memoryId = store.getState().memoryId;
+      updateSource(documentId, { loading: true, error: null });
+      try {
+        const found = await client.getDocument(scope, documentId);
+        if (store.getState().memoryId !== memoryId) return;
+        updateSource(documentId, {
+          loading: false,
+          content: found?.document.content ?? null,
+          chunks: found?.chunks ?? [],
+          ...found ? {} : { error: "document not found" }
+        });
+      } catch (error) {
+        if (store.getState().memoryId === memoryId) updateSource(documentId, { loading: false, error: errorText(error) });
+      }
+    },
+    requestForget() {
+      const { memory, forget } = store.getState();
+      if (!memory || memory.forgottenAt || forget !== "idle") return;
+      store.set({ forget: "confirming", forgetError: null });
+    },
+    cancelForget() {
+      if (store.getState().forget === "confirming") store.set({ forget: "idle" });
+    },
+    async confirmForget() {
+      const { memory, forget } = store.getState();
+      if (!memory || forget !== "confirming") return null;
+      store.set({ forget: "forgetting", forgetError: null });
+      try {
+        const forgotten = await client.forget(scope, memory.id);
+        if (store.getState().memoryId !== memory.id) return forgotten;
+        store.set((s) => ({
+          forget: "idle",
+          memory: forgotten,
+          versions: s.versions.map((v) => v.id === forgotten.id ? forgotten : v)
+        }));
+        options.onForgotten?.(forgotten);
+        return forgotten;
+      } catch (error) {
+        store.set({ forget: "confirming", forgetError: errorText(error) });
+        return null;
+      }
+    },
+    dispose: () => seq.cancel()
+  };
+  return controller;
+}
+
+// src/controllers/trace.ts
+var import_core5 = require("@memnest/core");
+var DEFAULT_TRACE_BUDGET = 2e3;
+function buildTraceRows(response, memories) {
+  let used = 0;
+  let budgetLine = null;
+  const rows = response.trace.candidates.map((candidate, index2) => {
+    if (candidate.included) used += candidate.tokens;
+    if (budgetLine === null && candidate.excludedReason === "budget") budgetLine = index2;
+    const memory = memories.get(candidate.memoryId);
+    return { ...candidate, content: memory?.content ?? null, kind: memory?.kind ?? null, cumulativeTokens: used };
+  });
+  return { rows, budgetLine };
+}
+function createTraceController(options) {
+  const { client } = options;
+  const scope = (0, import_core5.scopeOf)(options.containerTag);
+  const store = createStore({
+    query: "",
+    tokenBudget: options.tokenBudget ?? DEFAULT_TRACE_BUDGET,
+    status: "idle",
+    error: null,
+    response: null,
+    rows: [],
+    budgetLine: null,
+    chunkTokens: 0
+  });
+  const seq = createSequencer();
+  let lastRun = null;
+  async function execute(query, tokenBudget) {
+    const token = seq.next();
+    lastRun = { query, tokenBudget };
+    store.set({ status: "loading", error: null });
+    try {
+      const response = await client.search(query, scope, { tokenBudget });
+      const memories = new Map(response.memories.map((r) => [r.memory.id, r.memory]));
+      const missing = response.trace.candidates.map((c2) => c2.memoryId).filter((id) => !memories.has(id));
+      const fetched = await Promise.all(missing.map((id) => client.getMemory(scope, id)));
+      if (!seq.isCurrent(token)) return;
+      for (const memory of fetched) if (memory) memories.set(memory.id, memory);
+      store.set({
+        status: "ready",
+        response,
+        ...buildTraceRows(response, memories),
+        chunkTokens: response.chunks.reduce((sum, c2) => sum + c2.tokens, 0)
+      });
+    } catch (error) {
+      if (seq.isCurrent(token)) store.set({ status: "error", error: errorText(error) });
+    }
+  }
+  return {
+    getState: store.getState,
+    subscribe: store.subscribe,
+    setQuery: (query) => store.set({ query }),
+    setTokenBudget: (tokenBudget) => store.set({ tokenBudget }),
+    async run() {
+      const { query, tokenBudget } = store.getState();
+      if (!query.trim()) return;
+      await execute(query, tokenBudget);
+    },
+    async rerun() {
+      if (lastRun) await execute(lastRun.query, lastRun.tokenBudget);
+    },
+    dispose: () => seq.cancel()
+  };
+}
+
+// src/controllers/timeline.ts
+var import_core6 = require("@memnest/core");
+var DAY = 864e5;
+var iso = (ms) => new Date(ms).toISOString();
+var earliest = (...values) => values.filter((v) => typeof v === "string").sort()[0] ?? null;
+function buildTimeline(memories, now2) {
+  const byId = new Map(memories.map((m2) => [m2.id, m2]));
+  const newer = /* @__PURE__ */ new Map();
+  for (const m2 of memories) if (m2.supersedes && byId.has(m2.supersedes)) newer.set(m2.supersedes, m2);
+  const laneOf = /* @__PURE__ */ new Map();
+  const rootOf = (m2) => {
+    const seen = /* @__PURE__ */ new Set();
+    let current = m2;
+    while (current.supersedes && byId.has(current.supersedes) && !seen.has(current.id)) {
+      seen.add(current.id);
+      current = byId.get(current.supersedes);
+    }
+    return current.id;
+  };
+  for (const m2 of memories) laneOf.set(m2.id, rootOf(m2));
+  const items = memories.map((memory) => {
+    const replacement = newer.get(memory.id);
+    const supersededAt = replacement ? earliest(replacement.validFrom, replacement.createdAt) : null;
+    const expiredAt = memory.validUntil && memory.validUntil <= now2 ? memory.validUntil : null;
+    const endedAt = earliest(supersededAt, expiredAt, memory.forgottenAt);
+    const status = endedAt === null ? memory.isLatest ? "current" : "superseded" : endedAt === memory.forgottenAt ? "forgotten" : endedAt === supersededAt ? "superseded" : "expired";
+    return {
+      memory,
+      laneId: laneOf.get(memory.id),
+      start: memory.validFrom,
+      // A current fact with a future expiry shows where it will end.
+      end: endedAt ?? memory.validUntil ?? null,
+      status,
+      supersededBy: replacement?.id ?? null
+    };
+  });
+  const lanes = /* @__PURE__ */ new Map();
+  for (const item of items) (lanes.get(item.laneId) ?? lanes.set(item.laneId, []).get(item.laneId)).push(item);
+  const laneList = [...lanes.entries()].map(([id, laneItems]) => {
+    laneItems.sort((a2, z) => a2.start < z.start ? -1 : a2.start > z.start ? 1 : a2.memory.version - z.memory.version);
+    return { id, label: shorten(laneItems.at(-1).memory.content, 60), items: laneItems };
+  }).sort((a2, z) => a2.items[0].start < z.items[0].start ? -1 : 1);
+  if (items.length === 0) return { lanes: [], range: null, ticks: [] };
+  const start = Date.parse(items.map((i) => i.start).sort()[0]);
+  const lastEnd = Math.max(Date.parse(now2), ...items.map((i) => Date.parse(i.end ?? now2)));
+  const span = Math.max(lastEnd - start, DAY);
+  const range = { start: iso(start - span * 0.03), end: iso(start + span * 1.03) };
+  return { lanes: laneList, range, ticks: timeTicks(range.start, range.end) };
+}
+function timeTicks(start, end, count = 6) {
+  const from = Date.parse(start);
+  const to = Date.parse(end);
+  const span = Math.max(to - from, 1);
+  const withTime = span < 3 * DAY;
+  const crossesYear = new Date(from).getUTCFullYear() !== new Date(to).getUTCFullYear();
+  const format = new Intl.DateTimeFormat("en", {
+    timeZone: "UTC",
+    month: "short",
+    day: "numeric",
+    ...withTime ? { hour: "2-digit", minute: "2-digit", hourCycle: "h23" } : crossesYear ? { year: "numeric" } : {}
+  });
+  return Array.from({ length: count }, (_, i) => {
+    const at = from + span * i / (count - 1);
+    return { at: iso(at), label: format.format(at) };
+  });
+}
+function createTimelineController(options) {
+  const { client } = options;
+  const scope = (0, import_core6.scopeOf)(options.containerTag);
+  const now2 = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const store = createStore({ topic: "", status: "idle", error: null, lanes: [], range: null, ticks: [] });
+  const seq = createSequencer();
+  let lastTopic = null;
+  async function execute(topic) {
+    const token = seq.next();
+    lastTopic = topic;
+    store.set({ status: "loading", error: null });
+    try {
+      const response = await client.search(topic, scope, { tokenBudget: 1, candidates: 30 });
+      const found = new Map(response.memories.map((r) => [r.memory.id, r.memory]));
+      const ids = response.trace.candidates.map((c2) => c2.memoryId);
+      for (const memory of await Promise.all(ids.filter((id) => !found.has(id)).map((id) => client.getMemory(scope, id)))) {
+        if (memory) found.set(memory.id, memory);
+      }
+      const chainRoots = [...found.values()].filter((m2) => m2.supersedes || !m2.isLatest).slice(0, 20);
+      for (const graph of await Promise.all(chainRoots.map((m2) => client.getLineage(scope, m2.id)))) {
+        for (const m2 of graph?.memories ?? []) {
+          if (graph.edges.some((e) => e.relation === "updates" && (e.from === m2.id || e.to === m2.id))) found.set(m2.id, m2);
+        }
+      }
+      if (!seq.isCurrent(token)) return;
+      store.set({ status: "ready", ...buildTimeline([...found.values()], now2()) });
+    } catch (error) {
+      if (seq.isCurrent(token)) store.set({ status: "error", error: errorText(error) });
+    }
+  }
+  return {
+    getState: store.getState,
+    subscribe: store.subscribe,
+    setTopic: (topic) => store.set({ topic }),
+    async run() {
+      const { topic } = store.getState();
+      if (topic.trim()) await execute(topic);
+    },
+    async rerun() {
+      if (lastTopic !== null) await execute(lastTopic);
+    },
+    dispose: () => seq.cancel()
+  };
+}
+
+// src/controllers/finder.ts
+var import_core7 = require("@memnest/core");
+var PAGE = 50;
+function createFinderController(options) {
+  const { client } = options;
+  const scope = (0, import_core7.scopeOf)(options.containerTag);
+  const store = createStore({ query: "", includeHistory: false, status: "idle", error: null, items: [], hasMore: false });
+  const seq = createSequencer();
+  const visible = (m2, includeHistory) => includeHistory || m2.isLatest && !m2.forgottenAt;
+  async function search(query, includeHistory, token) {
+    const response = await client.search(query, scope, { tokenBudget: 1e6, candidates: PAGE });
+    const found = new Map(response.memories.map((r) => [r.memory.id, r.memory]));
+    const ids = response.trace.candidates.map((c2) => c2.memoryId);
+    const missing = ids.filter((id) => !found.has(id));
+    for (const memory of await Promise.all(missing.map((id) => client.getMemory(scope, id)))) if (memory) found.set(memory.id, memory);
+    if (!seq.isCurrent(token)) return;
+    store.set({ status: "ready", hasMore: false, items: ids.flatMap((id) => found.has(id) && visible(found.get(id), includeHistory) ? [found.get(id)] : []) });
+  }
+  async function browse(includeHistory, token, after) {
+    const page = await client.listMemories(scope, { limit: PAGE, ...after ? { after } : {} }, { latestOnly: !includeHistory, includeForgotten: includeHistory });
+    if (!seq.isCurrent(token)) return;
+    store.set((s) => ({ status: "ready", items: after ? [...s.items, ...page] : page, hasMore: page.length === PAGE }));
+  }
+  return {
+    getState: store.getState,
+    subscribe: store.subscribe,
+    setQuery: (query) => store.set({ query }),
+    setIncludeHistory: (includeHistory) => store.set({ includeHistory }),
+    async run() {
+      const token = seq.next();
+      const { query, includeHistory } = store.getState();
+      store.set({ status: "loading", error: null });
+      try {
+        if (query.trim()) await search(query, includeHistory, token);
+        else await browse(includeHistory, token);
+      } catch (error) {
+        if (seq.isCurrent(token)) store.set({ status: "error", error: errorText(error) });
+      }
+    },
+    async loadMore() {
+      const { items, hasMore, includeHistory, query, status } = store.getState();
+      if (!hasMore || query.trim() || status === "loading" || items.length === 0) return;
+      const token = seq.next();
+      store.set({ status: "loading" });
+      try {
+        await browse(includeHistory, token, items.at(-1).id);
+      } catch (error) {
+        if (seq.isCurrent(token)) store.set({ status: "error", error: errorText(error) });
+      }
+    },
+    dispose: () => seq.cancel()
+  };
+}
+
+// src/workspace.ts
+function createWorkspace(options) {
+  const { client, containerTag } = options;
+  const selection = createStore({ memoryId: null });
+  let workspace;
+  const onForgotten = (_memory) => {
+    void Promise.all([
+      workspace.finder.run(),
+      workspace.trace.rerun(),
+      workspace.timeline.rerun(),
+      workspace.graph.load(),
+      workspace.lineage.reload()
+    ]);
+  };
+  const select = (memoryId) => {
+    if (selection.getState().memoryId === memoryId) return;
+    selection.set({ memoryId });
+    workspace.graph.select(memoryId);
+    if (memoryId) {
+      void workspace.detail.load(memoryId);
+      void workspace.lineage.load(memoryId);
+    } else {
+      workspace.detail.clear();
+      workspace.lineage.clear();
+    }
+  };
+  workspace = {
+    containerTag,
+    selection,
+    select,
+    finder: createFinderController({ client, containerTag }),
+    detail: createDetailController({ client, containerTag, onForgotten }),
+    lineage: createLineageController({ client, containerTag }),
+    trace: createTraceController({ client, containerTag }),
+    timeline: createTimelineController({ client, containerTag, ...options.now ? { now: options.now } : {} }),
+    graph: createGraphController({
+      client,
+      containerTag,
+      ...options.graph,
+      ...options.layout ? { layout: options.layout } : {},
+      onSelect: (memoryId) => select(memoryId)
+    }),
+    async refresh() {
+      await Promise.all([
+        workspace.finder.run(),
+        workspace.trace.rerun(),
+        workspace.timeline.rerun(),
+        workspace.graph.load(),
+        workspace.detail.reload(),
+        workspace.lineage.reload()
+      ]);
+    },
+    dispose() {
+      for (const controller of [workspace.finder, workspace.detail, workspace.lineage, workspace.trace, workspace.timeline, workspace.graph]) {
+        controller.dispose();
+      }
+    }
+  };
+  return workspace;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLUSTER_THRESHOLD,
+  DEFAULT_GRAPH_FILTER,
+  DEFAULT_TRACE_BUDGET,
+  GRAPH_LOAD_LIMIT,
+  IDENTITY_VIEWPORT,
+  WORKER_LAYOUT_THRESHOLD,
+  ZOOM_LIMITS,
+  boundsOf,
+  buildGraphScene,
+  buildTimeline,
+  buildTraceRows,
+  clamp,
+  clusterNodes,
+  clusterRadius,
+  computeLayout,
+  createDetailController,
+  createFinderController,
+  createGraphController,
+  createHitIndex,
+  createLineageController,
+  createSequencer,
+  createStore,
+  createTimelineController,
+  createTraceController,
+  createWorkerLayoutRunner,
+  createWorkspace,
+  documentRadius,
+  drawScene,
+  fitViewport,
+  forceLayout,
+  inlineLayoutRunner,
+  layeredLayout,
+  layoutLineage,
+  matchesFilter,
+  nodeRadius,
+  panBy,
+  runLayoutRequest,
+  seededRandom,
+  serveLayoutRequests,
+  shorten,
+  timeTicks,
+  toScreen,
+  toWorld,
+  versionChain,
+  zoomAt
+});
+//# sourceMappingURL=index.cjs.map