@dxos/app-graph 0.8.2-staging.7ac8446 → 0.8.2

package/dist/lib/node-esm/index.mjs

@@ -1,28 +1,20 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 
 // packages/sdk/app-graph/src/graph.ts
-import { batch, effect, untracked } from "@preact/signals-core";
-import { asyncTimeout, Trigger } from "@dxos/async";
+import { Registry, Rx } from "@effect-rx/rx-react";
+import { Option, pipe, Record } from "effect";
+import { Event, Trigger } from "@dxos/async";
+import { todo } from "@dxos/debug";
 import { invariant } from "@dxos/invariant";
-import { create } from "@dxos/live-object";
 import { log } from "@dxos/log";
-import { isNonNullable, pick } from "@dxos/util";
-
-// packages/sdk/app-graph/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" : false;
-var actionGroupSymbol = Symbol("ActionGroup");
-var isActionGroup = (data) => isGraphNode(data) ? data.data === actionGroupSymbol : false;
-var isActionLike = (data) => isAction(data) || isActionGroup(data);
-
-// packages/sdk/app-graph/src/graph.ts
+import { isNonNullable } from "@dxos/util";
 var __dxlog_file = "/home/runner/work/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: 21,
+    L: 25,
     S: void 0,
     A: [
       "graph",
@@ -35,649 +27,543 @@ 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 DEFAULT_FILTER = (node) => untracked(() => !isActionLike(node));
-var Graph = class _Graph {
-  constructor({ nodes, edges, onInitialNode, onInitialNodes, onRemoveNode } = {}) {
-    this._waitingForNodes = {};
-    this._initialized = {};
-    /**
-    * @internal
-    */
-    this._nodes = {};
-    /**
-    * @internal
-    */
-    this._edges = {};
-    this._constructNode = (node) => {
-      return create({
-        ...node,
-        [graphSymbol]: this
+var Graph = class {
+  constructor({ registry, nodes, edges, onExpand, onRemoveNode } = {}) {
+    this.onNodeChanged = new Event();
+    this._expanded = Record.empty();
+    this._initialized = Record.empty();
+    this._initialEdges = Record.empty();
+    this._initialNodes = Record.fromEntries([
+      [
+        ROOT_ID,
+        this._constructNode({
+          id: ROOT_ID,
+          type: ROOT_TYPE,
+          data: null,
+          properties: {}
+        })
+      ]
+    ]);
+    /** @internal */
+    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}`));
+    });
+    this._nodeOrThrow = Rx.family((id) => {
+      return Rx.make((get) => {
+        const node = get(this._node(id));
+        invariant(Option.isSome(node), `Node not available: ${id}`, {
+          F: __dxlog_file,
+          L: 253,
+          S: this,
+          A: [
+            "Option.isSome(node)",
+            "`Node not available: ${id}`"
+          ]
+        });
+        return node.value;
       });
-    };
-    this._onInitialNode = onInitialNode;
-    this._onInitialNodes = onInitialNodes;
-    this._onRemoveNode = onRemoveNode;
-    this._nodes[ROOT_ID] = this._constructNode({
-      id: ROOT_ID,
-      type: ROOT_TYPE,
-      cacheable: [],
-      properties: {},
-      data: null
     });
+    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}`));
+    });
+    // NOTE: Currently the argument to the family needs to be referentially stable for the rx to be referentially stable.
+    // TODO(wittjosiah): Rx feature request, support for something akin to `ComplexMap` to allow for complex arguments.
+    this._connections = Rx.family((key) => {
+      return Rx.make((get) => {
+        const [id, relation] = key.split("$");
+        const edges = get(this._edges(id));
+        return edges[relation].map((id2) => get(this._node(id2))).filter(Option.isSome).map((o) => o.value);
+      }).pipe(Rx.withLabel(`graph:connections:${key}`));
+    });
+    this._actions = Rx.family((id) => {
+      return Rx.make((get) => {
+        return get(this._connections(`${id}$outbound`)).filter((node) => node.type === ACTION_TYPE || node.type === ACTION_GROUP_TYPE);
+      }).pipe(Rx.withLabel(`graph:actions:${id}`));
+    });
+    this._json = Rx.family((id) => {
+      return Rx.make((get) => {
+        const toJSON = (node, seen = []) => {
+          const nodes = get(this.connections(node.id));
+          const obj = {
+            id: node.id.length > 32 ? `${node.id.slice(0, 32)}...` : 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 : toJSON(n, nextSeen);
+            }).filter(isNonNullable);
+          }
+          return obj;
+        };
+        const root = get(this.nodeOrThrow(id));
+        return toJSON(root);
+      }).pipe(Rx.withLabel(`graph:json:${id}`));
+    });
+    this._registry = registry ?? Registry.make();
+    this._onExpand = onExpand;
+    this._onRemoveNode = onRemoveNode;
     if (nodes) {
       nodes.forEach((node) => {
-        const cacheable = Object.keys(node.properties ?? {});
-        if (node.type === ACTION_TYPE) {
-          this._addNode({
-            cacheable,
-            data: () => log.warn("Pickled action invocation", void 0, {
-              F: __dxlog_file,
-              L: 113,
-              S: this,
-              C: (f, a) => f(...a)
-            }),
-            ...node
-          });
-        } else if (node.type === ACTION_GROUP_TYPE) {
-          this._addNode({
-            cacheable,
-            data: actionGroupSymbol,
-            ...node
-          });
-        } else {
-          this._addNode({
-            cacheable,
-            ...node
-          });
-        }
+        Record.set(this._initialNodes, node.id, this._constructNode(node));
       });
     }
-    this._edges[ROOT_ID] = create({
-      inbound: [],
-      outbound: []
-    });
     if (edges) {
       Object.entries(edges).forEach(([source, edges2]) => {
-        edges2.forEach((target) => {
-          this._addEdge({
-            source,
-            target
-          });
-        });
-        this._sortEdges(source, "outbound", edges2);
+        Record.set(this._initialEdges, source, edges2);
       });
     }
   }
