@memnest/ui-core 0.0.0

package/dist/index.js

@@ -0,0 +1,1277 @@
+import {
+  WORKER_LAYOUT_THRESHOLD,
+  computeLayout,
+  createWorkerLayoutRunner,
+  forceLayout,
+  inlineLayoutRunner,
+  layeredLayout,
+  quadtree,
+  runLayoutRequest,
+  seededRandom,
+  serveLayoutRequests
+} from "./chunk-JCMPD6YF.js";
+
+// 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, y, r = 0 } of circles) {
+    if (!bounds) bounds = { minX: x - r, minY: y - r, maxX: x + r, maxY: y + r };
+    else {
+      bounds.minX = Math.min(bounds.minX, x - r);
+      bounds.minY = Math.min(bounds.minY, y - r);
+      bounds.maxX = Math.max(bounds.maxX, x + r);
+      bounds.maxY = Math.max(bounds.maxY, y + 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));
+
+// src/cluster.ts
+import { MEMORY_KINDS, queryTerms } from "@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) => queryTerms(t)) ?? []);
+  const termsOf = nodes.map((node) => 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(([a, x], [b, y]) => y - x || (a < 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(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((a, z) => z.count - a.count || (a.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],
+    (c) => c.x,
+    (c) => c.y
+  );
+  const maxR = circles.reduce((max, c) => Math.max(max, c.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 c = leaf.data;
+            const d = Math.hypot(c.x - world.x, c.y - world.y);
+            if (d <= c.r + slop && d < bestDistance) {
+              best = c;
+              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 a = positions.get(edge.from);
+      const b = positions.get(edge.to);
+      if (!a || !b) continue;
+      lines.push({
+        x1: a.x,
+        y1: a.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 a = positions.get(edge.from);
+    const b = positions.get(edge.to);
+    if (!a || !b) continue;
+    const inLineage = lineageEdges.has(`${edge.from} ${edge.to}`);
+    lines.push({
+      x1: a.x,
+      y1: a.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, (c) => c + c);
+  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 a = parseHex(color);
+  const b = parseHex(toward);
+  if (!a || !b) return color;
+  const channel = (i) => Math.round(a[i] + (b[i] - a[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 = (x, y, r) => {
+    const scale = ratio * k * r;
+    ctx.setTransform(scale, 0, 0, scale, ratio * (viewport.x + x * k), ratio * (viewport.y + y * 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 = (x, y) => x >= minX && x <= maxX && y >= minY && y <= 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((c) => visible(c.x, c.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((a, z) => z.priority - a.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 x = circle.x * k + viewport.x;
+    const y = (circle.y + circle.r) * k + viewport.y + 6;
+    const width = circle.label.length * 6.2;
+    const box = [x - width / 2, y, x + width / 2, y + 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, x, y);
+    ctx.fillStyle = theme.label;
+    ctx.fillText(circle.label, x, y);
+  }
+  ctx.restore();
+}
+
+// src/controllers/graph.ts
+import { scopeOf } from "@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 = 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((c) => ({ id: c.id, r: clusterRadius(c.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((m) => m.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((c) => c.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((c) => [c.id, clusterRadius(c.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((c) => c.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
+import { scopeOf as scopeOf2 } from "@memnest/core";
+function layoutLineage(graph) {
+  const nodes = [
+    ...graph.memories.map((m) => ({ id: m.id, r: nodeRadius(m) })),
+    ...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 = scopeOf2(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
+import { scopeOf as scopeOf3 } from "@memnest/core";
+function versionChain(graph, rootId) {
+  const byId = new Map(graph.memories.map((m) => [m.id, m]));
+  const newerOf = /* @__PURE__ */ new Map();
+  for (const m of graph.memories) if (m.supersedes) newerOf.set(m.supersedes, m);
+  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 = scopeOf3(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((m) => [m.id, m]));
+        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((m) => m.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
+import { scopeOf as scopeOf4 } from "@memnest/core";
+var DEFAULT_TRACE_BUDGET = 2e3;
+function buildTraceRows(response, memories) {
+  let used = 0;
+  let budgetLine = null;
+  const rows = response.trace.candidates.map((candidate, index) => {
+    if (candidate.included) used += candidate.tokens;
+    if (budgetLine === null && candidate.excludedReason === "budget") budgetLine = index;
+    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 = scopeOf4(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((c) => c.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, c) => sum + c.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
+import { scopeOf as scopeOf5 } from "@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, now) {
+  const byId = new Map(memories.map((m) => [m.id, m]));
+  const newer = /* @__PURE__ */ new Map();
+  for (const m of memories) if (m.supersedes && byId.has(m.supersedes)) newer.set(m.supersedes, m);
+  const laneOf = /* @__PURE__ */ new Map();
+  const rootOf = (m) => {
+    const seen = /* @__PURE__ */ new Set();
+    let current = m;
+    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 m of memories) laneOf.set(m.id, rootOf(m));
+  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 <= now ? 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((a, z) => a.start < z.start ? -1 : a.start > z.start ? 1 : a.memory.version - z.memory.version);
+    return { id, label: shorten(laneItems.at(-1).memory.content, 60), items: laneItems };
+  }).sort((a, z) => a.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(now), ...items.map((i) => Date.parse(i.end ?? now)));
+  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 = scopeOf5(options.containerTag);
+  const now = 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((c) => c.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((m) => m.supersedes || !m.isLatest).slice(0, 20);
+      for (const graph of await Promise.all(chainRoots.map((m) => client.getLineage(scope, m.id)))) {
+        for (const m of graph?.memories ?? []) {
+          if (graph.edges.some((e) => e.relation === "updates" && (e.from === m.id || e.to === m.id))) found.set(m.id, m);
+        }
+      }
+      if (!seq.isCurrent(token)) return;
+      store.set({ status: "ready", ...buildTimeline([...found.values()], now()) });
+    } 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
+import { scopeOf as scopeOf6 } from "@memnest/core";
+var PAGE = 50;
+function createFinderController(options) {
+  const { client } = options;
+  const scope = scopeOf6(options.containerTag);
+  const store = createStore({ query: "", includeHistory: false, status: "idle", error: null, items: [], hasMore: false });
+  const seq = createSequencer();
+  const visible = (m, includeHistory) => includeHistory || m.isLatest && !m.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((c) => c.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;
+}
+export {
+  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.js.map