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

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

@@ -1,20 +1,28 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 
 // packages/sdk/app-graph/src/graph.ts
-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 { batch, effect, untracked } from "@preact/signals-core";
+import { asyncTimeout, Trigger } from "@dxos/async";
 import { invariant } from "@dxos/invariant";
+import { create } from "@dxos/live-object";
 import { log } from "@dxos/log";
-import { isNonNullable } from "@dxos/util";
+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
 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: 25,
+    L: 21,
     S: void 0,
     A: [
       "graph",
@@ -27,496 +35,649 @@ 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 {
-  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;
+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
       });
-    });
-    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._onInitialNode = onInitialNode;
+    this._onInitialNodes = onInitialNodes;
     this._onRemoveNode = onRemoveNode;
+    this._nodes[ROOT_ID] = this._constructNode({
+      id: ROOT_ID,
+      type: ROOT_TYPE,
+      cacheable: [],
+      properties: {},
+      data: null
+    });
     if (nodes) {
       nodes.forEach((node) => {
-        Record.set(this._initialNodes, node.id, this._constructNode(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
+          });
+        }
       });
     }
+    this._edges[ROOT_ID] = create({
+      inbound: [],
+      outbound: []
+    });
     if (edges) {
       Object.entries(edges).forEach(([source, edges2]) => {
-        Record.set(this._initialEdges, source, edges2);
+        edges2.forEach((target) => {
+          this._addEdge({
+            source,
+            target
+          });
+        });
+        this._sortEdges(source, "outbound", edges2);
       });
     }
   }
-  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);
+  static from(pickle, options = {}) {
+    const { nodes, edges } = JSON.parse(pickle);
+    return new _Graph({
+      nodes,
+      edges,
+      ...options
+    });
   }