-  static from(pickle, options = {}) {
-    const { nodes, edges } = JSON.parse(pickle);
-    return new _Graph({
-      nodes,
-      edges,
-      ...options
-    });
+  toJSON(id = ROOT_ID) {
+    return this._registry.get(this._json(id));
+  }
+  json(id = ROOT_ID) {
+    return this._json(id);
+  }
+  node(id) {
+    return this._node(id);
+  }
+  nodeOrThrow(id) {
+    return this._nodeOrThrow(id);
+  }
+  connections(id, relation = "outbound") {
+    return this._connections(`${id}$${relation}`);
+  }
+  actions(id) {
+    return this._actions(id);
+  }
+  edges(id) {
+    return this._edges(id);
   }
-  /**
-  * Alias for `findNode('root')`.
-  */
   get root() {
-    return this.findNode(ROOT_ID);
-  }
-  /**
-  * Convert the graph to a JSON object.
-  */
-  toJSON({ id = ROOT_ID, maxLength = 32 } = {}) {
-    const toJSON = (node, seen = []) => {
-      const nodes = this.nodes(node);
-      const obj = {
-        id: node.id.length > maxLength ? `${node.id.slice(0, maxLength - 3)}...` : 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 : toJSON(n, nextSeen);
-        }).filter(isNonNullable);
-      }
-      return obj;
-    };
-    const root = this.findNode(id);
-    invariant(root, `Node not found: ${id}`, {
+    return this.getNodeOrThrow(ROOT_ID);
+  }
+  getNode(id) {
+    return this._registry.get(this.node(id));
+  }
+  getNodeOrThrow(id) {
+    return this._registry.get(this.nodeOrThrow(id));
+  }
+  getConnections(id, relation = "outbound") {
+    return this._registry.get(this.connections(id, relation));
+  }
+  getActions(id) {
+    return this._registry.get(this.actions(id));
+  }
+  getEdges(id) {
+    return this._registry.get(this.edges(id));
+  }
+  // TODO(wittjosiah): On initialize to restore state from cache.
+  // async initialize(id: string) {
+  //   const initialized = Record.get(this._initialized, id).pipe(Option.getOrElse(() => false));
+  //   log('initialize', { id, initialized });
+  //   if (!initialized) {
+  //     await this._onInitialize?.(id);
+  //     Record.set(this._initialized, id, true);
+  //   }
+  // }
+  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: 171,
+      L: 395,
       S: this,
-      A: [
-        "root",
-        "`Node not found: ${id}`"
-      ]
+      C: (f, a) => f(...a)
     });
