@dxos/app-graph 0.8.4-main.ead640a → 0.8.4-main.ef1bc66f44

package/dist/lib/browser/index.mjs

@@ -1,33 +1,97 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/atoms.ts
+var atoms_exports = {};
+__export(atoms_exports, {
+  fromObservable: () => fromObservable
+});
+import { Atom } from "@effect-atom/atom-react";
+var observableFamily = Atom.family((observable) => {
+  return Atom.make((get2) => {
+    const subscription = observable.subscribe((value) => get2.setSelf(value));
+    get2.addFinalizer(() => subscription.unsubscribe());
+    return observable.get();
+  });
+});
+var fromObservable = (observable) => {
+  return observableFamily(observable);
+};
+
 // src/graph.ts
-import { Registry, Rx } from "@effect-rx/rx-react";
+var graph_exports = {};
+__export(graph_exports, {
+  GraphKind: () => GraphKind,
+  GraphTypeId: () => GraphTypeId,
+  addEdge: () => addEdge,
+  addEdges: () => addEdges,
+  addNode: () => addNode,
+  addNodes: () => addNodes,
+  expand: () => expand,
+  getActions: () => getActions,
+  getConnections: () => getConnections,
+  getEdges: () => getEdges,
+  getGraph: () => getGraph,
+  getNode: () => getNode,
+  getNodeOrThrow: () => getNodeOrThrow,
+  getPath: () => getPath,
+  getRoot: () => getRoot,
+  initialize: () => initialize,
+  make: () => make,
+  removeEdge: () => removeEdge,
+  removeEdges: () => removeEdges,
+  removeNode: () => removeNode,
+  removeNodes: () => removeNodes,
+  sortEdges: () => sortEdges,
+  toJSON: () => toJSON,
+  traverse: () => traverse,
+  waitForPath: () => waitForPath
+});
+import { Atom as Atom2, Registry } from "@effect-atom/atom-react";
 import * as Function from "effect/Function";
 import * as Option from "effect/Option";
+import * as Pipeable from "effect/Pipeable";
 import * as Record from "effect/Record";
 import { Event, Trigger } from "@dxos/async";
 import { todo } from "@dxos/debug";
 import { invariant } from "@dxos/invariant";
 import { log } from "@dxos/log";
 import { isNonNullable } from "@dxos/util";