+  /**
+  * Alias for `findNode('root')`.
+  */
   get root() {
-    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
-    }, {
+    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}`, {
       F: __dxlog_file,
-      L: 395,
+      L: 171,
       S: this,
-      C: (f, a) => f(...a)
+      A: [
+        "root",
+        "`Node not found: ${id}`"
+      ]
     });
-    if (!expanded) {
-      this._onExpand?.(id, relation);
-      Record.set(this._expanded, key, true);
-    }
-  }
-  addNodes(nodes) {
-    Rx.batch(() => {
-      nodes.map((node) => this.addNode(node));
+    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)
+      };
     });
-  }
-  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", {
-          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();
-    }
-  }
-  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({
+    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,
-      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));
+      outbound.filter((nodeId) => cacheable.has(nodeId))
+    ]).toSorted(([a], [b]) => a.localeCompare(b)));
+    return JSON.stringify({
+      nodes,
+      edges
     });
   }
-  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
-        ]
-      });
+  /**
+  * 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);
     }
-    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
-      });
+    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;
+    }
+    if (timeout === void 0) {
+      return trigger.wait();
+    } else {
+      return asyncTimeout(trigger.wait(), timeout, `Node not found: ${id}`);
     }
   }
-  removeEdges(edges, removeOrphans = false) {
-    Rx.batch(() => {
-      edges.map((edge) => this.removeEdge(edge, removeOrphans));
+  /**
+  * 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
     });
+    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
+      })
+    ];
   }
-  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)
-      });
+  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;
     }
-    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);
   }
-  traverse({ visitor, source = ROOT_ID, relation = "outbound" }, path = []) {
-    if (path.includes(source)) {
+  _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)) {
       return;
     }
-    const node = this.getNodeOrThrow(source);
     const shouldContinue = visitor(node, [
       ...path,
-      source
+      node.id
     ]);
     if (shouldContinue === false) {
       return;
     }
-    Object.values(this.getConnections(source, relation)).forEach((child) => this.traverse({
-      source: child.id,
+    Object.values(this._getNodes({
+      node,
       relation,
-      visitor
+      expansion
+    })).forEach((child) => this.traverse({
+      node: child,
+      relation,
+      visitor,
+      expansion
     }, [
       ...path,
-      source
+      node.id
     ]));
   }
+  /**
+  * 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 }) {
-    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);
-          }
+    const start = this.findNode(source);
+    if (!start) {
+      return void 0;
+    }
+    let found;
+    this.traverse({
+      node: start,
+      visitor: (node, path) => {
+        if (found) {
+          return false;
         }
-      });
-      return found;
-    }));
+        if (node.id === target) {
+          found = path;
+        }
+      }
+    });
+    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 (Option.isSome(path)) {
-      return path.value;
+    if (path) {
+      return path;
     }
     const trigger = new Trigger();
     const i = setInterval(() => {
       const path2 = this.getPath(params);
-      if (Option.isSome(path2)) {
-        trigger.wake(path2.value);
+      if (path2) {
+        trigger.wake(path2);
       }
     }, interval);
     return trigger.wait({
       timeout
     }).finally(() => clearInterval(i));
   }
-  /** @internal */
-  _constructNode(node) {
-    return Option.some({
-      [graphSymbol]: this,
-      data: null,
-      properties: {},
-      ...node
+  /**
+  * 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
+          ]);
+        }
+      });
+    });
+  }
+  _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 { 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 { 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 { log as log2 } from "@dxos/log";
-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
+import { byPosition, isNode, isNonNullable as isNonNullable2 } from "@dxos/util";
 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", relation = "outbound", connector, actions: _actions, actionGroups: _actionGroups } = extension;
+  const { id, position = "static", resolver, connector, actions, actionGroups, ...rest } = extension;
   const getId = (key) => `${id}/${key}`;
-  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 } : undefined,
+    resolver ? {
+      id: getId("resolver"),
+      position,
+      resolver
+    } : void 0,
     connector ? {
+      ...rest,
       id: getId("connector"),
       position,
-      relation,
-      connector: Rx2.family((key) => connector(key).pipe(Rx2.withLabel(`graph-builder:connector:${id}`)))
+      connector
     } : void 0,
     actionGroups ? {
+      ...rest,
       id: getId("actionGroups"),
       position,
+      type: ACTION_GROUP_TYPE,
       relation: "outbound",
-      connector: Rx2.family((node) => Rx2.make((get) => get(actionGroups(node)).map((arg) => ({
+      connector: ({ node }) => actionGroups({
+        node
+      })?.map((arg) => ({
         ...arg,
         data: actionGroupSymbol,
         type: ACTION_GROUP_TYPE
-      }))).pipe(Rx2.withLabel(`graph-builder:connector:actionGroups:${id}`)))
+      }))
     } : void 0,
     actions ? {
+      ...rest,
       id: getId("actions"),
       position,
+      type: ACTION_TYPE,
       relation: "outbound",
-      connector: Rx2.family((node) => Rx2.make((get) => get(actions(node)).map((arg) => ({
+      connector: ({ node }) => actions({
+        node
+      })?.map((arg) => ({
         ...arg,
         type: ACTION_TYPE
-      }))).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 [
@@ -531,75 +692,107 @@ var flattenExtensions = (extension, acc = []) => {
   }
 };
 var GraphBuilder = class _GraphBuilder {
-  constructor({ registry, ...params } = {}) {
-    // TODO(wittjosiah): Use Context.
+  constructor(params = {}) {
+    this._dispatcher = new Dispatcher();
+    this._extensions = create2({});
+    this._resolverSubscriptions = /* @__PURE__ */ new Map();
     this._connectorSubscriptions = /* @__PURE__ */ new Map();
-    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._nodeChanged = {};
+    this._initialized = {};
     this._graph = new Graph({
       ...params,
-      registry: this._registry,
-      onExpand: (id, relation) => this._onExpand(id, relation),
-      // onInitialize: (id) => this._onInitialize(id),
+      onInitialNode: async (id) => this._onInitialNode(id),
+      onInitialNodes: async (node, relation, type) => this._onInitialNodes(node, relation, type),
       onRemoveNode: (id) => this._onRemoveNode(id)
     });
   }
-  static from(pickle, registry) {
+  static from(pickle) {
     if (!pickle) {
-      return new _GraphBuilder({
-        registry
-      });
+      return new _GraphBuilder();
     }
     const { nodes, edges } = JSON.parse(pickle);
     return new _GraphBuilder({
       nodes,
-      edges,
-      registry
+      edges
     });
   }
+  /**
+  * 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 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 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;
   }
+  /**
+  * Remove a node builder from the graph builder.
+  */
   removeExtension(id) {
-    const extensions = this._registry.get(this._extensions);
-    this._registry.set(this._extensions, Record2.remove(extensions, id));
+    untracked2(() => {
+      delete this._extensions[id];
+    });
     return this;
   }
-  async explore({ registry = Registry2.make(), source = ROOT_ID, relation = "outbound", visitor }, path = []) {
-    if (path.includes(source)) {
+  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)) {
       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
@@ -607,104 +800,158 @@ var GraphBuilder = class _GraphBuilder {
     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
-      ]);
+    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 ?? {}
     }));
-    if (registry !== this._registry) {
-      registry.reset();
-      registry.dispose();
-    }
-  }
-  destroy() {
-    this._connectorSubscriptions.forEach((unsubscribe) => unsubscribe());
-    this._connectorSubscriptions.clear();
-  }
-  _onExpand(id, relation) {
-    log2("onExpand", {
-      id,
+    await Promise.all(nodes.map((n) => this.explore({
+      node: n,
       relation,
-      registry: getDebugName(this._registry)
-    }, {
-      F: __dxlog_file2,
-      L: 276,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const connectors = this._connectors(`${id}+${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;
+        }
+      }
+    }));
+  }
+  _onInitialNodes(node, nodesRelation, nodesType) {
+    this._nodeChanged[node.id] = this._nodeChanged[node.id] ?? signal({});
+    let first = true;
     let previous = [];
-    const cancel = this._registry.subscribe(connectors, (nodes) => {
+    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 ids = nodes.map((n) => n.id);
-      const removed = previous.filter((id2) => !ids.includes(id2));
+      const removed = previous.filter((id) => !ids.includes(id));
       previous = ids;
-      log2("update", {
-        id,
-        relation,
-        ids,
-        removed
-      }, {
-        F: __dxlog_file2,
-        L: 287,
-        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));
+      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 = {};
+        }
       });
-    }, {
-      immediate: true
-    });
-    this._connectorSubscriptions.set(id, cancel);
+    }));
   }
-  // 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);
+  async _onRemoveNode(nodeId) {
+    this._resolverSubscriptions.get(nodeId)?.();
+    this._connectorSubscriptions.get(nodeId)?.();
+    this._resolverSubscriptions.delete(nodeId);
+    this._connectorSubscriptions.delete(nodeId);
   }
 };
-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,
@@ -713,6 +960,7 @@ export {
   ROOT_ID,
   ROOT_TYPE,
   actionGroupSymbol,
+  cleanup,
   createExtension,
   flattenExtensions,
   getGraph,
@@ -720,7 +968,7 @@ export {
   isActionGroup,
   isActionLike,
   isGraphNode,
-  rxFromObservable,
-  rxFromSignal
+  memoize,
+  toSignal
 };
 //# sourceMappingURL=index.mjs.map