-    return toJSON(root);
-  }
-  pickle() {
-    const nodes = Object.values(this._nodes).filter((node) => !!node.cacheable).map((node) => {
-      return {
-        id: node.id,
-        type: node.type,
-        properties: pick(node.properties, node.cacheable)
-      };
+    if (!expanded) {
+      this._onExpand?.(id, relation);
+      Record.set(this._expanded, key, true);
+    }
+  }
+  addNodes(nodes) {
+    Rx.batch(() => {
+      nodes.map((node) => this.addNode(node));
     });
-    const cacheable = new Set(nodes.map((node) => node.id));
-    const edges = Object.fromEntries(Object.entries(this._edges).filter(([id]) => cacheable.has(id)).map(([id, { outbound }]) => [
-      id,
-      outbound.filter((nodeId) => cacheable.has(nodeId))
-    ]).toSorted(([a], [b]) => a.localeCompare(b)));
-    return JSON.stringify({
-      nodes,
-      edges
+  }
+  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: 417,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        if (typeChanged || dataChanged || propertiesChanged) {
+          log("updating node", {
+            id,
+            type,
+            data,
+            properties
+          }, {
+            F: __dxlog_file,
+            L: 419,
+            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", {
+          id,
+          type,
+          data,
+          properties
+        }, {
+          F: __dxlog_file,
+          L: 426,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        const newNode = this._constructNode({
+          id,
+          type,
+          data,
+          properties
+        });
+        this._registry.set(nodeRx, newNode);
+        this.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();
+    }
   }
-  /**
-  * Find the node with the given id in the graph.
-  *
-  * If a node is not found within the graph and an `onInitialNode` callback is provided,
-  * it is called with the id and type of the node, potentially initializing the node.
-  */
-  findNode(id, expansion = true) {
-    const existingNode = this._nodes[id];
-    if (!existingNode && expansion) {
-      void this._onInitialNode?.(id);
+  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);
     }
-    return existingNode;
-  }
-  /**
-  * Wait for a node to be added to the graph.
-  *
-  * If the node is already present in the graph, the promise resolves immediately.
-  *
-  * @param id The id of the node to wait for.
-  * @param timeout The time in milliseconds to wait for the node to be added.
-  */
-  async waitForNode(id, timeout) {
-    const trigger = this._waitingForNodes[id] ?? (this._waitingForNodes[id] = new Trigger());
-    const node = this.findNode(id);
-    if (node) {
-      delete this._waitingForNodes[id];
-      return node;
+    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
+      }, {
+        F: __dxlog_file,
+        L: 481,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._registry.set(sourceRx, {
+        inbound: source.inbound,
+        outbound: [
+          ...source.outbound,
+          edgeArg.target
+        ]
+      });
     }
-    if (timeout === void 0) {
-      return trigger.wait();
-    } else {
-      return asyncTimeout(trigger.wait(), timeout, `Node not found: ${id}`);
+    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: 488,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._registry.set(targetRx, {
+        inbound: [
+          ...target.inbound,
+          edgeArg.source
+        ],
+        outbound: target.outbound
+      });
     }
   }
-  /**
-  * Nodes that this node is connected to in default order.
-  */
-  nodes(node, options = {}) {
-    const { relation, expansion, filter = DEFAULT_FILTER, type } = options;
-    const nodes = this._getNodes({
-      node,
-      relation,
-      expansion,
-      type
+  removeEdges(edges, removeOrphans = false) {
+    Rx.batch(() => {
+      edges.map((edge) => this.removeEdge(edge, removeOrphans));
     });
-    return nodes.filter((n) => filter(n, node));
-  }
-  /**
-  * Edges that this node is connected to in default order.
-  */
-  edges(node, { relation = "outbound" } = {}) {
-    return this._edges[node.id]?.[relation] ?? [];
-  }
-  /**
-  * Actions or action groups that this node is connected to in default order.
-  */
-  actions(node, { expansion } = {}) {
-    return [
-      ...this._getNodes({
-        node,
-        expansion,
-        type: ACTION_GROUP_TYPE
-      }),
-      ...this._getNodes({
-        node,
-        expansion,
-        type: ACTION_TYPE
-      })
-    ];
   }
-  async expand(node, relation = "outbound", type) {
-    const key = this._key(node, relation, type);
-    const initialized = this._initialized[key];
-    if (!initialized && this._onInitialNodes) {
-      await this._onInitialNodes(node, relation, type);
-      this._initialized[key] = true;
+  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
+        ]);
+      }
+    }
+  }
+  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);
   }
-  _key(node, relation, type) {
-    return `${node.id}-${relation}-${type}`;
-  }
-  /**
-  * Recursive depth-first traversal of the graph.
-  *
-  * @param options.node The node to start traversing from.
-  * @param options.relation The relation to traverse graph edges.
-  * @param options.visitor A callback which is called for each node visited during traversal.
-  */
-  traverse({ visitor, node = this.root, relation = "outbound", expansion }, path = []) {
-    if (path.includes(node.id)) {
+  traverse({ visitor, source = ROOT_ID, relation = "outbound" }, path = []) {
+    if (path.includes(source)) {
       return;
     }
+    const node = this.getNodeOrThrow(source);
     const shouldContinue = visitor(node, [
       ...path,
-      node.id
+      source
     ]);
     if (shouldContinue === false) {
       return;
     }
-    Object.values(this._getNodes({
-      node,
-      relation,
-      expansion
-    })).forEach((child) => this.traverse({
-      node: child,
+    Object.values(this.getConnections(source, relation)).forEach((child) => this.traverse({
+      source: child.id,
       relation,
-      visitor,
-      expansion
+      visitor
     }, [
       ...path,
-      node.id
+      source
     ]));
   }
-  /**
-  * Recursive depth-first traversal of the graph wrapping each visitor call in an effect.
-  *
-  * @param options.node The node to start traversing from.
-  * @param options.relation The relation to traverse graph edges.
-  * @param options.visitor A callback which is called for each node visited during traversal.
-  */
-  subscribeTraverse({ visitor, node = this.root, relation = "outbound", expansion }, currentPath = []) {
-    return effect(() => {
-      const path = [
-        ...currentPath,
-        node.id
-      ];
-      const result = visitor(node, path);
-      if (result === false) {
-        return;
-      }
-      const nodes = this._getNodes({
-        node,
-        relation,
-        expansion
-      });
-      const nodeSubscriptions = nodes.map((n) => this.subscribeTraverse({
-        node: n,
-        visitor,
-        expansion
-      }, path));
-      return () => {
-        nodeSubscriptions.forEach((unsubscribe) => unsubscribe());
-      };
-    });
-  }
-  /**
-  * Get the path between two nodes in the graph.
-  */
   getPath({ source = "root", target }) {
-    const start = this.findNode(source);
-    if (!start) {
-      return void 0;
-    }
-    let found;
-    this.traverse({
-      node: start,
-      visitor: (node, path) => {
-        if (found) {
-          return false;
-        }
-        if (node.id === target) {
-          found = path;
+    return 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;
+      });
+      return found;
+    }));
   }
-  /**
-  * Wait for the path between two nodes in the graph to be established.
-  */
   async waitForPath(params, { timeout = 5e3, interval = 500 } = {}) {
     const path = this.getPath(params);
-    if (path) {
-      return path;
+    if (Option.isSome(path)) {
+      return path.value;
     }
     const trigger = new Trigger();
     const i = setInterval(() => {
       const path2 = this.getPath(params);
-      if (path2) {
-        trigger.wake(path2);
+      if (Option.isSome(path2)) {
+        trigger.wake(path2.value);
       }
     }, interval);
     return trigger.wait({
       timeout
     }).finally(() => clearInterval(i));
   }
-  /**
-  * Add nodes to the graph.
-  *
-  * @internal
-  */
-  _addNodes(nodes) {
-    return batch(() => nodes.map((node) => this._addNode(node)));
-  }
-  _addNode({ nodes, edges, ..._node }) {
-    return untracked(() => {
-      const existingNode = this._nodes[_node.id];
-      const node = existingNode ?? this._constructNode({
-        data: null,
-        properties: {},
-        ..._node
-      });
-      if (existingNode) {
-        const { data = null, properties, type } = _node;
-        if (data !== node.data) {
-          node.data = data;
-        }
-        if (type !== node.type) {
-          node.type = type;
-        }
-        for (const key in properties) {
-          if (properties[key] !== node.properties[key]) {
-            node.properties[key] = properties[key];
-          }
-        }
-      } else {
-        this._nodes[node.id] = node;
-        this._edges[node.id] = create({
-          inbound: [],
-          outbound: []
-        });
-      }
-      const trigger = this._waitingForNodes[node.id];
-      if (trigger) {
-        trigger.wake(node);
-        delete this._waitingForNodes[node.id];
-      }
-      if (nodes) {
-        nodes.forEach((subNode) => {
-          this._addNode(subNode);
-          this._addEdge({
-            source: node.id,
-            target: subNode.id
-          });
-        });
-      }
-      if (edges) {
-        edges.forEach(([id, relation]) => relation === "outbound" ? this._addEdge({
-          source: node.id,
-          target: id
-        }) : this._addEdge({
-          source: id,
-          target: node.id
-        }));
-      }
-      return node;
-    });
-  }
-  /**
-  * Remove nodes from the graph.
-  *
-  * @param ids The id of the node to remove.
-  * @param edges Whether to remove edges connected to the node from the graph as well.
-  * @internal
-  */
-  _removeNodes(ids, edges = false) {
-    batch(() => ids.forEach((id) => this._removeNode(id, edges)));
-  }
-  _removeNode(id, edges = false) {
-    untracked(() => {
-      const node = this.findNode(id, false);
-      if (!node) {
-        return;
-      }
-      if (edges) {
-        this._getNodes({
-          node
-        }).forEach((node2) => {
-          this._removeEdge({
-            source: id,
-            target: node2.id
-          });
-        });
-        this._getNodes({
-          node,
-          relation: "inbound"
-        }).forEach((node2) => {
-          this._removeEdge({
-            source: node2.id,
-            target: id
-          });
-        });
-        delete this._edges[id];
-      }
-      delete this._nodes[id];
-      Object.keys(this._initialized).filter((key) => key.startsWith(id)).forEach((key) => {
-        delete this._initialized[key];
-      });
-      void this._onRemoveNode?.(id);
-    });
-  }
-  /**
-  * Add edges to the graph.
-  *
-  * @internal
-  */
-  _addEdges(edges) {
-    batch(() => edges.forEach((edge) => this._addEdge(edge)));
-  }
-  _addEdge({ source, target }) {
-    untracked(() => {
-      if (!this._edges[source]) {
-        this._edges[source] = create({
-          inbound: [],
-          outbound: []
-        });
-      }
-      if (!this._edges[target]) {
-        this._edges[target] = create({
-          inbound: [],
-          outbound: []
-        });
-      }
-      const sourceEdges = this._edges[source];
-      if (!sourceEdges.outbound.includes(target)) {
-        sourceEdges.outbound.push(target);
-      }
-      const targetEdges = this._edges[target];
-      if (!targetEdges.inbound.includes(source)) {
-        targetEdges.inbound.push(source);
-      }
-    });
-  }
-  /**
-  * Remove edges from the graph.
-  * @internal
-  */
-  _removeEdges(edges, removeOrphans = false) {
-    batch(() => edges.forEach((edge) => this._removeEdge(edge, removeOrphans)));
-  }
-  _removeEdge({ source, target }, removeOrphans = false) {
-    untracked(() => {
-      batch(() => {
-        const outboundIndex = this._edges[source]?.outbound.findIndex((id) => id === target);
-        if (outboundIndex !== void 0 && outboundIndex !== -1) {
-          this._edges[source].outbound.splice(outboundIndex, 1);
-        }
-        const inboundIndex = this._edges[target]?.inbound.findIndex((id) => id === source);
-        if (inboundIndex !== void 0 && inboundIndex !== -1) {
-          this._edges[target].inbound.splice(inboundIndex, 1);
-        }
-        if (removeOrphans) {
-          if (this._edges[source]?.outbound.length === 0 && this._edges[source]?.inbound.length === 0 && source !== ROOT_ID) {
-            this._removeNode(source, true);
-          }
-          if (this._edges[target]?.outbound.length === 0 && this._edges[target]?.inbound.length === 0 && target !== ROOT_ID) {
-            this._removeNode(target, true);
-          }
-        }
-      });
-    });
-  }
-  /**
-  * Sort edges for a node.
-  *
-  * Edges not included in the sorted list are appended to the end of the list.
-  *
-  * @param nodeId The id of the node to sort edges for.
-  * @param relation The relation of the edges from the node to sort.
-  * @param edges The ordered list of edges.
-  * @ignore
-  */
-  _sortEdges(nodeId, relation, edges) {
-    untracked(() => {
-      batch(() => {
-        const current = this._edges[nodeId];
-        if (current) {
-          const unsorted = current[relation].filter((id) => !edges.includes(id)) ?? [];
-          const sorted = edges.filter((id) => current[relation].includes(id)) ?? [];
-          current[relation].splice(0, current[relation].length, ...[
-            ...sorted,
-            ...unsorted
-          ]);
-        }
-      });
+  /** @internal */
+  _constructNode(node) {
+    return Option.some({
+      [graphSymbol]: this,
+      data: null,
+      properties: {},
+      ...node
     });
   }
-  _getNodes({ node, relation = "outbound", type, expansion }) {
-    if (expansion) {
-      void this.expand(node, relation, type);
-    }
-    const edges = this._edges[node.id];
-    if (!edges) {
-      return [];
-    } else {
-      return edges[relation].map((id) => this._nodes[id]).filter(isNonNullable).filter((n) => !type || n.type === type);
-    }
-  }
 };
 
 // packages/sdk/app-graph/src/graph-builder.ts
-import { effect as effect2, signal, untracked as untracked2 } from "@preact/signals-core";
-import { Trigger as Trigger2 } from "@dxos/async";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { create as create2 } from "@dxos/live-object";
+import { Registry as Registry2, Rx as Rx2 } from "@effect-rx/rx-react";
+import { effect } from "@preact/signals-core";
+import { Array, pipe as pipe2, Record as Record2 } from "effect";
 import { log as log2 } from "@dxos/log";
-import { byPosition, isNode, isNonNullable as isNonNullable2 } from "@dxos/util";
+import { byPosition, getDebugName, isNode, isNonNullable as isNonNullable2 } from "@dxos/util";
+
+// packages/sdk/app-graph/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" : false;
+var actionGroupSymbol = Symbol("ActionGroup");
+var isActionGroup = (data) => isGraphNode(data) ? data.data === actionGroupSymbol : false;
+var isActionLike = (data) => isAction(data) || isActionGroup(data);
+
+// packages/sdk/app-graph/src/graph-builder.ts
 var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/sdk/app-graph/src/graph-builder.ts";
-var NODE_RESOLVER_TIMEOUT = 1e3;
 var createExtension = (extension) => {
-  const { id, position = "static", resolver, connector, actions, actionGroups, ...rest } = extension;
+  const { id, position = "static", relation = "outbound", connector: _connector, actions: _actions, actionGroups: _actionGroups } = extension;
   const getId = (key) => `${id}/${key}`;
+  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,
+    // resolver ? { id: getId('resolver'), position, resolver } : undefined,
     connector ? {
-      ...rest,
       id: getId("connector"),
       position,
-      connector
+      relation,
+      connector: Rx2.family((node) => Rx2.make((get) => {
+        try {
+          return get(connector(node));
+        } catch {
+          log2.warn("Error in connector", {
+            id: getId("connector"),
+            node
+          }, {
+            F: __dxlog_file2,
+            L: 101,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          return [];
+        }
+      }).pipe(Rx2.withLabel(`graph-builder:connector:${id}`)))
     } : void 0,
     actionGroups ? {
-      ...rest,
       id: getId("actionGroups"),
       position,
-      type: ACTION_GROUP_TYPE,
       relation: "outbound",
-      connector: ({ node }) => actionGroups({
-        node
-      })?.map((arg) => ({
-        ...arg,
-        data: actionGroupSymbol,
-        type: ACTION_GROUP_TYPE
-      }))
+      connector: Rx2.family((node) => Rx2.make((get) => {
+        try {
+          return get(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: 122,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          return [];
+        }
+      }).pipe(Rx2.withLabel(`graph-builder:connector:actionGroups:${id}`)))
     } : void 0,
     actions ? {
-      ...rest,
       id: getId("actions"),
       position,
-      type: ACTION_TYPE,
       relation: "outbound",
-      connector: ({ node }) => actions({
-        node
-      })?.map((arg) => ({
-        ...arg,
-        type: ACTION_TYPE
-      }))
+      connector: Rx2.family((node) => Rx2.make((get) => {
+        try {
+          return get(actions(node)).map((arg) => ({
+            ...arg,
+            type: ACTION_TYPE
+          }));
+        } catch {
+          log2.warn("Error in actions", {
+            id: getId("actions"),
+            node
+          }, {
+            F: __dxlog_file2,
+            L: 139,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          return [];
+        }
+      }).pipe(Rx2.withLabel(`graph-builder:connector:actions:${id}`)))
     } : void 0
   ].filter(isNonNullable2);
 };
-var Dispatcher = class {
-  constructor() {
-    this.stateIndex = 0;
-    this.state = {};
-    this.cleanup = [];
-  }
-};
-var BuilderInternal = class {
-};
-var memoize = (fn, key = "result") => {
-  const dispatcher = BuilderInternal.currentDispatcher;
-  invariant2(dispatcher?.currentExtension, "memoize must be called within an extension", {
-    F: __dxlog_file2,
-    L: 135,
-    S: void 0,
-    A: [
-      "dispatcher?.currentExtension",
-      "'memoize must be called within an extension'"
-    ]
-  });
-  const all = dispatcher.state[dispatcher.currentExtension][dispatcher.stateIndex] ?? {};
-  const current = all[key];
-  const result = current ? current.result : fn();
-  dispatcher.state[dispatcher.currentExtension][dispatcher.stateIndex] = {
-    ...all,
-    [key]: {
-      result
-    }
-  };
-  dispatcher.stateIndex++;
-  return result;
-};
-var cleanup = (fn) => {
-  memoize(() => {
-    const dispatcher = BuilderInternal.currentDispatcher;
-    invariant2(dispatcher, "cleanup must be called within an extension", {
-      F: __dxlog_file2,
-      L: 150,
-      S: void 0,
-      A: [
-        "dispatcher",
-        "'cleanup must be called within an extension'"
-      ]
-    });
-    dispatcher.cleanup.push(fn);
-  });
-};
-var toSignal = (subscribe, get, key) => {
-  const thisSignal = memoize(() => {
-    return signal(get());
-  }, key);
-  const unsubscribe = memoize(() => {
-    return subscribe(() => thisSignal.value = get());
-  }, key);
-  cleanup(() => {
-    unsubscribe();
-  });
-  return thisSignal.value;
-};
 var flattenExtensions = (extension, acc = []) => {
   if (Array.isArray(extension)) {
     return [
@@ -692,107 +578,75 @@ var flattenExtensions = (extension, acc = []) => {
   }
 };
 var GraphBuilder = class _GraphBuilder {
-  constructor(params = {}) {
-    this._dispatcher = new Dispatcher();
-    this._extensions = create2({});
-    this._resolverSubscriptions = /* @__PURE__ */ new Map();
+  constructor({ registry, ...params } = {}) {
+    // TODO(wittjosiah): Use Context.
     this._connectorSubscriptions = /* @__PURE__ */ new Map();
-    this._nodeChanged = {};
-    this._initialized = {};
+    this._extensions = Rx2.make(Record2.empty()).pipe(Rx2.keepAlive, Rx2.withLabel("graph-builder:extensions"));
+    this._connectors = Rx2.family((key) => {
+      return Rx2.make((get) => {
+        const [id, relation] = key.split("+");
+        const node = this._graph.node(id);
+        return pipe2(
+          get(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) => get(result))
+        );
+      }).pipe(Rx2.withLabel(`graph-builder:connectors:${key}`));
+    });
+    this._registry = registry ?? Registry2.make();
     this._graph = new Graph({
       ...params,
-      onInitialNode: async (id) => this._onInitialNode(id),
-      onInitialNodes: async (node, relation, type) => this._onInitialNodes(node, relation, type),
+      registry: this._registry,
+      onExpand: (id, relation) => this._onExpand(id, relation),
+      // onInitialize: (id) => this._onInitialize(id),
       onRemoveNode: (id) => this._onRemoveNode(id)
     });
   }
-  static from(pickle) {
+  static from(pickle, registry) {
     if (!pickle) {
-      return new _GraphBuilder();
+      return new _GraphBuilder({
+        registry
+      });
     }
     const { nodes, edges } = JSON.parse(pickle);
     return new _GraphBuilder({
       nodes,
-      edges
+      edges,
+      registry
     });
   }
-  /**
-  * If graph is being restored from a pickle, the data will be null.
-  * Initialize the data of each node by calling resolvers.
-  * Wait until all of the initial nodes have resolved.
-  */
-  async initialize() {
-    Object.keys(this._graph._nodes).filter((id) => id !== ROOT_ID).forEach((id) => this._initialized[id] = new Trigger2());
-    Object.keys(this._graph._nodes).forEach((id) => this._onInitialNode(id));
-    await Promise.all(Object.entries(this._initialized).map(async ([id, trigger]) => {
-      try {
-        await trigger.wait({
-          timeout: NODE_RESOLVER_TIMEOUT
-        });
-      } catch {
-        log2.error("node resolver timeout", {
-          id
-        }, {
-          F: __dxlog_file2,
-          L: 244,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this.graph._removeNodes([
-          id
-        ]);
-      }
-    }));
-  }
   get graph() {
     return this._graph;
   }
-  /**
-  * @reactive
-  */
   get extensions() {
-    return Object.values(this._extensions);
-  }
-  /**
-  * Register a node builder which will be called in order to construct the graph.
-  */
-  addExtension(extension) {
-    const extensions = flattenExtensions(extension);
-    untracked2(() => {
-      extensions.forEach((extension2) => {
-        this._dispatcher.state[extension2.id] = [];
-        this._extensions[extension2.id] = extension2;
-      });
+    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));
     });
     return this;
   }
-  /**
-  * Remove a node builder from the graph builder.
-  */
   removeExtension(id) {
-    untracked2(() => {
-      delete this._extensions[id];
-    });
+    const extensions = this._registry.get(this._extensions);
+    this._registry.set(this._extensions, Record2.remove(extensions, id));
     return this;
   }
-  destroy() {
-    this._dispatcher.cleanup.forEach((fn) => fn());
-    this._resolverSubscriptions.forEach((unsubscribe) => unsubscribe());
-    this._connectorSubscriptions.forEach((unsubscribe) => unsubscribe());
-    this._resolverSubscriptions.clear();
-    this._connectorSubscriptions.clear();
-  }
-  /**
-  * A graph traversal using just the connector extensions, without subscribing to any signals or persisting any nodes.
-  */
-  async explore({ node = this._graph.root, relation = "outbound", visitor }, path = []) {
-    if (path.includes(node.id)) {
+  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
@@ -800,158 +654,104 @@ var GraphBuilder = class _GraphBuilder {
     if (shouldContinue === false) {
       return;
     }
-    const nodes = Object.values(this._extensions).filter((extension) => relation === (extension.relation ?? "outbound")).filter((extension) => !extension.filter || extension.filter(node)).flatMap((extension) => {
-      this._dispatcher.currentExtension = extension.id;
-      this._dispatcher.stateIndex = 0;
-      BuilderInternal.currentDispatcher = this._dispatcher;
-      const result = extension.connector?.({
-        node
-      }) ?? [];
-      BuilderInternal.currentDispatcher = void 0;
-      return result;
-    }).map((arg) => ({
-      id: arg.id,
-      type: arg.type,
-      cacheable: arg.cacheable,
-      data: arg.data ?? null,
-      properties: arg.properties ?? {}
-    }));
-    await Promise.all(nodes.map((n) => this.explore({
-      node: n,
-      relation,
-      visitor
-    }, [
-      ...path,
-      node.id
-    ])));
-  }
-  _onInitialNode(nodeId) {
-    this._nodeChanged[nodeId] = this._nodeChanged[nodeId] ?? signal({});
-    this._resolverSubscriptions.set(nodeId, effect2(() => {
-      const extensions = Object.values(this._extensions).toSorted(byPosition);
-      for (const { id, resolver } of extensions) {
-        if (!resolver) {
-          continue;
-        }
-        this._dispatcher.currentExtension = id;
-        this._dispatcher.stateIndex = 0;
-        BuilderInternal.currentDispatcher = this._dispatcher;
-        let node;
-        try {
-          node = resolver({
-            id: nodeId
-          });
-        } catch (err) {
-          log2.catch(err, {
-            extension: id
-          }, {
-            F: __dxlog_file2,
-            L: 359,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          log2.error(`Previous error occurred in extension: ${id}`, void 0, {
-            F: __dxlog_file2,
-            L: 360,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-        } finally {
-          BuilderInternal.currentDispatcher = void 0;
-        }
-        const trigger = this._initialized[nodeId];
-        if (node) {
-          this.graph._addNodes([
-            node
-          ]);
-          trigger?.wake();
-          if (this._nodeChanged[node.id]) {
-            this._nodeChanged[node.id].value = {};
-          }
-          break;
-        } else if (node === false) {
-          this.graph._removeNodes([
-            nodeId
-          ]);
-          trigger?.wake();
-          break;
-        }
-      }
+    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();
+    }
   }
-  _onInitialNodes(node, nodesRelation, nodesType) {
-    this._nodeChanged[node.id] = this._nodeChanged[node.id] ?? signal({});
-    let first = true;
+  destroy() {
+    this._connectorSubscriptions.forEach((unsubscribe) => unsubscribe());
+    this._connectorSubscriptions.clear();
+  }
+  _onExpand(id, relation) {
+    log2("onExpand", {
+      id,
+      relation,
+      registry: getDebugName(this._registry)
+    }, {
+      F: __dxlog_file2,
+      L: 301,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const connectors = this._connectors(`${id}+${relation}`);
     let previous = [];
-    this._connectorSubscriptions.set(node.id, effect2(() => {
-      if (!first && !this._connectorSubscriptions.has(node.id)) {
-        return;
-      }
-      first = false;
-      Object.keys(this._extensions);
-      this._nodeChanged[node.id].value;
-      const nodes = [];
-      const extensions = Object.values(this._extensions).toSorted(byPosition);
-      for (const { id, connector, filter, type, relation = "outbound" } of extensions) {
-        if (!connector || relation !== nodesRelation || nodesType && type !== nodesType || filter && !filter(node)) {
-          continue;
-        }
-        this._dispatcher.currentExtension = id;
-        this._dispatcher.stateIndex = 0;
-        BuilderInternal.currentDispatcher = this._dispatcher;
-        try {
-          nodes.push(...connector({
-            node
-          }) ?? []);
-        } catch (err) {
-          log2.catch(err, {
-            extension: id
-          }, {
-            F: __dxlog_file2,
-            L: 421,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          log2.error(`Previous error occurred in extension: ${id}`, void 0, {
-            F: __dxlog_file2,
-            L: 422,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-        } finally {
-          BuilderInternal.currentDispatcher = void 0;
-        }
-      }
+    const cancel = this._registry.subscribe(connectors, (nodes) => {
       const ids = nodes.map((n) => n.id);
-      const removed = previous.filter((id) => !ids.includes(id));
+      const removed = previous.filter((id2) => !ids.includes(id2));
       previous = ids;
-      this.graph._removeEdges(removed.map((target) => ({
-        source: node.id,
-        target
-      })), true);
-      this.graph._addNodes(nodes);
-      this.graph._addEdges(nodes.map(({ id }) => nodesRelation === "outbound" ? {
-        source: node.id,
-        target: id
-      } : {
-        source: id,
-        target: node.id
-      }));
-      this.graph._sortEdges(node.id, nodesRelation, nodes.map(({ id }) => id));
-      nodes.forEach((n) => {
-        if (this._nodeChanged[n.id]) {
-          this._nodeChanged[n.id].value = {};
-        }
+      log2("update", {
+        id,
+        relation,
+        ids,
+        removed
+      }, {
+        F: __dxlog_file2,
+        L: 312,
+        S: this,
+        C: (f, a) => f(...a)
       });
-    }));
+      Rx2.batch(() => {
+        this._graph.removeEdges(removed.map((target) => ({
+          source: id,
+          target
+        })), true);
+        this._graph.addNodes(nodes);
+        this._graph.addEdges(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));
+      });
+    }, {
+      immediate: true
+    });
+    this._connectorSubscriptions.set(id, cancel);
   }
-  async _onRemoveNode(nodeId) {
-    this._resolverSubscriptions.get(nodeId)?.();
-    this._connectorSubscriptions.get(nodeId)?.();
-    this._resolverSubscriptions.delete(nodeId);
-    this._connectorSubscriptions.delete(nodeId);
+  // TODO(wittjosiah): On initialize to restore state from cache.
+  // private async _onInitialize(id: string) {
+  //   log('onInitialize', { id });
+  // }
+  _onRemoveNode(id) {
+    this._connectorSubscriptions.get(id)?.();
+    this._connectorSubscriptions.delete(id);
   }
 };
+var rxFromSignal = (cb) => {
+  return Rx2.make((get) => {
+    const dispose = effect(() => {
+      get.setSelf(cb());
+    });
+    get.addFinalizer(() => dispose());
+    return cb();
+  });
+};
+var observableFamily = Rx2.family((observable) => {
+  return Rx2.make((get) => {
+    const subscription = observable.subscribe((value) => get.setSelf(value));
+    get.addFinalizer(() => subscription.unsubscribe());
+    return observable.get();
+  });
+});
+var rxFromObservable = (observable) => {
+  return observableFamily(observable);
+};
 export {
   ACTION_GROUP_TYPE,
   ACTION_TYPE,
@@ -960,7 +760,6 @@ export {
   ROOT_ID,
   ROOT_TYPE,
   actionGroupSymbol,
-  cleanup,
   createExtension,
   flattenExtensions,
   getGraph,
@@ -968,7 +767,7 @@ export {
   isActionGroup,
   isActionLike,
   isGraphNode,
-  memoize,
-  toSignal
+  rxFromObservable,
+  rxFromSignal
 };
 //# sourceMappingURL=index.mjs.map