@dxos/plugin-explorer 0.8.4-main.406dc2a → 0.8.4-main.43cb759274

package/dist/lib/{browser/chunk-MOM5KCKC.mjs → neutral/components/index.mjs}

@@ -1,15 +1,16 @@
+import {
+  treeTypeToTreeNode
+} from "../chunk-7XUDLV6E.mjs";
+import {
+  createAdapter,
+  getNodeFillForObject
+} from "../chunk-IKHJV3Q4.mjs";
+import "../chunk-J5LGTIGS.mjs";
+
 // src/components/Chart/Chart.tsx
-import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
 import * as Plot from "@observablehq/plot";
 import React, { useEffect } from "react";
 import { useResizeDetector } from "react-resize-detector";
-
-// src/components/plot.ts
-var createAdapter = (prop, accessor) => accessor ? {
-  transform: (values) => values.map((value) => accessor(value)[prop])
-} : prop;
-
-// src/components/Chart/Chart.tsx
 var defaultOptions = {
   r: 4,
   stroke: "gray",
@@ -17,49 +18,43 @@ var defaultOptions = {
   fillOpacity: 0.2
 };
 var Chart = ({ items = [], accessor, options = defaultOptions }) => {
-  var _effect = _useSignals();
-  try {
-    const { ref: containerRef, width = 0, height = 0 } = useResizeDetector({
-      refreshRate: 200
-    });
-    useEffect(() => {
-      if (!width || !height) {
-        return;
-      }
-      const plot3 = Plot.plot({
-        grid: true,
-        width,
-        height,
-        style: {
-          background: "transparent"
-        },
-        marks: [
-          Plot.frame(),
-          Plot.dot(items, {
-            x: createAdapter("x", accessor),
-            y: createAdapter("y", accessor),
-            ...options
-          })
-        ]
-      });
-      containerRef.current.append(plot3);
-      return () => plot3?.remove();
-    }, [
-      items,
+  const { ref: containerRef, width = 0, height = 0 } = useResizeDetector({
+    refreshRate: 200
+  });
+  useEffect(() => {
+    if (!width || !height) {
+      return;
+    }
+    const plot3 = Plot.plot({
+      grid: true,
       width,
-      height
-    ]);
-    return /* @__PURE__ */ React.createElement("div", {
-      ref: containerRef,
-      className: "grow"
+      height,
+      style: {
+        background: "transparent"
+      },
+      marks: [
+        Plot.frame(),
+        Plot.dot(items, {
+          x: createAdapter("x", accessor),
+          y: createAdapter("y", accessor),
+          ...options
+        })
+      ]
     });
-  } finally {
-    _effect.f();
-  }
+    containerRef.current.append(plot3);
+    return () => plot3?.remove();
+  }, [
+    items,
+    width,
+    height
+  ]);
+  return /* @__PURE__ */ React.createElement("div", {
+    ref: containerRef,
+    className: "grow"
+  });
 };
 
 // src/components/Globe/Globe.tsx
-import { useSignals as _useSignals2 } from "@preact-signals/safe-react/tracking";
 import * as Plot2 from "@observablehq/plot";
 import React2, { useEffect as useEffect2 } from "react";
 import { useResizeDetector as useResizeDetector2 } from "react-resize-detector";
@@ -10773,569 +10768,900 @@ var defaultOptions2 = {
   fill: "#003300"
 };
 var Globe = ({ items = [], accessor, projection = "orthographic", options = defaultOptions2 }) => {
-  var _effect = _useSignals2();
-  try {
-    const { ref: containerRef, width = 0, height = 0 } = useResizeDetector2({
-      refreshRate: 200
-    });
-    const land = topojson.feature(countries_110m_default, countries_110m_default.objects.land);
-    useEffect2(() => {
-      if (!width || !height) {
-        return;
-      }
-      const plot3 = Plot2.plot({
-        // https://observablehq.com/plot/features/projections
-        projection: {
-          type: projection,
-          rotate: [
-            -100,
-            -20
-          ]
-        },
-        // projection: { type: 'equirectangular', rotate: [-140, -30] },
-        width,
-        height,
-        style: {
-          background: "transparent"
-        },
-        // TODO(burdon): Create simple wrapper for Plot with good defaults.
-        marks: [
-          Plot2.sphere({
-            fill: "lightblue",
-            fillOpacity: 0.5
-          }),
-          Plot2.geo(land, {
-            fill: "darkgreen",
-            fillOpacity: 0.5
-          }),
-          Plot2.graticule(),
-          Plot2.dot(items, {
-            x: createAdapter("lat", accessor),
-            y: createAdapter("lng", accessor),
-            ...options
-          })
+  const { ref: containerRef, width = 0, height = 0 } = useResizeDetector2({
+    refreshRate: 200
+  });
+  const land = topojson.feature(countries_110m_default, countries_110m_default.objects.land);
+  useEffect2(() => {
+    if (!width || !height) {
+      return;
+    }
+    const plot3 = Plot2.plot({
+      // https://observablehq.com/plot/features/projections
+      projection: {
+        type: projection,
+        rotate: [
+          -100,
+          -20
         ]
-      });
-      containerRef.current.append(plot3);
-      return () => plot3?.remove();
-    }, [
-      items,
+      },
+      // projection: { type: 'equirectangular', rotate: [-140, -30] },
       width,
-      height
-    ]);
-    return /* @__PURE__ */ React2.createElement("div", {
-      ref: containerRef,
-      className: "grow p-4"
+      height,
+      style: {
+        background: "transparent"
+      },
+      // TODO(burdon): Create simple wrapper for Plot with good defaults.
+      marks: [
+        Plot2.sphere({
+          fill: "lightblue",
+          fillOpacity: 0.5
+        }),
+        Plot2.geo(land, {
+          fill: "darkgreen",
+          fillOpacity: 0.5
+        }),
+        Plot2.graticule(),
+        Plot2.dot(items, {
+          x: createAdapter("lat", accessor),
+          y: createAdapter("lng", accessor),
+          ...options
+        })
+      ]
     });
-  } finally {
-    _effect.f();
-  }
-};
-
-// src/components/Tree/Tree.tsx
-import { useSignals as _useSignals3 } from "@preact-signals/safe-react/tracking";
-import React3, { useEffect as useEffect3, useRef, useState } from "react";
-import { useAsyncState } from "@dxos/react-ui";
-import { SVG } from "@dxos/react-ui-graph";
-import { SpaceGraphModel } from "@dxos/schema";
-
-// src/components/Tree/layout/HierarchicalEdgeBundling.ts
-import { cluster, curveBundle, hierarchy, lineRadial, select } from "d3";
-var HierarchicalEdgeBundling = (s, data, options) => {
-  const svg = select(s);
-  svg.selectAll("*").remove();
-  const { radius = 600, padding = 100, slots } = options;
-  const root = hierarchy(flatten(data));
-  const tree3 = cluster().size([
-    2 * Math.PI,
-    radius - padding
+    containerRef.current.append(plot3);
+    return () => plot3?.remove();
+  }, [
+    items,
+    width,
+    height
   ]);
-  const layout = tree3(addLinks(root));
-  const node = svg.append("g").selectAll().data(layout.leaves()).join("g").attr("transform", (d) => `rotate(${d.x * (180 / Math.PI) - 90}) translate(${d.y},0)`).append("text").attr("class", slots?.text ?? "").attr("dy", "0.31em").attr("x", (d) => d.x < Math.PI ? 6 : -6).attr("text-anchor", (d) => d.x < Math.PI ? "start" : "end").attr("transform", (d) => d.x >= Math.PI ? "rotate(180)" : null).call((text) => text.text((d) => d.data.id.slice(0, 8)));
-  const line = lineRadial().curve(curveBundle.beta(0.85)).radius((d) => d.y).angle((d) => d.x);
-  const links = svg.append("g").selectAll().data(layout.leaves().flatMap((leaf) => leaf.outgoing)).join("path").style("mix-blend-mode", "multiply").attr("class", slots?.path ?? "").attr("d", ([i, o]) => {
-    return line(i.path(o));
-  }).each(function(d) {
-    d.path = this;
+  return /* @__PURE__ */ React2.createElement("div", {
+    ref: containerRef,
+    className: "grow p-4"
   });
 };
-var addLinks = (root) => {
-  const nodes = new Map(root.descendants().map((d) => [
-    d.data.id,
-    d
-  ]));
-  const parents = root.descendants().reduce((map, d) => {
-    if (d.children?.length) {
-      map.set(d.data.id, d);
-    }
-    return map;
-  }, /* @__PURE__ */ new Map());
-  for (const d of root.leaves()) {
-    const parent = parents.get(d.data.id);
-    if (parent) {
-      d.outgoing = parent.data.children?.slice(1).map((child) => {
-        return [
-          d,
-          nodes.get(child.id)
-        ];
-      }) ?? [];
-    } else {
-      d.outgoing = [];
-    }
+
+// src/components/Graph/CanvasForceGraph.tsx
+import { forceLink, forceManyBody } from "d3";
+import NativeForceGraph from "force-graph";
+import React3, { useCallback, useEffect as useEffect3, useRef, useState } from "react";
+import { useResizeDetector as useResizeDetector3 } from "react-resize-detector";
+import { composable, composableProps } from "@dxos/react-ui";
+
+// src/components/Graph/graph-adapter.ts
+var GraphAdapter = class {
+  graph;
+  _nodes = [];
+  _links = [];
+  constructor(graph) {
+    this.graph = graph;
+    this._nodes = graph.nodes.map((node) => ({
+      id: node.id,
+      type: node.type,
+      data: node.data
+    }));
+    const nodeIds = new Set(this._nodes.map((node) => node.id));
+    this._links = graph.edges.filter((edge) => nodeIds.has(edge.source) && nodeIds.has(edge.target)).map((edge) => ({
+      type: edge.type,
+      source: edge.source,
+      target: edge.target,
+      data: edge.data
+    }));
   }
-  return root;
-};
-var flatten = (node) => {
-  const clone = {
-    id: node.id
-  };
-  if (node.children?.length) {
-    const children = node.children.map((child) => flatten(child));
-    clone.children = [
-      {
-        id: node.id
-      },
-      ...children
-    ];
+  get nodes() {
+    return this._nodes;
   }
-  return clone;
-};
-var HierarchicalEdgeBundling_default = HierarchicalEdgeBundling;
-
-// src/components/Tree/layout/RadialTree.ts
-import { hierarchy as hierarchy2, linkRadial, select as select2, tree } from "d3";
-var RadialTree = (s, data, options) => {
-  const svg = select2(s);
-  svg.selectAll("*").remove();
-  const { label, radius = 400, r = 4, slots } = options;
-  const arc = 2 * Math.PI;
-  const root = hierarchy2(data);
-  const descendants = root.descendants();
-  const getLabel = label === null ? null : descendants.map((d) => label(d.data));
-  const layout = tree().size([
-    arc,
-    radius
-  ]).separation((a, b) => (a.parent === b.parent ? 1 : 2) / a.depth);
-  layout(root);
-  svg.append("g").selectAll("path").data(root.links()).join("path").attr("class", slots?.path ?? "").attr("d", linkRadial().angle((d) => d.x + Math.PI / 2).radius((d) => d.y));
-  const node = svg.append("g").selectAll("a").data(root.descendants()).join("a").attr("transform", (d) => `rotate(${d.x * 180 / Math.PI}) translate(${d.y},0)`);
-  node.append("circle").attr("class", slots?.node ?? "").attr("r", r);
-  if (getLabel) {
-    node.append("text").attr("transform", (d) => `rotate(${d.x >= Math.PI ? 180 : 0})`).attr("dy", "0.32em").attr("x", (d) => d.x < Math.PI === !d.children ? 6 : -6).attr("text-anchor", (d) => d.x < Math.PI === !d.children ? "start" : "end").attr("class", slots?.text ?? "").text((d, i) => getLabel[i]);
+  get links() {
+    return this._links;
   }
-  return svg.node();
 };
-var RadialTree_default = RadialTree;
 
-// src/components/Tree/layout/TidyTree.ts
-import { curveBumpX, hierarchy as hierarchy3, link, select as select3, tree as tree2 } from "d3";
-var TidyTree = (s, data, options) => {
-  const svg = select3(s);
-  svg.selectAll("*").remove();
-  const { label, width, height, r = 4, padding = 4, margin = 60, slots } = options;
-  const root = hierarchy3(data);
-  const descendants = root.descendants();
-  const getLabel = label == null ? null : descendants.map((d) => label(d.data));
-  const dx = 16;
-  const dy = width / (root.height + padding);
-  const layout = tree2().nodeSize([
-    dx,
-    dy
+// src/components/Graph/CanvasForceGraph.tsx
+var CanvasForceGraph = composable(({ model, match, onClick, ...props }, forwardedRef) => {
+  const { ref: resizeRef, width, height } = useResizeDetector3({
+    refreshRate: 200
+  });
+  const setRef = useCallback((node) => {
+    resizeRef(node);
+    assignRef(forwardedRef, node);
+  }, [
+    resizeRef,
+    forwardedRef
   ]);
-  layout(root);
-  let x0 = Infinity;
-  let x1 = -x0;
-  let y0 = Infinity;
-  let y1 = -y0;
-  root.each((d) => {
-    if (d.x > x1) {
-      x1 = d.x;
-    }
-    if (d.x < x0) {
-      x0 = d.x;
+  const rootRef = useRef(null);
+  const forceGraph = useRef(null);
+  const [data, setData] = useState();
+  useEffect3(() => {
+    return model?.subscribe((model2) => setData(new GraphAdapter(model2.graph)));
+  }, [
+    model
+  ]);
+  useEffect3(() => {
+    if (rootRef.current) {
+      forceGraph.current = new NativeForceGraph(rootRef.current).nodeRelSize(6).nodeLabel((node) => node.type === "schema" ? node.data.typename : node.data.label ?? node.id).nodeAutoColorBy((node) => node.type === "schema" ? "schema" : node.data.typename).linkAutoColorBy((link) => link.type);
     }
-    if (d.y > y1) {
-      y1 = d.y;
+    return () => {
+      forceGraph.current?.pauseAnimation().graphData({
+        nodes: [],
+        links: []
+      });
+      forceGraph.current = null;
+    };
+  }, []);
+  useEffect3(() => {
+    if (!data || !width || !height || !forceGraph.current) {
+      return;
     }
-    if (d.y < y0) {
-      y0 = d.y;
+    forceGraph.current.pauseAnimation().width(width).height(height).onEngineStop(() => handleZoomToFit()).onNodeClick((node) => {
+      forceGraph.current?.emitParticle(node);
+    }).d3Force("link", forceLink().distance(160).strength(0.5)).d3Force("charge", forceManyBody().strength(-30)).graphData(data).warmupTicks(100).cooldownTime(1e3).resumeAnimation();
+  }, [
+    data,
+    width,
+    height
+  ]);
+  const handleZoomToFit = () => {
+    forceGraph.current?.zoomToFit(400, 40);
+  };
+  const handleClick = useCallback((event) => {
+    onClick?.(event);
+    if (!event.defaultPrevented) {
+      handleZoomToFit();
     }
-  });
-  const sx = Math.min(2, Math.max(1, (height - margin * 2) / (x1 - x0)));
-  const oy = -(width - (y1 - y0)) / 2;
-  svg.append("g").selectAll("path").data(root.links()).join("path").attr("class", slots?.path ?? "").attr("d", link(curveBumpX).x((d) => d.y + oy).y((d) => d.x * sx));
-  const node = svg.append("g").selectAll("a").data(root.descendants()).join("a").attr("transform", (d) => `translate(${d.y + oy},${d.x * sx})`);
-  node.append("circle").attr("class", slots?.node ?? "").attr("r", r);
-  if (getLabel) {
-    node.append("text").attr("dy", "0.32em").attr("x", (d) => d.children ? -6 : 6).attr("text-anchor", (d) => d.children ? "end" : "start").attr("class", slots?.text ?? "").text((d, i) => getLabel[i]);
+  }, [
+    onClick
+  ]);
+  return /* @__PURE__ */ React3.createElement("div", {
+    ...composableProps(props, {
+      classNames: "relative grow"
+    }),
+    onClick: handleClick,
+    ref: setRef
+  }, /* @__PURE__ */ React3.createElement("div", {
+    ref: rootRef,
+    className: "absolute inset-0"
+  }));
+});
+var assignRef = (ref, value) => {
+  if (typeof ref === "function") {
+    ref(value);
+  } else if (ref) {
+    ref.current = value;
   }
 };
-var TidyTree_default = TidyTree;
 
-// src/components/Tree/types/tree.ts
-import * as Schema from "effect/Schema";
-import { Key, Obj, Type } from "@dxos/echo";
-import { invariant } from "@dxos/invariant";
-function _define_property(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-explorer/src/components/Tree/types/tree.ts";
-var TreeNodeType = Schema.Struct({
-  id: Key.ObjectId,
-  children: Schema.mutable(Schema.Array(Key.ObjectId)),
-  data: Schema.mutable(Schema.Record({
-    key: Schema.String,
-    value: Schema.Any
-  })),
-  ref: Schema.optional(Type.Ref(Type.Expando))
-}).pipe(Schema.mutable);
-var TreeType = Schema.Struct({
-  root: Key.ObjectId,
-  nodes: Schema.mutable(Schema.Record({
-    key: Key.ObjectId,
-    value: TreeNodeType
-  }))
-}).pipe(Type.Obj({
-  typename: "dxos.org/type/Tree",
-  version: "0.1.0"
-}));
-var Tree = class _Tree {
-  get tree() {
-    return this._tree;
-  }
-  // TODO(burdon): Make reactive.
-  get size() {
-    return Object.keys(this._tree.nodes).length;
-  }
-  get root() {
-    return this.getNode(this._tree.root);
-  }
-  //
-  // Traversal
-  //
-  /**
-  * Recursively traverse the tree until the callback returns a value.
-  */
-  tranverse(callback, root = this._tree.root, depth = 0) {
-    const node = this._tree.nodes[root];
-    const result = callback(node, depth);
-    if (result !== void 0) {
-      return result;
+// src/components/Graph/ForceGraph.tsx
+import { Atom, useAtomValue } from "@effect-atom/atom-react";
+import React4, { useCallback as useCallback2, useEffect as useEffect4, useMemo, useRef as useRef2, useState as useState2 } from "react";
+import { Obj } from "@dxos/echo";
+import { SelectionModel } from "@dxos/graph";
+import { composable as composable2, composableProps as composableProps2 } from "@dxos/react-ui";
+import { GraphForceProjector, SVG } from "@dxos/react-ui-graph";
+import { getHashStyles } from "@dxos/ui-theme";
+import "@dxos/react-ui-graph/styles/graph.css";
+var EMPTY_ATOM = Atom.make({
+  nodes: [],
+  edges: []
+});
+var ForceGraph = composable2(({ model, selection: selectionProp, grid, drag, onInspect, ...props }, forwardedRef) => {
+  useAtomValue(model?.graphAtom ?? EMPTY_ATOM);
+  const graph = useRef2(null);
+  const selection = useMemo(() => selectionProp ?? new SelectionModel(), [
+    selectionProp
+  ]);
+  useEffect4(() => {
+    const unsubscribe = selection.subscribe(() => graph.current?.repaint());
+    return unsubscribe;
+  }, [
+    selection
+  ]);
+  const svgRef = useRef2(null);
+  const [projector, setProjector] = useState2();
+  useEffect4(() => {
+    if (svgRef.current) {
+      setProjector(new GraphForceProjector(svgRef.current, {
+        attributes: {
+          // TODO(burdon): Check type (currently assumes Employee property).
+          // Edge shouldn't contribute to force if it's not active.
+          linkForce: (edge) => edge.data?.object?.active !== false
+        },
+        forces: {
+          point: {
+            strength: 0.01
+          }
+        }
+      }));
+    }
+  }, []);
+  const handleSelect = useCallback2((node) => {
+    if (selection.contains(node.id)) {
+      selection.remove(node.id);
+    } else {
+      selection.add(node.id);
     }
-    for (const childId of node.children) {
-      const result2 = this.tranverse(callback, childId, depth + 1);
-      if (result2 !== void 0) {
-        return result2;
+  }, [
+    selection
+  ]);
+  return /* @__PURE__ */ React4.createElement("div", {
+    ...composableProps2(props, {
+      classNames: "dx-container"
+    }),
+    ref: forwardedRef
+  }, /* @__PURE__ */ React4.createElement(SVG.Root, {
+    ref: svgRef
+  }, /* @__PURE__ */ React4.createElement(SVG.Markers, null), grid && /* @__PURE__ */ React4.createElement(SVG.Grid, {
+    axis: true
+  }), /* @__PURE__ */ React4.createElement(SVG.Zoom, {
+    extent: [
+      1 / 2,
+      2
+    ]
+  }, /* @__PURE__ */ React4.createElement(SVG.Graph, {
+    ref: graph,
+    drag,
+    model,
+    projector,
+    labels: {
+      text: (node) => node.data?.data.label ?? node.id
+    },
+    attributes: {
+      node: (node) => {
+        const obj = node.data?.data.object;
+        return {
+          data: {
+            color: getHashStyles(obj && Obj.getTypename(obj))?.hue
+          },
+          classes: {
+            "dx-selected": selection.contains(node.id)
+          }
+        };
       }
+    },
+    onSelect: handleSelect,
+    onInspect
+  }))));
+});
+
+// src/components/Lattice/Lattice.tsx
+import { select } from "d3";
+import React5, { useEffect as useEffect6, useMemo as useMemo2, useRef as useRef3 } from "react";
+import { Obj as Obj2 } from "@dxos/echo";
+
+// src/components/Tree/layout/useContainerSize.ts
+import { useEffect as useEffect5, useState as useState3 } from "react";
+var useContainerSize = () => {
+  const [el, setEl] = useState3(null);
+  const [size, setSize] = useState3({
+    width: 0,
+    height: 0
+  });
+  useEffect5(() => {
+    if (!el) {
+      return;
     }
-  }
-  getNode(id) {
-    const node = this._tree.nodes[id];
-    invariant(node, void 0, {
-      F: __dxlog_file,
-      L: 98,
-      S: this,
-      A: [
-        "node",
-        ""
-      ]
+    const rect = el.getBoundingClientRect();
+    setSize({
+      width: rect.width,
+      height: rect.height
     });
-    return node;
-  }
-  /**
-  * Get the children of a node.
-  */
-  getChildNodes(node) {
-    return node.children.map((id) => this.getNode(id));
-  }
-  /**
-  * Get the parent of a node.
-  */
-  getParent(node) {
-    const parent = this.tranverse((n) => {
-      if (n.children.includes(node.id)) {
-        return n;
+    const observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (!entry) {
+        return;
       }
+      const { width, height } = entry.contentRect;
+      setSize((prev) => prev.width === width && prev.height === height ? prev : {
+        width,
+        height
+      });
     });
-    return parent ?? null;
-  }
-  /**
-  * Get the next node in the tree.
-  */
-  getNext(node, hierarchical = true) {
-    if (hierarchical && node.children.length) {
-      return this.getChildNodes(node)[0];
-    } else {
-      const parent = this.getParent(node);
-      if (parent) {
-        const idx = this.getChildNodes(parent).findIndex(({ id }) => id === node.id);
-        if (idx < parent.children.length - 1) {
-          return this.getNode(parent.children[idx + 1]);
-        } else {
-          return this.getNext(parent, false);
-        }
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, [
+    el
+  ]);
+  return {
+    setRef: setEl,
+    width: size.width,
+    height: size.height
+  };
+};
+
+// src/components/Lattice/Lattice.tsx
+var TRANSITION_MS = 350;
+var Lattice = ({ nodes, padding = 16, onNodeHover }) => {
+  const svgRef = useRef3(null);
+  const { setRef, width, height } = useContainerSize();
+  const cells = useMemo2(() => {
+    return nodes.map((node) => {
+      const object = node.data?.object;
+      if (!object) {
+        return void 0;
       }
+      const label = node.data?.label ?? Obj2.getLabel(object) ?? node.id;
+      const typename = Obj2.getTypename(object) ?? "(untyped)";
+      return {
+        id: node.id,
+        label,
+        typename,
+        object
+      };
+    }).filter((cell) => cell !== void 0).sort((a, b) => a.typename.localeCompare(b.typename) || a.label.localeCompare(b.label));
+  }, [
+    nodes
+  ]);
+  const handleHoverRef = useRef3(void 0);
+  handleHoverRef.current = onNodeHover;
+  useEffect6(() => {
+    if (!svgRef.current || !width || !height) {
+      return;
     }
+    renderLattice(svgRef.current, cells, {
+      width,
+      height,
+      padding,
+      onNodeHover: (n, e) => handleHoverRef.current?.(n, e)
+    });
+    return () => {
+      handleHoverRef.current?.(null);
+    };
+  }, [
+    cells,
+    width,
+    height,
+    padding
+  ]);
+  return /* @__PURE__ */ React5.createElement("div", {
+    ref: setRef,
+    className: "dx-expander relative"
+  }, width > 0 && height > 0 && /* @__PURE__ */ React5.createElement("svg", {
+    ref: svgRef,
+    xmlns: "http://www.w3.org/2000/svg",
+    width,
+    height,
+    viewBox: `0 0 ${width} ${height}`
+  }));
+};
+var renderLattice = (svgElement, cells, options) => {
+  const { width, height, padding, onNodeHover } = options;
+  const svg = select(svgElement);
+  if (!cells.length) {
+    onNodeHover(null);
+    svg.selectAll("g.dx-lattice-root").remove();
+    return;
   }
-  /**
-  * Get the previous node in the tree.
-  */
-  getPrevious(node, hierarchical = true) {
-    const parent = this.getParent(node);
-    const idx = this.getChildNodes(parent).findIndex(({ id }) => id === node.id);
-    if (idx === 0) {
-      if (hierarchical) {
-        return parent;
-      }
-    } else {
-      const previous = this.getNode(parent.children[idx - 1]);
-      if (hierarchical && previous.children.length) {
-        return this.getLastDescendent(previous);
-      }
-      return previous;
+  const count = cells.length;
+  const columns = Math.max(1, Math.ceil(Math.sqrt(count)));
+  const rows = Math.ceil(count / columns);
+  const innerW = Math.max(0, width - 2 * padding);
+  const innerH = Math.max(0, height - 2 * padding);
+  const cellSize = Math.max(0, Math.min(innerW / columns, innerH / rows));
+  const gutter = Math.max(2, cellSize * 0.12);
+  const rectSize = Math.max(0, cellSize - gutter);
+  const radius = Math.max(2, rectSize * 0.18);
+  const gridW = cellSize * columns;
+  const gridH = cellSize * rows;
+  const offsetX = (width - gridW) / 2;
+  const offsetY = (height - gridH) / 2;
+  const g = svg.selectAll("g.dx-lattice-root").data([
+    null
+  ]).join("g").classed("dx-lattice-root", true);
+  const positioned = cells.map((cell, i) => ({
+    ...cell,
+    x: offsetX + i % columns * cellSize + gutter / 2,
+    y: offsetY + Math.floor(i / columns) * cellSize + gutter / 2
+  }));
+  const node = g.selectAll("g.dx-lattice-cell").data(positioned, (d) => d.id).join((enter) => {
+    const ge = enter.append("g").classed("dx-lattice-cell", true).attr("opacity", 0);
+    ge.append("rect").style("cursor", "pointer");
+    return ge;
+  }, (update) => update, (exit) => exit.each(function() {
+    select(this).interrupt();
+  }).transition().duration(TRANSITION_MS).attr("opacity", 0).remove());
+  node.transition().duration(TRANSITION_MS).attr("opacity", 1).attr("transform", (d) => `translate(${d.x},${d.y})`);
+  node.select("rect").attr("width", rectSize).attr("height", rectSize).attr("rx", radius).attr("ry", radius).style("fill", (d) => getNodeFillForObject(d.object)).on("pointerenter", (event, d) => onNodeHover({
+    id: d.id,
+    label: d.label,
+    data: d.object
+  }, event)).on("pointerleave", () => onNodeHover(null));
+};
+
+// src/components/Tree/Tree.tsx
+import React9, { useMemo as useMemo6 } from "react";
+
+// src/components/Tree/layout/HierarchicalEdgeBundling.tsx
+import { cluster, curveBundle, hierarchy, lineRadial, select as select2 } from "d3";
+import React6, { useEffect as useEffect7, useMemo as useMemo3, useRef as useRef4 } from "react";
+import { mx } from "@dxos/ui-theme";
+
+// src/components/Tree/layout/slots.ts
+var defaultTreeLayoutSlots = {
+  // Cursor + transition so the hover swap reads clearly; SVG circles support the `:hover` pseudo-class
+  // via Tailwind variants exactly like HTML elements.
+  node: "fill-blue-600 hover:fill-orange-500 cursor-pointer transition-colors",
+  // 0.5px is fine on a white background, but on a dark Storybook background the lines disappear.
+  // Use stroke-1 with opacity 50% so they read in both themes; dx-bundle-dim/out/in further tune on hover.
+  path: "fill-none stroke-blue-500/50 stroke-[1px] dark:stroke-blue-400/60",
+  text: "fill-neutral-700 dark:fill-neutral-300 text-xs hover:fill-orange-500 cursor-pointer transition-colors"
+};
+
+// src/components/Tree/layout/HierarchicalEdgeBundling.tsx
+var TRANSITION_MS2 = 350;
+var HierarchicalEdgeBundling = ({ classNames, data, edges = [], label = (d) => d.label ?? d.id, padding = 120, tension = 0.85, r = 4, slots = defaultTreeLayoutSlots, onNodeHover }) => {
+  const svgRef = useRef4(null);
+  const { setRef, width, height } = useContainerSize();
+  const root = useMemo3(() => buildBundleHierarchy(data, edges), [
+    data,
+    edges
+  ]);
+  const handleHoverRef = useRef4(() => {
+  });
+  handleHoverRef.current = (node, event) => onNodeHover?.(node, event);
+  useEffect7(() => {
+    if (!svgRef.current || !width || !height) {
+      return;
     }
+    const radius = Math.max(0, Math.min(width, height) / 2 - padding);
+    renderBundling(svgRef.current, root, {
+      radius,
+      r,
+      label,
+      slots,
+      tension,
+      onNodeHover: (n, e) => handleHoverRef.current(n, e)
+    });
+  }, [
+    root,
+    width,
+    height,
+    padding,
+    tension,
+    r,
+    label,
+    slots
+  ]);
+  return /* @__PURE__ */ React6.createElement("div", {
+    ref: setRef,
+    className: mx("dx-expander relative", classNames)
+  }, width > 0 && height > 0 && /* @__PURE__ */ React6.createElement("svg", {
+    ref: svgRef,
+    xmlns: "http://www.w3.org/2000/svg",
+    width,
+    height,
+    viewBox: `${-width / 2} ${-height / 2} ${width} ${height}`
+  }));
+};
+var buildBundleHierarchy = (data, edges) => {
+  const root = hierarchy(data);
+  const byId = /* @__PURE__ */ new Map();
+  for (const node of root.descendants()) {
+    byId.set(node.data.id, node);
+    node.outgoing = [];
+    node.incoming = [];
   }
-  /**
-  * Get the last descendent of a node.
-  */
-  getLastDescendent(node) {
-    const children = this.getChildNodes(node);
-    const last = children.length ? children[children.length - 1] : void 0;
-    if (last) {
-      return this.getLastDescendent(last);
+  for (const edge of edges) {
+    const source = byId.get(edge.source);
+    const target = byId.get(edge.target);
+    if (!source || !target || source === target) {
+      continue;
     }
-    return node;
+    source.outgoing.push([
+      source,
+      target,
+      edge
+    ]);
+    target.incoming.push([
+      source,
+      target,
+      edge
+    ]);
   }
-  //
-  // Mutations
-  //
-  /**
-  * Clear tree.
-  */
-  clear() {
-    const root = this._tree.nodes[this._tree.root];
-    root.children.length = 0;
-    this._tree.nodes = {
-      [root.id]: root
-    };
+  return root;
+};
+var renderBundling = (svgElement, root, options) => {
+  const { radius, r, tension, label, slots, onNodeHover } = options;
+  const svg = select2(svgElement);
+  if (!root.children?.length) {
+    svg.selectAll("g.dx-bundle-root").remove();
+    return;
   }
-  /**
-  * Add node.
-  */
-  addNode(parent, node, index) {
-    if (!node) {
-      const id = Key.ObjectId.random();
-      node = {
-        id,
-        children: [],
-        data: {
-          text: ""
+  cluster().size([
+    2 * Math.PI,
+    radius
+  ])(root);
+  const g = svg.selectAll("g.dx-bundle-root").data([
+    null
+  ]).join("g").classed("dx-bundle-root", true);
+  const linksLayer = g.selectAll("g.dx-bundle-links").data([
+    null
+  ]).join("g").classed("dx-bundle-links", true);
+  const nodesLayer = g.selectAll("g.dx-bundle-nodes").data([
+    null
+  ]).join("g").classed("dx-bundle-nodes", true);
+  const line = lineRadial().curve(curveBundle.beta(tension)).radius((d) => d.y).angle((d) => d.x);
+  const leaves = root.leaves();
+  const flatEdges = leaves.flatMap((leaf) => leaf.outgoing ?? []);
+  const paths = linksLayer.selectAll("path").data(flatEdges, (d) => `${d[0].data.id}->${d[1].data.id}`).join((enter) => enter.append("path").attr("class", slots.path ?? "").attr("fill", "none").attr("opacity", 0), (update) => update, (exit) => exit.each(function() {
+    select2(this).interrupt();
+  }).transition().duration(TRANSITION_MS2).attr("opacity", 0).remove());
+  paths.each(function(d) {
+    d[0].pathEl = this;
+  }).transition().duration(TRANSITION_MS2).attr("opacity", 1).attr("d", ([s, t]) => line(s.path(t)));
+  const labels = nodesLayer.selectAll("g.dx-bundle-leaf").data(leaves, (d) => d.data.id).join((enter) => {
+    const ge = enter.append("g").classed("dx-bundle-leaf", true).attr("opacity", 0);
+    ge.append("circle").style("cursor", "pointer");
+    ge.append("text").attr("dy", "0.32em").attr("paint-order", "stroke").style("cursor", "pointer");
+    return ge;
+  }, (update) => update, (exit) => exit.each(function() {
+    select2(this).interrupt();
+  }).transition().duration(TRANSITION_MS2).attr("opacity", 0).remove());
+  labels.transition().duration(TRANSITION_MS2).attr("opacity", 1).attr("transform", (d) => `rotate(${d.x * 180 / Math.PI - 90}) translate(${d.y},0)`);
+  const onEnter = function(event, d) {
+    onNodeHover(d.data, event);
+    hover(linksLayer, leaves, d, true);
+  };
+  const onLeave = function(event, d) {
+    onNodeHover(null);
+    hover(linksLayer, leaves, d, false);
+  };
+  labels.select("circle").attr("class", [
+    slots.node ?? "",
+    "dx-leaf"
+  ].filter(Boolean).join(" ")).attr("r", r).style("fill", (d) => getNodeFillForObject(d.data.data)).each(function(d) {
+    d.circle = this;
+  }).on("pointerenter", onEnter).on("pointerleave", onLeave);
+  labels.select("text").attr("class", slots.text ?? "").attr("x", (d) => d.x < Math.PI ? r + 4 : -(r + 4)).attr("text-anchor", (d) => d.x < Math.PI ? "start" : "end").attr("transform", (d) => d.x >= Math.PI ? "rotate(180)" : null).each(function(d) {
+    d.text = this;
+  }).text((d) => label(d.data)).on("pointerenter", onEnter).on("pointerleave", onLeave);
+};
+var hover = (linksLayer, leaves, focused, on) => {
+  const outgoing = new Set((focused.outgoing ?? []).map(([, t]) => t));
+  const incoming = new Set((focused.incoming ?? []).map(([s]) => s));
+  linksLayer.selectAll("path").style("stroke", (d) => {
+    if (!on) {
+      return null;
+    }
+    if (d[0] === focused) {
+      return "var(--color-orange-500)";
+    }
+    if (d[1] === focused) {
+      return "var(--color-sky-500)";
+    }
+    return null;
+  }).style("stroke-width", (d) => on && (d[0] === focused || d[1] === focused) ? "1.5px" : null).style("opacity", (d) => on && d[0] !== focused && d[1] !== focused ? "0.08" : null);
+  for (const leaf of leaves) {
+    const isOut = outgoing.has(leaf);
+    const isIn = incoming.has(leaf);
+    const isConnected = isOut || isIn;
+    if (leaf.text) {
+      select2(leaf.text).style("fill", () => {
+        if (!on) {
+          return null;
         }
-      };
+        if (leaf === focused) {
+          return "var(--color-neutral-900)";
+        }
+        if (isOut) {
+          return "var(--color-orange-500)";
+        }
+        if (isIn) {
+          return "var(--color-sky-500)";
+        }
+        return null;
+      }).style("font-weight", () => on && leaf === focused ? "600" : null);
+    }
+    if (leaf.circle) {
+      select2(leaf.circle).style("stroke", () => on && isConnected ? "var(--color-orange-400)" : null).style("stroke-width", () => on && isConnected ? "2.5px" : null).style("opacity", () => on && !isConnected && leaf !== focused ? "0.15" : null);
     }
-    this._tree.nodes[node.id] = node;
-    parent.children.splice(index ?? parent.children.length, 0, node.id);
-    return node;
   }
-  /**
-  * Delete node.
-  */
-  deleteNode(parent, id) {
-    const node = this._tree.nodes[id];
-    if (!node) {
+};
+
+// src/components/Tree/layout/RadialTree.tsx
+import { cluster as d3Cluster, linkRadial, select as select3, tree as d3Tree } from "d3";
+import React7, { useCallback as useCallback3, useEffect as useEffect8, useMemo as useMemo4, useRef as useRef5, useState as useState4 } from "react";
+import { mx as mx2 } from "@dxos/ui-theme";
+
+// src/components/Tree/layout/hierarchy.ts
+import { hierarchy as d3Hierarchy } from "d3";
+var buildHierarchy = (data, collapsed = /* @__PURE__ */ new Set()) => {
+  return d3Hierarchy(data, (d) => {
+    if (!d.children?.length) {
       return void 0;
     }
-    delete this._tree.nodes[node.id];
-    const idx = parent.children.findIndex((child) => child === id);
-    if (idx !== -1) {
-      parent.children.splice(idx, 1);
-    }
-    return node;
-  }
-  /**
-  * Move child node.
-  */
-  moveNode(node, from, to) {
-    invariant(from >= 0 && from < node.children.length, void 0, {
-      F: __dxlog_file,
-      L: 228,
-      S: this,
-      A: [
-        "from >= 0 && from < node.children.length",
-        ""
-      ]
-    });
-    invariant(to >= 0 && to < node.children.length, void 0, {
-      F: __dxlog_file,
-      L: 229,
-      S: this,
-      A: [
-        "to >= 0 && to < node.children.length",
-        ""
-      ]
+    return collapsed.has(d.id) ? void 0 : d.children;
+  });
+};
+var isCollapsed = (data, collapsed) => Boolean(data.children?.length) && collapsed.has(data.id);
+var isLeaf = (data) => !data.children?.length;
+
+// src/components/Tree/layout/RadialTree.tsx
+var TRANSITION_MS3 = 350;
+var RadialTree = ({ classNames, data, label = (d) => d.label ?? d.id, slots = defaultTreeLayoutSlots, r = 4, padding = 80, initialCollapsed, cluster: cluster2 = false, onNodeClick, onNodeHover }) => {
+  const svgRef = useRef5(null);
+  const { setRef, width, height } = useContainerSize();
+  const [collapsed, setCollapsed] = useState4(() => new Set(initialCollapsed ?? []));
+  const toggle = useCallback3((id) => {
+    setCollapsed((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) {
+        next.delete(id);
+      } else {
+        next.add(id);
+      }
+      return next;
     });
-    if (from === to) {
-      return null;
-    }
-    const child = node.children[from];
-    node.children.splice(from, 1);
-    node.children.splice(to, 0, child);
-    return this.getNode(child);
-  }
-  /**
-  * Indent node.
-  */
-  indentNode(node) {
-    const parent = this.getParent(node);
-    if (!parent) {
-      return;
+  }, []);
+  const handleClickRef = useRef5(() => {
+  });
+  handleClickRef.current = (node) => {
+    onNodeClick?.(node);
+    if (node.children?.length) {
+      toggle(node.id);
     }
-    const idx = parent.children.findIndex((child) => child === node.id);
-    if (idx < 1 || idx >= parent.children.length) {
+  };
+  const handleHoverRef = useRef5(() => {
+  });
+  handleHoverRef.current = (node, event) => onNodeHover?.(node, event);
+  const root = useMemo4(() => buildHierarchy(data, collapsed), [
+    data,
+    collapsed
+  ]);
+  useEffect8(() => {
+    if (!svgRef.current || !width || !height) {
       return;
     }
-    const previous = this.getNode(parent.children[idx - 1]);
-    parent.children.splice(idx, 1);
-    previous.children.push(node.id);
-  }
-  /**
-  * Unindent node.
-  */
-  unindentNode(node) {
-    const parent = this.getParent(node);
-    if (!parent) {
-      return;
+    const radius = Math.max(0, Math.min(width, height) / 2 - padding);
+    renderRadialTree(svgRef.current, root, {
+      radius,
+      r,
+      label,
+      slots,
+      collapsed,
+      cluster: cluster2,
+      onNodeClick: (n) => handleClickRef.current(n),
+      onNodeHover: (n, e) => handleHoverRef.current(n, e)
+    });
+  }, [
+    root,
+    width,
+    height,
+    r,
+    padding,
+    label,
+    slots,
+    collapsed,
+    cluster2
+  ]);
+  return /* @__PURE__ */ React7.createElement("div", {
+    ref: setRef,
+    className: mx2("dx-expander relative", classNames)
+  }, width > 0 && height > 0 && /* @__PURE__ */ React7.createElement("svg", {
+    ref: svgRef,
+    xmlns: "http://www.w3.org/2000/svg",
+    width,
+    height,
+    viewBox: `${-width / 2} ${-height / 2} ${width} ${height}`
+  }));
+};
+var renderRadialTree = (svgElement, root, options) => {
+  const { radius, r, label, slots, collapsed, cluster: cluster2, onNodeClick, onNodeHover } = options;
+  const svg = select3(svgElement);
+  const layout = cluster2 ? d3Cluster() : d3Tree();
+  layout.size([
+    2 * Math.PI,
+    radius
+  ]).separation((a, b) => (a.parent === b.parent ? 1 : 2) / Math.max(1, a.depth))(root);
+  const g = svg.selectAll("g.dx-radial-root").data([
+    null
+  ]).join("g").classed("dx-radial-root", true);
+  const linksLayer = g.selectAll("g.dx-radial-links").data([
+    null
+  ]).join("g").classed("dx-radial-links", true);
+  const nodesLayer = g.selectAll("g.dx-radial-nodes").data([
+    null
+  ]).join("g").classed("dx-radial-nodes", true);
+  const linkPath = linkRadial().angle((d) => d.x).radius((d) => d.y);
+  linksLayer.selectAll("path").data(root.links(), (d) => `${d.source.data.id}->${d.target.data.id}`).join((enter) => enter.append("path").attr("class", slots.path ?? "").attr("fill", "none").attr("opacity", 0), (update) => update, (exit) => exit.transition().duration(TRANSITION_MS3).attr("opacity", 0).remove()).transition().duration(TRANSITION_MS3).attr("opacity", 1).attr("d", linkPath);
+  const node = nodesLayer.selectAll("g.dx-radial-node").data(root.descendants(), (d) => d.data.id);
+  const nodeEnter = node.enter().append("g").classed("dx-radial-node", true).attr("opacity", 0).attr("transform", (d) => `rotate(${d.x * 180 / Math.PI - 90}) translate(${d.y},0)`).style("cursor", (d) => d.data.children?.length ? "pointer" : "default").on("click", (_, d) => onNodeClick(d.data));
+  nodeEnter.append("circle").attr("r", r).on("pointerenter", (event, d) => onNodeHover(d.data, event)).on("pointerleave", (event) => onNodeHover(null, event));
+  nodeEnter.append("text").attr("dy", "0.32em").attr("paint-order", "stroke").text((d) => label(d.data));
+  const nodeMerge = nodeEnter.merge(node);
+  nodeMerge.transition().duration(TRANSITION_MS3).attr("opacity", 1).attr("transform", (d) => `rotate(${d.x * 180 / Math.PI - 90}) translate(${d.y},0)`);
+  nodeMerge.select("circle").attr("class", (d) => {
+    const collapsedHere = isCollapsed(d.data, collapsed);
+    const leaf = isLeaf(d.data);
+    return [
+      slots.node ?? "",
+      collapsedHere ? "dx-collapsed" : leaf ? "dx-leaf" : "dx-branch"
+    ].filter(Boolean).join(" ");
+  }).attr("r", r).style("fill", (d) => isLeaf(d.data) ? getNodeFillForObject(d.data.data) : null);
+  nodeMerge.select("text").attr("class", slots.text ?? "").attr("transform", (d) => d.x >= Math.PI ? "rotate(180)" : null).attr("x", (d) => d.x < Math.PI === !d.children ? r + 4 : -(r + 4)).attr("text-anchor", (d) => d.x < Math.PI === !d.children ? "start" : "end").text((d) => label(d.data));
+  node.exit().transition().duration(TRANSITION_MS3).attr("opacity", 0).remove();
+};
+
+// src/components/Tree/layout/TidyTree.tsx
+import { curveBumpX, link as d3Link, select as select4, tree as d3Tree2 } from "d3";
+import React8, { useCallback as useCallback4, useEffect as useEffect9, useMemo as useMemo5, useRef as useRef6, useState as useState5 } from "react";
+import { mx as mx3 } from "@dxos/ui-theme";
+var TRANSITION_MS4 = 350;
+var TidyTree = ({ classNames, data, label = (d) => d.label ?? d.id, slots = defaultTreeLayoutSlots, r = 4, margin = 24, initialCollapsed, onNodeClick }) => {
+  const svgRef = useRef6(null);
+  const { setRef, width, height } = useContainerSize();
+  const [collapsed, setCollapsed] = useState5(() => new Set(initialCollapsed ?? []));
+  const toggle = useCallback4((id) => {
+    setCollapsed((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) {
+        next.delete(id);
+      } else {
+        next.add(id);
+      }
+      return next;
+    });
+  }, []);
+  const handleClickRef = useRef6(() => {
+  });
+  handleClickRef.current = (node) => {
+    onNodeClick?.(node);
+    if (node.children?.length) {
+      toggle(node.id);
     }
-    const ancestor = this.getParent(parent);
-    if (!ancestor) {
+  };
+  const root = useMemo5(() => buildHierarchy(data, collapsed), [
+    data,
+    collapsed
+  ]);
+  useEffect9(() => {
+    if (!svgRef.current || !width || !height) {
       return;
     }
-    const nodeIdx = parent.children.findIndex((id) => id === node.id);
-    const [_, ...rest] = parent.children.splice(nodeIdx, parent.children.length - nodeIdx);
-    parent.children.splice(nodeIdx, parent.children.length - nodeIdx);
-    const parentIdx = this.getChildNodes(ancestor).findIndex((n) => n.id === parent.id);
-    ancestor.children.splice(parentIdx + 1, 0, node.id);
-    node.children.push(...rest);
-  }
-  constructor(tree3) {
-    _define_property(this, "_tree", void 0);
-    this._tree = tree3 ?? _Tree.create();
-  }
+    renderTidyTree(svgRef.current, root, {
+      width,
+      height,
+      r,
+      margin,
+      label,
+      slots,
+      collapsed,
+      onNodeClick: (n) => handleClickRef.current(n)
+    });
+  }, [
+    root,
+    width,
+    height,
+    r,
+    margin,
+    label,
+    slots,
+    collapsed
+  ]);
+  return /* @__PURE__ */ React8.createElement("div", {
+    ref: setRef,
+    className: mx3("dx-expander relative", classNames)
+  }, width > 0 && height > 0 && /* @__PURE__ */ React8.createElement("svg", {
+    ref: svgRef,
+    xmlns: "http://www.w3.org/2000/svg",
+    width,
+    height,
+    viewBox: `${-width / 2} ${-height / 2} ${width} ${height}`
+  }));
 };
-_define_property(Tree, "create", () => {
-  const id = Key.ObjectId.random();
-  return Obj.make(TreeType, {
-    root: id,
-    nodes: {
-      [id]: {
-        id,
-        children: [],
-        data: {
-          text: ""
-        }
-      }
+var renderTidyTree = (svgElement, root, options) => {
+  const { width, height, r, margin, label, slots, collapsed, onNodeClick } = options;
+  const svg = select4(svgElement);
+  const dx = 18;
+  const dy = Math.max(60, (width - margin * 2) / Math.max(1, root.height + 1));
+  d3Tree2().nodeSize([
+    dx,
+    dy
+  ])(root);
+  let x0 = Infinity;
+  let x1 = -x0;
+  root.each((d) => {
+    if (d.x > x1) {
+      x1 = d.x;
+    }
+    if (d.x < x0) {
+      x0 = d.x;
     }
   });
-});
-
-// src/components/Tree/types/types.ts
-var mapGraphToTreeData = (model, maxDepth = 8) => {
-  let data;
-  return data;
+  const treeWidth = width - margin * 2;
+  const treeHeight = x1 - x0;
+  const scaleY = treeHeight > 0 ? Math.min(1, (height - margin * 2) / treeHeight) : 1;
+  const offsetX = -treeWidth / 2;
+  const offsetY = -(x0 + x1) / 2;
+  const g = svg.selectAll("g.dx-tidy-root").data([
+    null
+  ]).join("g").classed("dx-tidy-root", true);
+  const linksLayer = g.selectAll("g.dx-tidy-links").data([
+    null
+  ]).join("g").classed("dx-tidy-links", true);
+  const nodesLayer = g.selectAll("g.dx-tidy-nodes").data([
+    null
+  ]).join("g").classed("dx-tidy-nodes", true);
+  const linkPath = d3Link(curveBumpX).x((d) => offsetX + d.y).y((d) => (d.x + offsetY) * scaleY);
+  linksLayer.selectAll("path").data(root.links(), (d) => `${d.source.data.id}->${d.target.data.id}`).join((enter) => enter.append("path").attr("class", slots.path ?? "").attr("fill", "none").attr("opacity", 0), (update) => update, (exit) => exit.transition().duration(TRANSITION_MS4).attr("opacity", 0).remove()).transition().duration(TRANSITION_MS4).attr("opacity", 1).attr("d", linkPath);
+  const node = nodesLayer.selectAll("g.dx-tidy-node").data(root.descendants(), (d) => d.data.id);
+  const nodeEnter = node.enter().append("g").classed("dx-tidy-node", true).attr("transform", (d) => `translate(${offsetX + d.y},${(d.x + offsetY) * scaleY})`).attr("opacity", 0).style("cursor", (d) => d.data.children?.length ? "pointer" : "default").on("click", (_, d) => onNodeClick(d.data));
+  nodeEnter.append("circle").attr("r", r);
+  nodeEnter.append("text").attr("dy", "0.32em").attr("x", (d) => d.children ? -(r + 4) : r + 4).attr("text-anchor", (d) => d.children ? "end" : "start").text((d) => label(d.data));
+  const nodeMerge = nodeEnter.merge(node);
+  nodeMerge.transition().duration(TRANSITION_MS4).attr("opacity", 1).attr("transform", (d) => `translate(${offsetX + d.y},${(d.x + offsetY) * scaleY})`);
+  nodeMerge.select("circle").attr("class", (d) => {
+    const collapsedHere = isCollapsed(d.data, collapsed);
+    const leaf = isLeaf(d.data);
+    return [
+      slots.node ?? "",
+      collapsedHere ? "dx-collapsed" : leaf ? "dx-leaf" : "dx-branch"
+    ].filter(Boolean).join(" ");
+  }).attr("r", r);
+  nodeMerge.select("text").attr("class", slots.text ?? "").attr("x", (d) => d.children ? -(r + 4) : r + 4).attr("text-anchor", (d) => d.children ? "end" : "start").text((d) => label(d.data));
+  node.exit().each(function() {
+    select4(this).interrupt();
+  }).transition().duration(TRANSITION_MS4).attr("opacity", 0).remove();
 };
 
 // src/components/Tree/Tree.tsx
-var defaultTreeLayoutSlots = {
-  node: "fill-blue-600",
-  path: "fill-none stroke-blue-400 stroke-[0.5px]",
-  text: "stroke-[0.5px] stroke-neutral-700 text-xs"
-};
-var renderers = /* @__PURE__ */ new Map([
-  [
-    "tidy",
-    TidyTree_default
-  ],
-  [
-    "radial",
-    RadialTree_default
-  ],
-  [
-    "edge",
-    HierarchicalEdgeBundling_default
-  ]
-]);
-var Tree2 = ({ space, selected, variant = "tidy", onNodeClick }) => {
-  var _effect = _useSignals3();
-  try {
-    const [model] = useAsyncState(async () => space ? new SpaceGraphModel().open(space) : void 0, [
-      space,
-      selected
-    ]);
-    const [tree3, setTree] = useState();
-    useEffect3(() => {
-      return model?.subscribe(() => {
-        const tree4 = mapGraphToTreeData(model);
-        setTree(tree4);
-      }, true);
-    }, [
-      model
-    ]);
-    const context = useRef(null);
-    useEffect3(() => {
-      if (context.current?.size) {
-        const { width, height } = context.current.size;
-        const size = Math.min(width, height);
-        const radius = size * 0.4;
-        const options = {
-          // TODO(burdon): Type.
-          label: (d) => d.label ?? d.id,
-          width,
-          height,
-          radius,
-          marginLeft: (width - radius * 2) / 2,
-          marginRight: (width - radius * 2) / 2,
-          marginTop: (height - radius * 2) / 2,
-          marginBottom: (height - radius * 2) / 2,
-          slots: defaultTreeLayoutSlots
-        };
-        if (tree3) {
-          const renderer = renderers.get(variant);
-          renderer?.(context.current.svg, tree3, options);
-        }
-      }
-    }, [
-      context.current,
-      tree3
-    ]);
-    return /* @__PURE__ */ React3.createElement("div", {
-      onClick: () => onNodeClick?.()
-    }, /* @__PURE__ */ React3.createElement(SVG.Root, {
-      ref: context
-    }));
-  } finally {
-    _effect.f();
-  }
+var Tree = ({ classNames, data, edges, variant = "tidy", label, slots, initialCollapsed, onNodeClick, onNodeHover }) => {
+  return useMemo6(() => {
+    switch (variant) {
+      case "tidy":
+        return /* @__PURE__ */ React9.createElement(TidyTree, {
+          classNames,
+          data,
+          label,
+          slots,
+          initialCollapsed,
+          onNodeClick
+        });
+      case "radial":
+        return /* @__PURE__ */ React9.createElement(RadialTree, {
+          classNames,
+          data,
+          label,
+          slots,
+          initialCollapsed,
+          onNodeClick,
+          onNodeHover
+        });
+      case "edge":
+        return /* @__PURE__ */ React9.createElement(HierarchicalEdgeBundling, {
+          classNames,
+          data,
+          edges: edges ?? [],
+          label,
+          slots,
+          onNodeHover
+        });
+    }
+  }, [
+    variant,
+    classNames,
+    data,
+    edges,
+    label,
+    slots,
+    initialCollapsed,
+    onNodeClick,
+    onNodeHover
+  ]);
 };
-
-// src/components/index.ts
-import { lazy } from "react";
-var ExplorerContainer = lazy(() => import("./ExplorerContainer-6SHZJ6AK.mjs"));
-
 export {
+  CanvasForceGraph,
   Chart,
+  ForceGraph,
   Globe,
+  HierarchicalEdgeBundling,
+  Lattice,
+  RadialTree,
+  TidyTree,
+  Tree,
+  buildHierarchy,
   defaultTreeLayoutSlots,
-  Tree2 as Tree,
-  ExplorerContainer
+  isCollapsed,
+  isLeaf,
+  treeTypeToTreeNode
 };
-//# sourceMappingURL=chunk-MOM5KCKC.mjs.map
+//# sourceMappingURL=index.mjs.map