-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;
-}
+
+// src/node.ts
+var node_exports = {};
+__export(node_exports, {
+  ActionGroupType: () => ActionGroupType,
+  ActionType: () => ActionType,
+  RootId: () => RootId,
+  RootType: () => RootType,
+  actionGroupSymbol: () => actionGroupSymbol,
+  isAction: () => isAction,
+  isActionGroup: () => isActionGroup,
+  isActionLike: () => isActionLike,
+  isGraphNode: () => isGraphNode
+});
+var RootId = "root";
+var RootType = "dxos.org/type/GraphRoot";
+var ActionType = "dxos.org/type/GraphAction";
+var ActionGroupType = "dxos.org/type/GraphActionGroup";
+var isGraphNode = (data) => data && typeof data === "object" && "id" in data && "properties" in data && data.properties ? typeof data.properties === "object" && "data" in data : false;
+var isAction = (data) => isGraphNode(data) ? typeof data.data === "function" && data.type === ActionType : false;
+var actionGroupSymbol = Symbol("ActionGroup");
+var isActionGroup = (data) => isGraphNode(data) ? data.data === actionGroupSymbol && data.type === ActionGroupType : false;
+var isActionLike = (data) => isAction(data) || isActionGroup(data);
+
+// src/graph.ts
 var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-graph/src/graph.ts";
 var graphSymbol = Symbol("graph");
 var getGraph = (node) => {
   const graph = node[graphSymbol];
   invariant(graph, "Node is not associated with a graph.", {
     F: __dxlog_file,
-    L: 27,
+    L: 32,
     S: void 0,
     A: [
       "graph",
@@ -36,603 +100,815 @@ var getGraph = (node) => {
   });
   return graph;
 };
-var ROOT_ID = "root";
-var ROOT_TYPE = "dxos.org/type/GraphRoot";
-var ACTION_TYPE = "dxos.org/type/GraphAction";
-var ACTION_GROUP_TYPE = "dxos.org/type/GraphActionGroup";
-var Graph = class {
-  toJSON(id = ROOT_ID) {
-    return this._registry.get(this._json(id));
+var GraphTypeId = Symbol.for("@dxos/app-graph/Graph");
+var GraphKind = Symbol.for("@dxos/app-graph/GraphKind");
+var GraphImpl = class {
+  [GraphTypeId] = GraphTypeId;
+  [GraphKind] = "writable";
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments);
+  }
+  onNodeChanged = new Event();
+  _onExpand;
+  _onInitialize;
+  _onRemoveNode;
+  _registry;
+  _expanded = Record.empty();
+  _initialized = Record.empty();
+  _initialEdges = Record.empty();
+  _initialNodes = Record.fromEntries([
+    [
+      RootId,
+      this._constructNode({
+        id: RootId,
+        type: RootType,
+        data: null,
+        properties: {}
+      })
+    ]
+  ]);
+  /** @internal */
+  _node = Atom2.family((id) => {
+    const initial = Option.flatten(Record.get(this._initialNodes, id));
+    return Atom2.make(initial).pipe(Atom2.keepAlive, Atom2.withLabel(`graph:node:${id}`));
+  });
+  _nodeOrThrow = Atom2.family((id) => {
+    return Atom2.make((get2) => {
+      const node = get2(this._node(id));
+      invariant(Option.isSome(node), `Node not available: ${id}`, {
+        F: __dxlog_file,
+        L: 174,
+        S: this,
+        A: [
+          "Option.isSome(node)",
+          "`Node not available: ${id}`"
+        ]
+      });
+      return node.value;
+    });
+  });
+  _edges = Atom2.family((id) => {
+    const initial = Record.get(this._initialEdges, id).pipe(Option.getOrElse(() => ({
+      inbound: [],
+      outbound: []
+    })));
+    return Atom2.make(initial).pipe(Atom2.keepAlive, Atom2.withLabel(`graph:edges:${id}`));
+  });
+  // NOTE: Currently the argument to the family needs to be referentially stable for the atom to be referentially stable.
+  // TODO(wittjosiah): Atom feature request, support for something akin to `ComplexMap` to allow for complex arguments.
+  _connections = Atom2.family((key) => {
+    return Atom2.make((get2) => {
+      const [id, relation] = key.split("$");
+      const edges = get2(this._edges(id));
+      return edges[relation].map((id2) => get2(this._node(id2))).filter(Option.isSome).map((o) => o.value);
+    }).pipe(Atom2.withLabel(`graph:connections:${key}`));
+  });
+  _actions = Atom2.family((id) => {
+    return Atom2.make((get2) => {
+      return get2(this._connections(`${id}$outbound`)).filter((node) => node.type === ActionType || node.type === ActionGroupType);
+    }).pipe(Atom2.withLabel(`graph:actions:${id}`));
+  });
+  _json = Atom2.family((id) => {
+    return Atom2.make((get2) => {
+      const toJSON2 = (node, seen = []) => {
+        const nodes = get2(this._connections(`${node.id}$outbound`));
+        const obj = {
+          id: node.id,
+          type: node.type
+        };
+        if (node.properties.label) {
+          obj.label = node.properties.label;
+        }
+        if (nodes.length) {
+          obj.nodes = nodes.map((n) => {
+            const nextSeen = [
+              ...seen,
+              node.id
+            ];
+            return nextSeen.includes(n.id) ? void 0 : toJSON2(n, nextSeen);
+          }).filter(isNonNullable);
+        }
+        return obj;
+      };
+      const root = get2(this._nodeOrThrow(id));
+      return toJSON2(root);
+    }).pipe(Atom2.withLabel(`graph:json:${id}`));
+  });
+  constructor({ registry, nodes, edges, onInitialize, onExpand, onRemoveNode } = {}) {
+    this._registry = registry ?? Registry.make();
+    this._onInitialize = onInitialize;
+    this._onExpand = onExpand;
+    this._onRemoveNode = onRemoveNode;
+    if (nodes) {
+      nodes.forEach((node) => {
+        Record.set(this._initialNodes, node.id, this._constructNode(node));
+      });
+    }
+    if (edges) {
+      Object.entries(edges).forEach(([source, edges2]) => {
+        Record.set(this._initialEdges, source, edges2);
+      });
+    }
   }
-  json(id = ROOT_ID) {
-    return this._json(id);
+  json(id = RootId) {
+    return jsonImpl(this, id);
   }
   node(id) {
-    return this._node(id);
+    return nodeImpl(this, id);
   }
   nodeOrThrow(id) {
-    return this._nodeOrThrow(id);
+    return nodeOrThrowImpl(this, id);
   }
   connections(id, relation = "outbound") {
-    return this._connections(`${id}$${relation}`);
+    return connectionsImpl(this, id, relation);
   }
   actions(id) {
-    return this._actions(id);
+    return actionsImpl(this, id);
   }
   edges(id) {
-    return this._edges(id);
+    return edgesImpl(this, id);
   }
-  get root() {
-    return this.getNodeOrThrow(ROOT_ID);
+  /** @internal */
+  _constructNode(node) {
+    return Option.some({
+      [graphSymbol]: this,
+      data: null,
+      properties: {},
+      ...node
+    });
   }
-  getNode(id) {
-    return this._registry.get(this.node(id));
+};
+var getInternal = (graph) => {
+  return graph;
+};
+var toJSON = (graph, id = RootId) => {
+  const internal = getInternal(graph);
+  return internal._registry.get(internal._json(id));
+};
+var jsonImpl = (graph, id = RootId) => {
+  const internal = getInternal(graph);
+  return internal._json(id);
+};
+var nodeImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._node(id);
+};
+var nodeOrThrowImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._nodeOrThrow(id);
+};
+var connectionsImpl = (graph, id, relation = "outbound") => {
+  const internal = getInternal(graph);
+  return internal._connections(`${id}$${relation}`);
+};
+var actionsImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._actions(id);
+};
+var edgesImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._edges(id);
+};
+var getNodeImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._registry.get(nodeImpl(graph, id));
+};
+function getNode(graphOrId, id) {
+  if (typeof graphOrId === "string") {
+    const id2 = graphOrId;
+    return (graph) => getNodeImpl(graph, id2);
+  } else {
+    const graph = graphOrId;
+    return getNodeImpl(graph, id);
   }
-  getNodeOrThrow(id) {
-    return this._registry.get(this.nodeOrThrow(id));
+}
+var getNodeOrThrowImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._registry.get(nodeOrThrowImpl(graph, id));
+};
+function getNodeOrThrow(graphOrId, id) {
+  if (typeof graphOrId === "string") {
+    const id2 = graphOrId;
+    return (graph) => getNodeOrThrowImpl(graph, id2);
+  } else {
+    const graph = graphOrId;
+    return getNodeOrThrowImpl(graph, id);
   }
-  getConnections(id, relation = "outbound") {
-    return this._registry.get(this.connections(id, relation));
+}
+function getRoot(graph) {
+  return getNodeOrThrowImpl(graph, RootId);
+}
+var getConnectionsImpl = (graph, id, relation = "outbound") => {
+  const internal = getInternal(graph);
+  return internal._registry.get(connectionsImpl(graph, id, relation));
+};
+function getConnections(graphOrId, idOrRelation, relation) {
+  if (typeof graphOrId === "string") {
+    const id = graphOrId;
+    const rel = (typeof idOrRelation === "string" ? "outbound" : idOrRelation) ?? "outbound";
+    return (graph) => getConnectionsImpl(graph, id, rel);
+  } else {
+    const graph = graphOrId;
+    const id = idOrRelation;
+    const rel = relation ?? "outbound";
+    return getConnectionsImpl(graph, id, rel);
   }
-  getActions(id) {
-    return this._registry.get(this.actions(id));
+}
+var getActionsImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._registry.get(actionsImpl(graph, id));
+};
+function getActions(graphOrId, id) {
+  if (typeof graphOrId === "string") {
+    const id2 = graphOrId;
+    return (graph) => getActionsImpl(graph, id2);
+  } else {
+    const graph = graphOrId;
+    return getActionsImpl(graph, id);
   }
-  getEdges(id) {
-    return this._registry.get(this.edges(id));
+}
+var getEdgesImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._registry.get(edgesImpl(graph, id));
+};
+function getEdges(graphOrId, id) {
+  if (typeof graphOrId === "string") {
+    const id2 = graphOrId;
+    return (graph) => getEdgesImpl(graph, id2);
+  } else {
+    const graph = graphOrId;
+    return getEdgesImpl(graph, id);
   }
-  async initialize(id) {
-    const initialized = Record.get(this._initialized, id).pipe(Option.getOrElse(() => false));
-    log("initialize", {
-      id,
-      initialized
-    }, {
-      F: __dxlog_file,
-      L: 386,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (!initialized) {
-      await this._onInitialize?.(id);
-      Record.set(this._initialized, id, true);
-    }
+}
+var traverseImpl = (graph, options, path = []) => {
+  const { visitor, source = RootId, relation = "outbound" } = options;
+  if (path.includes(source)) {
+    return;
   }
-  expand(id, relation = "outbound") {
-    const key = `${id}$${relation}`;
-    const expanded = Record.get(this._expanded, key).pipe(Option.getOrElse(() => false));
-    log("expand", {
-      key,
-      expanded
-    }, {
-      F: __dxlog_file,
-      L: 396,
-      S: this,
-      C: (f, a) => f(...a)
+  const node = getNodeOrThrow(graph, source);
+  const shouldContinue = visitor(node, [
+    ...path,
+    source
+  ]);
+  if (shouldContinue === false) {
+    return;
+  }
+  Object.values(getConnections(graph, source, relation)).forEach((child) => traverseImpl(graph, {
+    source: child.id,
+    relation,
+    visitor
+  }, [
+    ...path,
+    source
+  ]));
+};
+function traverse(graphOrOptions, optionsOrPath, path) {
+  if (typeof graphOrOptions === "object" && "visitor" in graphOrOptions) {
+    const options = graphOrOptions;
+    const pathArg = Array.isArray(optionsOrPath) ? optionsOrPath : void 0;
+    return (graph) => traverseImpl(graph, options, pathArg);
+  } else {
+    const graph = graphOrOptions;
+    const options = optionsOrPath;
+    const pathArg = path ?? (Array.isArray(optionsOrPath) ? optionsOrPath : void 0);
+    return traverseImpl(graph, options, pathArg);
+  }
+}
+var getPathImpl = (graph, params) => {
+  return Function.pipe(getNode(graph, params.source ?? "root"), Option.flatMap((node) => {
+    let found = Option.none();
+    traverseImpl(graph, {
+      source: node.id,
+      visitor: (node2, path) => {
+        if (Option.isSome(found)) {
+          return false;
+        }
+        if (node2.id === params.target) {
+          found = Option.some(path);
+        }
+      }
     });
-    if (!expanded) {
-      this._onExpand?.(id, relation);
-      Record.set(this._expanded, key, true);
+    return found;
+  }));
+};
+function getPath(graphOrParams, params) {
+  if (params === void 0 && typeof graphOrParams === "object" && "target" in graphOrParams) {
+    const params2 = graphOrParams;
+    return (graph) => getPathImpl(graph, params2);
+  } else {
+    const graph = graphOrParams;
+    return getPathImpl(graph, params);
+  }
+}
+var waitForPathImpl = (graph, params, options) => {
+  const { timeout = 5e3, interval = 500 } = options ?? {};
+  const path = getPathImpl(graph, params);
+  if (Option.isSome(path)) {
+    return Promise.resolve(path.value);
+  }
+  const trigger = new Trigger();
+  const i = setInterval(() => {
+    const path2 = getPathImpl(graph, params);
+    if (Option.isSome(path2)) {
+      trigger.wake(path2.value);
     }
+  }, interval);
+  return trigger.wait({
+    timeout
+  }).finally(() => clearInterval(i));
+};
+function waitForPath(graphOrParams, paramsOrOptions, options) {
+  if (typeof graphOrParams === "object" && "target" in graphOrParams) {
+    const params = graphOrParams;
+    const opts = typeof paramsOrOptions === "object" && !("target" in paramsOrOptions) ? paramsOrOptions : void 0;
+    return (graph) => waitForPathImpl(graph, params, opts);
+  } else {
+    const graph = graphOrParams;
+    const params = paramsOrOptions;
+    return waitForPathImpl(graph, params, options);
   }
-  addNodes(nodes) {
-    Rx.batch(() => {
-      nodes.map((node) => this.addNode(node));
-    });
+}
+var initializeImpl = async (graph, id) => {
+  const internal = getInternal(graph);
+  const initialized = Record.get(internal._initialized, id).pipe(Option.getOrElse(() => false));
+  log("initialize", {
+    id,
+    initialized
+  }, {
+    F: __dxlog_file,
+    L: 661,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  if (!initialized) {
+    await internal._onInitialize?.(id);
+    Record.set(internal._initialized, id, true);
   }
-  addNode({ nodes, edges, ...nodeArg }) {
-    const { id, type, data = null, properties = {} } = nodeArg;
-    const nodeRx = this._node(id);
-    const node = this._registry.get(nodeRx);
-    Option.match(node, {
-      onSome: (node2) => {
-        const typeChanged = node2.type !== type;
-        const dataChanged = node2.data !== data;
-        const propertiesChanged = Object.keys(properties).some((key) => node2.properties[key] !== properties[key]);
-        log("existing node", {
-          id,
-          typeChanged,
-          dataChanged,
-          propertiesChanged
-        }, {
-          F: __dxlog_file,
-          L: 418,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (typeChanged || dataChanged || propertiesChanged) {
-          log("updating node", {
-            id,
-            type,
-            data,
-            properties
-          }, {
-            F: __dxlog_file,
-            L: 420,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          const newNode = Option.some({
-            ...node2,
-            type,
-            data,
-            properties: {
-              ...node2.properties,
-              ...properties
-            }
-          });
-          this._registry.set(nodeRx, newNode);
-          this.onNodeChanged.emit({
-            id,
-            node: newNode
-          });
-        }
-      },
-      onNone: () => {
-        log("new node", {
+  return graph;
+};
+function initialize(graphOrId, id) {
+  if (typeof graphOrId === "string") {
+    const id2 = graphOrId;
+    return (graph) => initializeImpl(graph, id2);
+  } else {
+    const graph = graphOrId;
+    return initializeImpl(graph, id);
+  }
+}
+var expandImpl = (graph, id, relation = "outbound") => {
+  const internal = getInternal(graph);
+  const key = `${id}$${relation}`;
+  const expanded = Record.get(internal._expanded, key).pipe(Option.getOrElse(() => false));
+  log("expand", {
+    key,
+    expanded
+  }, {
+    F: __dxlog_file,
+    L: 702,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  if (!expanded) {
+    internal._onExpand?.(id, relation);
+    Record.set(internal._expanded, key, true);
+  }
+  return graph;
+};
+function expand(graphOrId, idOrRelation, relation) {
+  if (typeof graphOrId === "string") {
+    const id = graphOrId;
+    const rel = (typeof idOrRelation === "string" ? "outbound" : idOrRelation) ?? "outbound";
+    return (graph) => expandImpl(graph, id, rel);
+  } else {
+    const graph = graphOrId;
+    const id = idOrRelation;
+    const rel = relation ?? "outbound";
+    return expandImpl(graph, id, rel);
+  }
+}
+var sortEdgesImpl = (graph, id, relation, order) => {
+  const internal = getInternal(graph);
+  const edgesAtom = internal._edges(id);
+  const edges = internal._registry.get(edgesAtom);
+  const unsorted = edges[relation].filter((id2) => !order.includes(id2)) ?? [];
+  const sorted = order.filter((id2) => edges[relation].includes(id2)) ?? [];
+  edges[relation].splice(0, edges[relation].length, ...[
+    ...sorted,
+    ...unsorted
+  ]);
+  internal._registry.set(edgesAtom, edges);
+  return graph;
+};
+function sortEdges(graphOrId, idOrRelation, relationOrOrder, order) {
+  if (typeof graphOrId === "string") {
+    const id = graphOrId;
+    const relation = idOrRelation;
+    const order2 = relationOrOrder;
+    return (graph) => sortEdgesImpl(graph, id, relation, order2);
+  } else {
+    const graph = graphOrId;
+    const id = idOrRelation;
+    const relation = relationOrOrder;
+    return sortEdgesImpl(graph, id, relation, order);
+  }
+}
+var addNodesImpl = (graph, nodes) => {
+  Atom2.batch(() => {
+    nodes.map((node) => addNodeImpl(graph, node));
+  });
+  return graph;
+};
+function addNodes(graphOrNodes, nodes) {
+  if (nodes === void 0) {
+    const nodes2 = graphOrNodes;
+    return (graph) => addNodesImpl(graph, nodes2);
+  } else {
+    const graph = graphOrNodes;
+    return addNodesImpl(graph, nodes);
+  }
+}
+var addNodeImpl = (graph, nodeArg) => {
+  const internal = getInternal(graph);
+  const { nodes, edges, id, type, data = null, properties = {}, ...rest } = nodeArg;
+  const nodeAtom = internal._node(id);
+  const existingNode = internal._registry.get(nodeAtom);
+  Option.match(existingNode, {
+    onSome: (existing) => {
+      const typeChanged = existing.type !== type;
+      const dataChanged = existing.data !== data;
+      const propertiesChanged = Object.keys(properties).some((key) => existing.properties[key] !== properties[key]);
+      log("existing node", {
+        id,
+        typeChanged,
+        dataChanged,
+        propertiesChanged
+      }, {
+        F: __dxlog_file,
+        L: 847,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      if (typeChanged || dataChanged || propertiesChanged) {
+        log("updating node", {
           id,
           type,
           data,
           properties
         }, {
           F: __dxlog_file,
-          L: 427,
-          S: this,
+          L: 854,
+          S: void 0,
           C: (f, a) => f(...a)
         });
-        const newNode = this._constructNode({
-          id,
+        const newNode = Option.some({
+          ...existing,
+          ...rest,
           type,
           data,
-          properties
+          properties: {
+            ...existing.properties,
+            ...properties
+          }
         });
-        this._registry.set(nodeRx, newNode);
-        this.onNodeChanged.emit({
+        internal._registry.set(nodeAtom, newNode);
+        graph.onNodeChanged.emit({
           id,
           node: newNode
         });
       }
-    });
-    if (nodes) {
-      this.addNodes(nodes);
-      const _edges = nodes.map((node2) => ({
-        source: id,
-        target: node2.id
-      }));
-      this.addEdges(_edges);
-    }
-    if (edges) {
-      todo();
-    }
-  }
-  removeNodes(ids, edges = false) {
-    Rx.batch(() => {
-      ids.map((id) => this.removeNode(id, edges));
-    });
-  }
-  removeNode(id, edges = false) {
-    const nodeRx = this._node(id);
-    this._registry.set(nodeRx, Option.none());
-    this.onNodeChanged.emit({
-      id,
-      node: Option.none()
-    });
-    if (edges) {
-      const { inbound, outbound } = this._registry.get(this._edges(id));
-      const edges2 = [
-        ...inbound.map((source) => ({
-          source,
-          target: id
-        })),
-        ...outbound.map((target) => ({
-          source: id,
-          target
-        }))
-      ];
-      this.removeEdges(edges2);
-    }
-    this._onRemoveNode?.(id);
-  }
-  addEdges(edges) {
-    Rx.batch(() => {
-      edges.map((edge) => this.addEdge(edge));
-    });
-  }
-  addEdge(edgeArg) {
-    const sourceRx = this._edges(edgeArg.source);
-    const source = this._registry.get(sourceRx);
-    if (!source.outbound.includes(edgeArg.target)) {
-      log("add outbound edge", {
-        source: edgeArg.source,
-        target: edgeArg.target
+    },
+    onNone: () => {
+      log("new node", {
+        id,
+        type,
+        data,
+        properties
       }, {
         F: __dxlog_file,
-        L: 482,
-        S: this,
+        L: 867,
+        S: void 0,
         C: (f, a) => f(...a)
       });
-      this._registry.set(sourceRx, {
-        inbound: source.inbound,
-        outbound: [
-          ...source.outbound,
-          edgeArg.target
-        ]
-      });
-    }
-    const targetRx = this._edges(edgeArg.target);
-    const target = this._registry.get(targetRx);
-    if (!target.inbound.includes(edgeArg.source)) {
-      log("add inbound edge", {
-        source: edgeArg.source,
-        target: edgeArg.target
-      }, {
-        F: __dxlog_file,
-        L: 489,
-        S: this,
-        C: (f, a) => f(...a)
+      const newNode = internal._constructNode({
+        id,
+        type,
+        data,
+        properties,
+        ...rest
       });
-      this._registry.set(targetRx, {
-        inbound: [
-          ...target.inbound,
-          edgeArg.source
-        ],
-        outbound: target.outbound
+      internal._registry.set(nodeAtom, newNode);
+      graph.onNodeChanged.emit({
+        id,
+        node: newNode
       });
     }
+  });
+  if (nodes) {
+    addNodesImpl(graph, nodes);
+    const _edges = nodes.map((node) => ({
+      source: id,
+      target: node.id
+    }));
+    addEdgesImpl(graph, _edges);
+  }
+  if (edges) {
+    todo();
+  }
+  return graph;
+};
+function addNode(graphOrNodeArg, nodeArg) {
+  if (nodeArg === void 0) {
+    const nodeArg2 = graphOrNodeArg;
+    return (graph) => addNodeImpl(graph, nodeArg2);
+  } else {
+    const graph = graphOrNodeArg;
+    return addNodeImpl(graph, nodeArg);
+  }
+}
+var removeNodesImpl = (graph, ids, edges = false) => {
+  Atom2.batch(() => {
+    ids.map((id) => removeNodeImpl(graph, id, edges));
+  });
+  return graph;
+};
+function removeNodes(graphOrIds, idsOrEdges, edges) {
+  if (Array.isArray(graphOrIds)) {
+    const ids = graphOrIds;
+    const edgesArg = typeof idsOrEdges === "boolean" ? idsOrEdges : false;
+    return (graph) => removeNodesImpl(graph, ids, edgesArg);
+  } else {
+    const graph = graphOrIds;
+    const ids = idsOrEdges;
+    const edgesArg = edges ?? false;
+    return removeNodesImpl(graph, ids, edgesArg);
+  }
+}
+var removeNodeImpl = (graph, id, edges = false) => {
+  const internal = getInternal(graph);
+  const nodeAtom = internal._node(id);
+  internal._registry.set(nodeAtom, Option.none());
+  graph.onNodeChanged.emit({
+    id,
+    node: Option.none()
+  });
+  if (edges) {
+    const { inbound, outbound } = internal._registry.get(internal._edges(id));
+    const edgesToRemove = [
+      ...inbound.map((source) => ({
+        source,
+        target: id
+      })),
+      ...outbound.map((target) => ({
+        source: id,
+        target
+      }))
+    ];
+    removeEdgesImpl(graph, edgesToRemove);
+  }
+  internal._onRemoveNode?.(id);
+  return graph;
+};
+function removeNode(graphOrId, idOrEdges, edges) {
+  if (typeof graphOrId === "string") {
+    const id = graphOrId;
+    const edgesArg = typeof idOrEdges === "boolean" ? idOrEdges : false;
+    return (graph) => removeNodeImpl(graph, id, edgesArg);
+  } else {
+    const graph = graphOrId;
+    const id = idOrEdges;
+    const edgesArg = edges ?? false;
+    return removeNodeImpl(graph, id, edgesArg);
+  }
+}
+var addEdgesImpl = (graph, edges) => {
+  Atom2.batch(() => {
+    edges.map((edge) => addEdgeImpl(graph, edge));
+  });
+  return graph;
+};
+function addEdges(graphOrEdges, edges) {
+  if (edges === void 0) {
+    const edges2 = graphOrEdges;
+    return (graph) => addEdgesImpl(graph, edges2);
+  } else {
+    const graph = graphOrEdges;
+    return addEdgesImpl(graph, edges);
   }
-  removeEdges(edges, removeOrphans = false) {
-    Rx.batch(() => {
-      edges.map((edge) => this.removeEdge(edge, removeOrphans));
+}
+var addEdgeImpl = (graph, edgeArg) => {
+  const internal = getInternal(graph);
+  const sourceAtom = internal._edges(edgeArg.source);
+  const source = internal._registry.get(sourceAtom);
+  if (!source.outbound.includes(edgeArg.target)) {
+    log("add outbound edge", {
+      source: edgeArg.source,
+      target: edgeArg.target
+    }, {
+      F: __dxlog_file,
+      L: 1026,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    internal._registry.set(sourceAtom, {
+      inbound: source.inbound,
+      outbound: [
+        ...source.outbound,
+        edgeArg.target
+      ]
     });
   }
-  removeEdge(edgeArg, removeOrphans = false) {
-    const sourceRx = this._edges(edgeArg.source);
-    const source = this._registry.get(sourceRx);
-    if (source.outbound.includes(edgeArg.target)) {
-      this._registry.set(sourceRx, {
-        inbound: source.inbound,
-        outbound: source.outbound.filter((id) => id !== edgeArg.target)
-      });
-    }
-    const targetRx = this._edges(edgeArg.target);
-    const target = this._registry.get(targetRx);
-    if (target.inbound.includes(edgeArg.source)) {
-      this._registry.set(targetRx, {
-        inbound: target.inbound.filter((id) => id !== edgeArg.source),
-        outbound: target.outbound
-      });
-    }
-    if (removeOrphans) {
-      const source2 = this._registry.get(sourceRx);
-      const target2 = this._registry.get(targetRx);
-      if (source2.outbound.length === 0 && source2.inbound.length === 0 && edgeArg.source !== ROOT_ID) {
-        this.removeNodes([
-          edgeArg.source
-        ]);
-      }
-      if (target2.outbound.length === 0 && target2.inbound.length === 0 && edgeArg.target !== ROOT_ID) {
-        this.removeNodes([
-          edgeArg.target
-        ]);
-      }
-    }
+  const targetAtom = internal._edges(edgeArg.target);
+  const target = internal._registry.get(targetAtom);
+  if (!target.inbound.includes(edgeArg.source)) {
+    log("add inbound edge", {
+      source: edgeArg.source,
+      target: edgeArg.target
+    }, {
+      F: __dxlog_file,
+      L: 1039,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    internal._registry.set(targetAtom, {
+      inbound: [
+        ...target.inbound,
+        edgeArg.source
+      ],
+      outbound: target.outbound
+    });
   }
-  sortEdges(id, relation, order) {
-    const edgesRx = this._edges(id);
-    const edges = this._registry.get(edgesRx);
-    const unsorted = edges[relation].filter((id2) => !order.includes(id2)) ?? [];
-    const sorted = order.filter((id2) => edges[relation].includes(id2)) ?? [];
-    edges[relation].splice(0, edges[relation].length, ...[
-      ...sorted,
-      ...unsorted
-    ]);
-    this._registry.set(edgesRx, edges);
+  return graph;
+};
+function addEdge(graphOrEdgeArg, edgeArg) {
+  if (edgeArg === void 0) {
+    const edgeArg2 = graphOrEdgeArg;
+    return (graph) => addEdgeImpl(graph, edgeArg2);
+  } else {
+    const graph = graphOrEdgeArg;
+    return addEdgeImpl(graph, edgeArg);
   }
-  traverse({ visitor, source = ROOT_ID, relation = "outbound" }, path = []) {
-    if (path.includes(source)) {
-      return;
-    }
-    const node = this.getNodeOrThrow(source);
-    const shouldContinue = visitor(node, [
-      ...path,
-      source
-    ]);
-    if (shouldContinue === false) {
-      return;
-    }
-    Object.values(this.getConnections(source, relation)).forEach((child) => this.traverse({
-      source: child.id,
-      relation,
-      visitor
-    }, [
-      ...path,
-      source
-    ]));
-  }
-  getPath({ source = "root", target }) {
-    return Function.pipe(this.getNode(source), Option.flatMap((node) => {
-      let found = Option.none();
-      this.traverse({
-        source: node.id,
-        visitor: (node2, path) => {
-          if (Option.isSome(found)) {
-            return false;
-          }
-          if (node2.id === target) {
-            found = Option.some(path);
-          }
-        }
-      });
-      return found;
-    }));
+}
+var removeEdgesImpl = (graph, edges, removeOrphans = false) => {
+  Atom2.batch(() => {
+    edges.map((edge) => removeEdgeImpl(graph, edge, removeOrphans));
+  });
+  return graph;
+};
+function removeEdges(graphOrEdges, edgesOrRemoveOrphans, removeOrphans) {
+  if (Array.isArray(graphOrEdges)) {
+    const edges = graphOrEdges;
+    const removeOrphansArg = typeof edgesOrRemoveOrphans === "boolean" ? edgesOrRemoveOrphans : false;
+    return (graph) => removeEdgesImpl(graph, edges, removeOrphansArg);
+  } else {
+    const graph = graphOrEdges;
+    const edges = edgesOrRemoveOrphans;
+    const removeOrphansArg = removeOrphans ?? false;
+    return removeEdgesImpl(graph, edges, removeOrphansArg);
   }
-  async waitForPath(params, { timeout = 5e3, interval = 500 } = {}) {
-    const path = this.getPath(params);
-    if (Option.isSome(path)) {
-      return path.value;
-    }
-    const trigger = new Trigger();
-    const i = setInterval(() => {
-      const path2 = this.getPath(params);
-      if (Option.isSome(path2)) {
-        trigger.wake(path2.value);
-      }
-    }, interval);
-    return trigger.wait({
-      timeout
-    }).finally(() => clearInterval(i));
+}
+var removeEdgeImpl = (graph, edgeArg, removeOrphans = false) => {
+  const internal = getInternal(graph);
+  const sourceAtom = internal._edges(edgeArg.source);
+  const source = internal._registry.get(sourceAtom);
+  if (source.outbound.includes(edgeArg.target)) {
+    internal._registry.set(sourceAtom, {
+      inbound: source.inbound,
+      outbound: source.outbound.filter((id) => id !== edgeArg.target)
+    });
   }
-  /** @internal */
-  _constructNode(node) {
-    return Option.some({
-      [graphSymbol]: this,
-      data: null,
-      properties: {},
-      ...node
+  const targetAtom = internal._edges(edgeArg.target);
+  const target = internal._registry.get(targetAtom);
+  if (target.inbound.includes(edgeArg.source)) {
+    internal._registry.set(targetAtom, {
+      inbound: target.inbound.filter((id) => id !== edgeArg.source),
+      outbound: target.outbound
     });
   }
-  constructor({ registry, nodes, edges, onInitialize, onExpand, onRemoveNode } = {}) {
-    _define_property(this, "onNodeChanged", new Event());
-    _define_property(this, "_onExpand", void 0);
-    _define_property(this, "_onInitialize", void 0);
-    _define_property(this, "_onRemoveNode", void 0);
-    _define_property(this, "_registry", void 0);
-    _define_property(this, "_expanded", Record.empty());
-    _define_property(this, "_initialized", Record.empty());
-    _define_property(this, "_initialEdges", Record.empty());
-    _define_property(this, "_initialNodes", Record.fromEntries([
-      [
-        ROOT_ID,
-        this._constructNode({
-          id: ROOT_ID,
-          type: ROOT_TYPE,
-          data: null,
-          properties: {}
-        })
-      ]
-    ]));
-    _define_property(this, "_node", Rx.family((id) => {
-      const initial = Option.flatten(Record.get(this._initialNodes, id));
-      return Rx.make(initial).pipe(Rx.keepAlive, Rx.withLabel(`graph:node:${id}`));
-    }));
-    _define_property(this, "_nodeOrThrow", Rx.family((id) => {
-      return Rx.make((get2) => {
-        const node = get2(this._node(id));
-        invariant(Option.isSome(node), `Node not available: ${id}`, {
-          F: __dxlog_file,
-          L: 254,
-          S: this,
-          A: [
-            "Option.isSome(node)",
-            "`Node not available: ${id}`"
-          ]
-        });
-        return node.value;
-      });
-    }));
-    _define_property(this, "_edges", Rx.family((id) => {
-      const initial = Record.get(this._initialEdges, id).pipe(Option.getOrElse(() => ({
-        inbound: [],
-        outbound: []
-      })));
-      return Rx.make(initial).pipe(Rx.keepAlive, Rx.withLabel(`graph:edges:${id}`));
-    }));
-    _define_property(this, "_connections", Rx.family((key) => {
-      return Rx.make((get2) => {
-        const [id, relation] = key.split("$");
-        const edges2 = get2(this._edges(id));
-        return edges2[relation].map((id2) => get2(this._node(id2))).filter(Option.isSome).map((o) => o.value);
-      }).pipe(Rx.withLabel(`graph:connections:${key}`));
-    }));
-    _define_property(this, "_actions", Rx.family((id) => {
-      return Rx.make((get2) => {
-        return get2(this._connections(`${id}$outbound`)).filter((node) => node.type === ACTION_TYPE || node.type === ACTION_GROUP_TYPE);
-      }).pipe(Rx.withLabel(`graph:actions:${id}`));
-    }));
-    _define_property(this, "_json", Rx.family((id) => {
-      return Rx.make((get2) => {
-        const toJSON = (node, seen = []) => {
-          const nodes2 = get2(this.connections(node.id));
-          const obj = {
-            id: node.id,
-            type: node.type
-          };
-          if (node.properties.label) {
-            obj.label = node.properties.label;
-          }
-          if (nodes2.length) {
-            obj.nodes = nodes2.map((n) => {
-              const nextSeen = [
-                ...seen,
-                node.id
-              ];
-              return nextSeen.includes(n.id) ? void 0 : toJSON(n, nextSeen);
-            }).filter(isNonNullable);
-          }
-          return obj;
-        };
-        const root = get2(this.nodeOrThrow(id));
-        return toJSON(root);
-      }).pipe(Rx.withLabel(`graph:json:${id}`));
-    }));
-    this._registry = registry ?? Registry.make();
-    this._onInitialize = onInitialize;
-    this._onExpand = onExpand;
-    this._onRemoveNode = onRemoveNode;
-    if (nodes) {
-      nodes.forEach((node) => {
-        Record.set(this._initialNodes, node.id, this._constructNode(node));
-      });
+  if (removeOrphans) {
+    const source2 = internal._registry.get(sourceAtom);
+    const target2 = internal._registry.get(targetAtom);
+    if (source2.outbound.length === 0 && source2.inbound.length === 0 && edgeArg.source !== RootId) {
+      removeNodesImpl(graph, [
+        edgeArg.source
+      ]);
     }
-    if (edges) {
-      Object.entries(edges).forEach(([source, edges2]) => {
-        Record.set(this._initialEdges, source, edges2);
-      });
+    if (target2.outbound.length === 0 && target2.inbound.length === 0 && edgeArg.target !== RootId) {
+      removeNodesImpl(graph, [
+        edgeArg.target
+      ]);
     }
   }
+  return graph;
+};
+function removeEdge(graphOrEdgeArg, edgeArgOrRemoveOrphans, removeOrphans) {
+  if (edgeArgOrRemoveOrphans === void 0 || typeof edgeArgOrRemoveOrphans === "boolean" || "source" in graphOrEdgeArg) {
+    const edgeArg = graphOrEdgeArg;
+    const removeOrphansArg = typeof edgeArgOrRemoveOrphans === "boolean" ? edgeArgOrRemoveOrphans : false;
+    return (graph) => removeEdgeImpl(graph, edgeArg, removeOrphansArg);
+  } else {
+    const graph = graphOrEdgeArg;
+    const edgeArg = edgeArgOrRemoveOrphans;
+    const removeOrphansArg = removeOrphans ?? false;
+    return removeEdgeImpl(graph, edgeArg, removeOrphansArg);
+  }
+}
+var make = (params) => {
+  return new GraphImpl(params);
 };
 
 // src/graph-builder.ts
-import { Registry as Registry2, Rx as Rx2 } from "@effect-rx/rx-react";
-import { effect } from "@preact/signals-core";
-import * as Array from "effect/Array";
+var graph_builder_exports = {};
+__export(graph_builder_exports, {
+  GraphBuilderTypeId: () => GraphBuilderTypeId,
+  addExtension: () => addExtension,
+  createConnector: () => createConnector,
+  createExtension: () => createExtension,
+  createExtensionRaw: () => createExtensionRaw,
+  createTypeExtension: () => createTypeExtension,
+  destroy: () => destroy,
+  explore: () => explore,
+  flattenExtensions: () => flattenExtensions,
+  from: () => from,
+  make: () => make2,
+  removeExtension: () => removeExtension
+});
+import { Atom as Atom3, Registry as Registry2 } from "@effect-atom/atom-react";
+import * as Array2 from "effect/Array";
+import * as Effect from "effect/Effect";
 import * as Function2 from "effect/Function";
-import * as Option2 from "effect/Option";
+import * as Option3 from "effect/Option";
+import * as Pipeable2 from "effect/Pipeable";
 import * as Record2 from "effect/Record";
 import { log as log2 } from "@dxos/log";
 import { byPosition, getDebugName, isNode, isNonNullable as isNonNullable2 } from "@dxos/util";
 
-// src/node.ts
-var isGraphNode = (data) => data && typeof data === "object" && "id" in data && "properties" in data && data.properties ? typeof data.properties === "object" && "data" in data : false;
-var isAction = (data) => isGraphNode(data) ? typeof data.data === "function" && data.type === ACTION_TYPE : false;
-var actionGroupSymbol = Symbol("ActionGroup");
-var isActionGroup = (data) => isGraphNode(data) ? data.data === actionGroupSymbol && data.type === ACTION_GROUP_TYPE : false;
-var isActionLike = (data) => isAction(data) || isActionGroup(data);
-
-// src/graph-builder.ts
-function _define_property2(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
+// src/node-matcher.ts
+var node_matcher_exports = {};
+__export(node_matcher_exports, {
+  whenAll: () => whenAll,
+  whenAny: () => whenAny,
+  whenEchoObject: () => whenEchoObject,
+  whenEchoObjectMatches: () => whenEchoObjectMatches,
+  whenEchoType: () => whenEchoType,
+  whenEchoTypeMatches: () => whenEchoTypeMatches,
+  whenId: () => whenId,
+  whenNodeType: () => whenNodeType,
+  whenNot: () => whenNot,
+  whenRoot: () => whenRoot
+});
+import * as Option2 from "effect/Option";
+import { Obj } from "@dxos/echo";
+var whenRoot = (node) => node.id === RootId ? Option2.some(node) : Option2.none();
+var whenId = (id) => (node) => node.id === id ? Option2.some(node) : Option2.none();
+var whenNodeType = (type) => (node) => node.type === type ? Option2.some(node) : Option2.none();
+var whenEchoType = (type) => (node) => Obj.instanceOf(type, node.data) ? Option2.some(node.data) : Option2.none();
+var whenEchoObject = (node) => Obj.isObject(node.data) ? Option2.some(node.data) : Option2.none();
+var whenAll = (...matchers) => (node) => {
+  for (const matcher of matchers) {
+    const result = matcher(node);
+    if (Option2.isNone(result)) {
+      return Option2.none();
+    }
   }
-  return obj;
-}
-var __dxlog_file2 = "/__w/dxos/dxos/packages/sdk/app-graph/src/graph-builder.ts";
-var createExtension = (extension) => {
-  const { id, position = "static", relation = "outbound", resolver: _resolver, connector: _connector, actions: _actions, actionGroups: _actionGroups } = extension;
-  const getId = (key) => `${id}/${key}`;
-  const resolver = _resolver && Rx2.family((id2) => _resolver(id2).pipe(Rx2.withLabel(`graph-builder:_resolver:${id2}`)));
-  const connector = _connector && Rx2.family((node) => _connector(node).pipe(Rx2.withLabel(`graph-builder:_connector:${id}`)));
-  const actionGroups = _actionGroups && Rx2.family((node) => _actionGroups(node).pipe(Rx2.withLabel(`graph-builder:_actionGroups:${id}`)));
-  const actions = _actions && Rx2.family((node) => _actions(node).pipe(Rx2.withLabel(`graph-builder:_actions:${id}`)));
-  return [
-    resolver ? {
-      id: getId("resolver"),
-      position,
-      resolver
-    } : void 0,
-    connector ? {
-      id: getId("connector"),
-      position,
-      relation,
-      connector: Rx2.family((node) => Rx2.make((get2) => {
-        try {
-          return get2(connector(node));
-        } catch {
-          log2.warn("Error in connector", {
-            id: getId("connector"),
-            node
-          }, {
-            F: __dxlog_file2,
-            L: 112,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          return [];
-        }
-      }).pipe(Rx2.withLabel(`graph-builder:connector:${id}`)))
-    } : void 0,
-    actionGroups ? {
-      id: getId("actionGroups"),
-      position,
-      relation: "outbound",
-      connector: Rx2.family((node) => Rx2.make((get2) => {
-        try {
-          return get2(actionGroups(node)).map((arg) => ({
-            ...arg,
-            data: actionGroupSymbol,
-            type: ACTION_GROUP_TYPE
-          }));
-        } catch {
-          log2.warn("Error in actionGroups", {
-            id: getId("actionGroups"),
-            node
-          }, {
-            F: __dxlog_file2,
-            L: 133,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          return [];
-        }
-      }).pipe(Rx2.withLabel(`graph-builder:connector:actionGroups:${id}`)))
-    } : void 0,
-    actions ? {
-      id: getId("actions"),
-      position,
-      relation: "outbound",
-      connector: Rx2.family((node) => Rx2.make((get2) => {
-        try {
-          return get2(actions(node)).map((arg) => ({
-            ...arg,
-            type: ACTION_TYPE
-          }));
-        } catch {
-          log2.warn("Error in actions", {
-            id: getId("actions"),
-            node
-          }, {
-            F: __dxlog_file2,
-            L: 150,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          return [];
-        }
-      }).pipe(Rx2.withLabel(`graph-builder:connector:actions:${id}`)))
-    } : void 0
-  ].filter(isNonNullable2);
+  return Option2.some(node);
 };
-var flattenExtensions = (extension, acc = []) => {
-  if (Array.isArray(extension)) {
-    return [
-      ...acc,
-      ...extension.flatMap((ext) => flattenExtensions(ext, acc))
-    ];
-  } else {
-    return [
-      ...acc,
-      extension
-    ];
+var whenAny = (...matchers) => (node) => {
+  for (const matcher of matchers) {
+    const result = matcher(node);
+    if (Option2.isSome(result)) {
+      return Option2.some(node);
+    }
   }
+  return Option2.none();
 };
-var GraphBuilder = class _GraphBuilder {
-  static from(pickle, registry) {
-    if (!pickle) {
-      return new _GraphBuilder({
-        registry
-      });
-    }
-    const { nodes, edges } = JSON.parse(pickle);
-    return new _GraphBuilder({
-      nodes,
-      edges,
-      registry
+var whenEchoTypeMatches = (type) => (node) => Obj.instanceOf(type, node.data) ? Option2.some(node) : Option2.none();
+var whenEchoObjectMatches = (node) => Obj.isObject(node.data) ? Option2.some(node) : Option2.none();
+var whenNot = (matcher) => (node) => Option2.isNone(matcher(node)) ? Option2.some(node) : Option2.none();
+
+// src/graph-builder.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/sdk/app-graph/src/graph-builder.ts";
+var GraphBuilderTypeId = Symbol.for("@dxos/app-graph/GraphBuilder");
+var GraphBuilderImpl = class {
+  [GraphBuilderTypeId] = GraphBuilderTypeId;
+  pipe() {
+    return Pipeable2.pipeArguments(this, arguments);
+  }
+  // TODO(wittjosiah): Use Context.
+  _subscriptions = /* @__PURE__ */ new Map();
+  _extensions = Atom3.make(Record2.empty()).pipe(Atom3.keepAlive, Atom3.withLabel("graph-builder:extensions"));
+  _initialized = {};
+  _registry;
+  _graph;
+  constructor({ registry, ...params } = {}) {
+    this._registry = registry ?? Registry2.make();
+    const graph = make({
+      ...params,
+      registry: this._registry,
+      onExpand: (id, relation) => this._onExpand(id, relation),
+      onInitialize: (id) => this._onInitialize(id),
+      onRemoveNode: (id) => this._onRemoveNode(id)
     });
+    this._graph = graph;
   }
   get graph() {
     return this._graph;
@@ -640,56 +916,27 @@ var GraphBuilder = class _GraphBuilder {
   get extensions() {
     return this._extensions;
   }
-  addExtension(extensions) {
-    flattenExtensions(extensions).forEach((extension) => {
-      const extensions2 = this._registry.get(this._extensions);
-      this._registry.set(this._extensions, Record2.set(extensions2, extension.id, extension));
+  _resolvers = Atom3.family((id) => {
+    return Atom3.make((get2) => {
+      return Function2.pipe(get2(this._extensions), Record2.values, Array2.sortBy(byPosition), Array2.map(({ resolver }) => resolver), Array2.filter(isNonNullable2), Array2.map((resolver) => get2(resolver(id))), Array2.filter(isNonNullable2), Array2.head);
     });
-    return this;
-  }
-  removeExtension(id) {
-    const extensions = this._registry.get(this._extensions);
-    this._registry.set(this._extensions, Record2.remove(extensions, id));
-    return this;
-  }
-  async explore({ registry = Registry2.make(), source = ROOT_ID, relation = "outbound", visitor }, path = []) {
-    if (path.includes(source)) {
-      return;
-    }
-    if (!isNode()) {
-      const { yieldOrContinue } = await import("main-thread-scheduling");
-      await yieldOrContinue("idle");
-    }
-    const node = registry.get(this._graph.nodeOrThrow(source));
-    const shouldContinue = await visitor(node, [
-      ...path,
-      node.id
-    ]);
-    if (shouldContinue === false) {
-      return;
-    }
-    const nodes = Object.values(this._registry.get(this._extensions)).filter((extension) => relation === (extension.relation ?? "outbound")).map((extension) => extension.connector).filter(isNonNullable2).flatMap((connector) => registry.get(connector(this._graph.node(source))));
-    await Promise.all(nodes.map((nodeArg) => {
-      registry.set(this._graph._node(nodeArg.id), this._graph._constructNode(nodeArg));
-      return this.explore({
-        registry,
-        source: nodeArg.id,
-        relation,
-        visitor
-      }, [
-        ...path,
-        node.id
-      ]);
-    }));
-    if (registry !== this._registry) {
-      registry.reset();
-      registry.dispose();
-    }
-  }
-  destroy() {
-    this._subscriptions.forEach((unsubscribe) => unsubscribe());
-    this._subscriptions.clear();
-  }
+  });
+  _connectors = Atom3.family((key) => {
+    return Atom3.make((get2) => {
+      const [id, relation] = key.split("+");
+      const node = this._graph.node(id);
+      return Function2.pipe(
+        get2(this._extensions),
+        Record2.values,
+        // TODO(wittjosiah): Sort on write rather than read.
+        Array2.sortBy(byPosition),
+        Array2.filter(({ relation: _relation = "outbound" }) => _relation === relation),
+        Array2.map(({ connector }) => connector?.(node)),
+        Array2.filter(isNonNullable2),
+        Array2.flatMap((result) => get2(result))
+      );
+    }).pipe(Atom3.withLabel(`graph-builder:connectors:${key}`));
+  });
   _onExpand(id, relation) {
     log2("onExpand", {
       id,
@@ -697,7 +944,7 @@ var GraphBuilder = class _GraphBuilder {
       registry: getDebugName(this._registry)
     }, {
       F: __dxlog_file2,
-      L: 327,
+      L: 176,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -714,25 +961,25 @@ var GraphBuilder = class _GraphBuilder {
         removed
       }, {
         F: __dxlog_file2,
-        L: 338,
+        L: 187,
         S: this,
         C: (f, a) => f(...a)
       });
       const update = () => {
-        Rx2.batch(() => {
-          this._graph.removeEdges(removed.map((target) => ({
+        Atom3.batch(() => {
+          removeEdges(this._graph, removed.map((target) => ({
             source: id,
             target
           })), true);
-          this._graph.addNodes(nodes);
-          this._graph.addEdges(nodes.map((node) => relation === "outbound" ? {
+          addNodes(this._graph, nodes);
+          addEdges(this._graph, nodes.map((node) => relation === "outbound" ? {
             source: id,
             target: node.id
           } : {
             source: node.id,
             target: id
           }));
-          this._graph.sortEdges(id, relation, nodes.map(({ id: id2 }) => id2));
+          sortEdges(this._graph, id, relation, nodes.map(({ id: id2 }) => id2));
         });
       };
       if (typeof requestAnimationFrame === "function") {
@@ -751,23 +998,23 @@ var GraphBuilder = class _GraphBuilder {
       id
     }, {
       F: __dxlog_file2,
-      L: 375,
+      L: 227,
       S: this,
       C: (f, a) => f(...a)
     });
     const resolver = this._resolvers(id);
     const cancel = this._registry.subscribe(resolver, (node) => {
       const trigger = this._initialized[id];
-      Option2.match(node, {
+      Option3.match(node, {
         onSome: (node2) => {
-          this._graph.addNodes([
+          addNodes(this._graph, [
             node2
           ]);
           trigger?.wake();
         },
         onNone: () => {
           trigger?.wake();
-          this._graph.removeNodes([
+          removeNodes(this._graph, [
             id
           ]);
         }
@@ -781,78 +1028,270 @@ var GraphBuilder = class _GraphBuilder {
     this._subscriptions.get(id)?.();
     this._subscriptions.delete(id);
   }
-  constructor({ registry, ...params } = {}) {
-    _define_property2(this, "_subscriptions", /* @__PURE__ */ new Map());
-    _define_property2(this, "_extensions", Rx2.make(Record2.empty()).pipe(Rx2.keepAlive, Rx2.withLabel("graph-builder:extensions")));
-    _define_property2(this, "_initialized", {});
-    _define_property2(this, "_registry", void 0);
-    _define_property2(this, "_graph", void 0);
-    _define_property2(this, "_resolvers", Rx2.family((id) => {
-      return Rx2.make((get2) => {
-        return Function2.pipe(get2(this._extensions), Record2.values, Array.sortBy(byPosition), Array.map(({ resolver }) => resolver), Array.filter(isNonNullable2), Array.map((resolver) => get2(resolver(id))), Array.filter(isNonNullable2), Array.head);
-      });
-    }));
-    _define_property2(this, "_connectors", Rx2.family((key) => {
-      return Rx2.make((get2) => {
-        const [id, relation] = key.split("+");
-        const node = this._graph.node(id);
-        return Function2.pipe(
-          get2(this._extensions),
-          Record2.values,
-          // TODO(wittjosiah): Sort on write rather than read.
-          Array.sortBy(byPosition),
-          Array.filter(({ relation: _relation = "outbound" }) => _relation === relation),
-          Array.map(({ connector }) => connector?.(node)),
-          Array.filter(isNonNullable2),
-          Array.flatMap((result) => get2(result))
-        );
-      }).pipe(Rx2.withLabel(`graph-builder:connectors:${key}`));
-    }));
-    this._registry = registry ?? Registry2.make();
-    this._graph = new Graph({
-      ...params,
-      registry: this._registry,
-      onExpand: (id, relation) => this._onExpand(id, relation),
-      onInitialize: (id) => this._onInitialize(id),
-      onRemoveNode: (id) => this._onRemoveNode(id)
+};
+var make2 = (params) => {
+  return new GraphBuilderImpl(params);
+};
+var from = (pickle, registry) => {
+  if (!pickle) {
+    return make2({
+      registry
     });
   }
+  const { nodes, edges } = JSON.parse(pickle);
+  return make2({
+    nodes,
+    edges,
+    registry
+  });
 };
-var rxFromSignal = (cb) => {
-  return Rx2.make((get2) => {
-    const dispose = effect(() => {
-      get2.setSelf(cb());
-    });
-    get2.addFinalizer(() => dispose());
-    return cb();
+var addExtensionImpl = (builder, extensions) => {
+  const internal = builder;
+  flattenExtensions(extensions).forEach((extension) => {
+    const extensions2 = internal._registry.get(internal._extensions);
+    internal._registry.set(internal._extensions, Record2.set(extensions2, extension.id, extension));
   });
+  return builder;
 };
-var observableFamily = Rx2.family((observable) => {
-  return Rx2.make((get2) => {
-    const subscription = observable.subscribe((value) => get2.setSelf(value));
-    get2.addFinalizer(() => subscription.unsubscribe());
-    return observable.get();
+function addExtension(builderOrExtensions, extensions) {
+  if (extensions === void 0) {
+    const extensions2 = builderOrExtensions;
+    return (builder) => addExtensionImpl(builder, extensions2);
+  } else {
+    const builder = builderOrExtensions;
+    return addExtensionImpl(builder, extensions);
+  }
+}
+var removeExtensionImpl = (builder, id) => {
+  const internal = builder;
+  const extensions = internal._registry.get(internal._extensions);
+  internal._registry.set(internal._extensions, Record2.remove(extensions, id));
+  return builder;
+};
+function removeExtension(builderOrId, id) {
+  if (typeof builderOrId === "string") {
+    const id2 = builderOrId;
+    return (builder) => removeExtensionImpl(builder, id2);
+  } else {
+    const builder = builderOrId;
+    return removeExtensionImpl(builder, id);
+  }
+}
+var exploreImpl = async (builder, options, path = []) => {
+  const internal = builder;
+  const { registry = Registry2.make(), source = RootId, relation = "outbound", visitor } = options;
+  if (path.includes(source)) {
+    return;
+  }
+  if (!isNode()) {
+    const { yieldOrContinue } = await import("main-thread-scheduling");
+    await yieldOrContinue("idle");
+  }
+  const node = registry.get(internal._graph.nodeOrThrow(source));
+  const shouldContinue = await visitor(node, [
+    ...path,
+    node.id
+  ]);
+  if (shouldContinue === false) {
+    return;
+  }
+  const nodes = Object.values(internal._registry.get(internal._extensions)).filter((extension) => relation === (extension.relation ?? "outbound")).map((extension) => extension.connector).filter(isNonNullable2).flatMap((connector) => registry.get(connector(internal._graph.node(source))));
+  await Promise.all(nodes.map((nodeArg) => {
+    registry.set(internal._graph._node(nodeArg.id), internal._graph._constructNode(nodeArg));
+    return exploreImpl(builder, {
+      registry,
+      source: nodeArg.id,
+      relation,
+      visitor
+    }, [
+      ...path,
+      node.id
+    ]);
+  }));
+  if (registry !== internal._registry) {
+    registry.reset();
+    registry.dispose();
+  }
+};
+function explore(builderOrOptions, optionsOrPath, path) {
+  if (typeof builderOrOptions === "object" && "visitor" in builderOrOptions) {
+    const options = builderOrOptions;
+    const path2 = Array2.isArray(optionsOrPath) ? optionsOrPath : void 0;
+    return (builder) => exploreImpl(builder, options, path2);
+  } else {
+    const builder = builderOrOptions;
+    const options = optionsOrPath;
+    const pathArg = path ?? (Array2.isArray(optionsOrPath) ? optionsOrPath : void 0);
+    return exploreImpl(builder, options, pathArg);
+  }
+}
+var destroyImpl = (builder) => {
+  const internal = builder;
+  internal._subscriptions.forEach((unsubscribe) => unsubscribe());
+  internal._subscriptions.clear();
+};
+function destroy(builder) {
+  if (builder === void 0) {
+    return (builder2) => destroyImpl(builder2);
+  } else {
+    return destroyImpl(builder);
+  }
+}
+var createExtensionRaw = (extension) => {
+  const { id, position = "static", relation = "outbound", resolver: _resolver, connector: _connector, actions: _actions, actionGroups: _actionGroups } = extension;
+  const getId = (key) => `${id}/${key}`;
+  const resolver = _resolver && Atom3.family((id2) => _resolver(id2).pipe(Atom3.withLabel(`graph-builder:_resolver:${id2}`)));
+  const connector = _connector && Atom3.family((node) => _connector(node).pipe(Atom3.withLabel(`graph-builder:_connector:${id}`)));
+  const actionGroups = _actionGroups && Atom3.family((node) => _actionGroups(node).pipe(Atom3.withLabel(`graph-builder:_actionGroups:${id}`)));
+  const actions = _actions && Atom3.family((node) => _actions(node).pipe(Atom3.withLabel(`graph-builder:_actions:${id}`)));
+  return [
+    resolver ? {
+      id: getId("resolver"),
+      position,
+      resolver
+    } : void 0,
+    connector ? {
+      id: getId("connector"),
+      position,
+      relation,
+      connector: Atom3.family((node) => Atom3.make((get2) => {
+        try {
+          return get2(connector(node));
+        } catch (error) {
+          log2.warn("Error in connector", {
+            id: getId("connector"),
+            node,
+            error
+          }, {
+            F: __dxlog_file2,
+            L: 509,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          return [];
+        }
+      }).pipe(Atom3.withLabel(`graph-builder:connector:${id}`)))
+    } : void 0,
+    actionGroups ? {
+      id: getId("actionGroups"),
+      position,
+      relation: "outbound",
+      connector: Atom3.family((node) => Atom3.make((get2) => {
+        try {
+          return get2(actionGroups(node)).map((arg) => ({
+            ...arg,
+            data: actionGroupSymbol,
+            type: ActionGroupType
+          }));
+        } catch (error) {
+          log2.warn("Error in actionGroups", {
+            id: getId("actionGroups"),
+            node,
+            error
+          }, {
+            F: __dxlog_file2,
+            L: 530,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          return [];
+        }
+      }).pipe(Atom3.withLabel(`graph-builder:connector:actionGroups:${id}`)))
+    } : void 0,
+    actions ? {
+      id: getId("actions"),
+      position,
+      relation: "outbound",
+      connector: Atom3.family((node) => Atom3.make((get2) => {
+        try {
+          return get2(actions(node)).map((arg) => ({
+            ...arg,
+            type: ActionType
+          }));
+        } catch (error) {
+          log2.warn("Error in actions", {
+            id: getId("actions"),
+            node,
+            error
+          }, {
+            F: __dxlog_file2,
+            L: 547,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          return [];
+        }
+      }).pipe(Atom3.withLabel(`graph-builder:connector:actions:${id}`)))
+    } : void 0
+  ].filter(isNonNullable2);
+};
+var runEffectSyncWithFallback = (effect, context2, extensionId, fallback) => {
+  return Effect.runSync(effect.pipe(Effect.provide(context2), Effect.catchAll((error) => {
+    log2.warn("Extension failed", {
+      extension: extensionId,
+      error
+    }, {
+      F: __dxlog_file2,
+      L: 590,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return Effect.succeed(fallback);
+  })));
+};
+var createExtension = (options) => Effect.map(Effect.context(), (context2) => {
+  const { id, match: match3, actions, connector, resolver, relation, position } = options;
+  const connectorExtension = connector ? createConnectorWithRuntime(id, match3, connector, context2) : void 0;
+  const actionsExtension = actions ? (node) => Atom3.make((get2) => Function2.pipe(get2(node), Option3.flatMap(match3), Option3.map((matched) => runEffectSyncWithFallback(actions(matched, get2), context2, id, []).map((action) => ({
+    ...action,
+    // Attach captured context for action execution.
+    _actionContext: context2
+  }))), Option3.getOrElse(() => []))) : void 0;
+  const resolverExtension = resolver ? (nodeId) => Atom3.make((get2) => runEffectSyncWithFallback(resolver(nodeId, get2), context2, id, null) ?? null) : void 0;
+  return createExtensionRaw({
+    id,
+    relation,
+    position,
+    connector: connectorExtension,
+    actions: actionsExtension,
+    resolver: resolverExtension
   });
 });
-var rxFromObservable = (observable) => {
-  return observableFamily(observable);
+var createConnector = (matcher, factory) => {
+  return (node) => Atom3.make((get2) => Function2.pipe(get2(node), Option3.flatMap(matcher), Option3.map((data) => factory(data, get2)), Option3.getOrElse(() => [])));
+};
+var createConnectorWithRuntime = (extensionId, matcher, factory, context2) => {
+  return (node) => Atom3.make((get2) => Function2.pipe(get2(node), Option3.flatMap(matcher), Option3.map((data) => runEffectSyncWithFallback(factory(data, get2), context2, extensionId, [])), Option3.getOrElse(() => [])));
+};
+var createTypeExtension = (options) => {
+  const { id, type, actions, connector, relation, position } = options;
+  return createExtension({
+    id,
+    match: whenEchoType(type),
+    actions,
+    connector,
+    relation,
+    position
+  });
+};
+var flattenExtensions = (extension, acc = []) => {
+  if (Array2.isArray(extension)) {
+    return [
+      ...acc,
+      ...extension.flatMap((ext) => flattenExtensions(ext, acc))
+    ];
+  } else {
+    return [
+      ...acc,
+      extension
+    ];
+  }
 };
 export {
-  ACTION_GROUP_TYPE,
-  ACTION_TYPE,
-  Graph,
-  GraphBuilder,
-  ROOT_ID,
-  ROOT_TYPE,
-  actionGroupSymbol,
-  createExtension,
-  flattenExtensions,
-  getGraph,
-  isAction,
-  isActionGroup,
-  isActionLike,
-  isGraphNode,
-  rxFromObservable,
-  rxFromSignal
+  atoms_exports as CreateAtom,
+  graph_exports as Graph,
+  graph_builder_exports as GraphBuilder,
+  node_exports as Node,
+  node_matcher_exports as NodeMatcher
 };
 //# sourceMappingURL=index.mjs.map