@dxos/app-graph 0.6.3-main.9e4e207 → 0.6.3-next.2f65b78

package/dist/lib/browser/index.mjs

@@ -1,6 +1,5 @@
 // packages/sdk/app-graph/src/graph.ts
-import { batch, effect, untracked } from "@preact/signals-core";
-import { Trigger } from "@dxos/async";
+import { untracked } from "@preact/signals-core";
 import { create } from "@dxos/echo-schema";
 import { invariant } from "@dxos/invariant";
 import { nonNullable } from "@dxos/util";
@@ -14,56 +13,51 @@ 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: 20,
-    S: void 0,
-    A: [
-      "graph",
-      "'Node is not associated with a graph.'"
-    ]
-  });
-  return graph;
-};
 var ROOT_ID = "root";
-var ROOT_TYPE = "dxos.org/type/GraphRoot";
-var ACTION_TYPE = "dxos.org/type/GraphAction";
-var ACTION_GROUP_TYPE = "dxos.org/type/GraphActionGroup";
-var NODE_TIMEOUT = 5e3;
 var Graph = class {
-  constructor({ onInitialNode, onInitialNodes, onRemoveNode } = {}) {
-    this._waitingForNodes = {};
-    this._initialized = {};
+  constructor() {
     /**
     * @internal
     */
-    this._nodes = {};
+    this._nodes = create({
+      [ROOT_ID]: {
+        id: ROOT_ID,
+        properties: {},
+        data: null
+      }
+    });
     /**
     * @internal
     */
-    this._edges = {};
-    this._constructNode = (node) => {
-      return create({
-        ...node,
-        [graphSymbol]: this
-      });
+    // Key is the `${node.id}-${direction}` and value is an ordered list of node ids.
+    // Explicit type required because TS says this is not portable.
+    this._edges = create({});
+    this._constructNode = (nodeBase) => {
+      const node = {
+        ...nodeBase,
+        edges: ({ direction = "outbound" } = {}) => {
+          return this._edges[this.getEdgeKey(node.id, direction)];
+        },
+        nodes: ({ direction, filter } = {}) => {
+          const nodes = this._getNodes({
+            id: node.id,
+            direction
+          }).filter((n) => !isActionLike(n));
+          return filter ? nodes.filter((n) => filter(n, node)) : nodes;
+        },
+        node: (id) => {
+          return this._getNodes({
+            id
+          }).find((node2) => node2.id === id);
+        },
+        actions: () => {
+          return this._getNodes({
+            id: node.id
+          }).filter(isActionLike);
+        }
+      };
+      return node;
     };
-    this._onInitialNode = onInitialNode;
-    this._onInitialNodes = onInitialNodes;
-    this._onRemoveNode = onRemoveNode;
-    this._nodes[ROOT_ID] = this._constructNode({
-      id: ROOT_ID,
-      type: ROOT_TYPE,
-      properties: {},
-      data: null
-    });
-    this._edges[ROOT_ID] = create({
-      inbound: [],
-      outbound: []
-    });
   }
   /**
   * Alias for `findNode('root')`.
@@ -74,14 +68,11 @@ var Graph = class {
   /**
   * Convert the graph to a JSON object.
   */
-  toJSON({ id = ROOT_ID, maxLength = 32, onlyLoaded = true } = {}) {
+  toJSON({ id = ROOT_ID, maxLength = 32 } = {}) {
     const toJSON = (node, seen = []) => {
-      const nodes = this.nodes(node, {
-        onlyLoaded
-      });
+      const nodes = node.nodes();
       const obj = {
-        id: node.id.length > maxLength ? `${node.id.slice(0, maxLength - 3)}...` : node.id,
-        type: node.type
+        id: node.id.length > maxLength ? `${node.id.slice(0, maxLength - 3)}...` : node.id
       };
       if (node.properties.label) {
         obj.label = node.properties.label;
@@ -100,7 +91,7 @@ var Graph = class {
     const root = this.findNode(id);
     invariant(root, `Node not found: ${id}`, {
       F: __dxlog_file,
-      L: 140,
+      L: 91,
       S: this,
       A: [
         "root",
@@ -111,639 +102,257 @@ var Graph = class {
   }
   /**
   * 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, type) {
-    const existingNode = this._nodes[id];
-    const nodeArg = !existingNode && this._onInitialNode?.(id, type);
-    return existingNode ?? (nodeArg ? this._addNode(nodeArg) : void 0);
-  }
-  /**
-  * 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.
   */
-  waitForNode(id, timeout = NODE_TIMEOUT) {
-    if (this._nodes[id]) {
-      return Promise.resolve(this._nodes[id]);
+  findNode(id) {
+    const nodeBase = this._nodes[id];
+    if (!nodeBase) {
+      return void 0;
     }
-    const trigger = this._waitingForNodes[id] ?? (this._waitingForNodes[id] = new Trigger());
-    return trigger.wait({
-      timeout
-    });
+    return this._constructNode(nodeBase);
   }
-  /**
-  * Nodes that this node is connected to in default order.
-  */
-  nodes(node, options = {}) {
-    const { onlyLoaded, relation, filter, type } = options;
-    const nodes = this._getNodes({
-      node,
-      relation,
-      type,
-      onlyLoaded
-    });
-    return nodes.filter((n) => untracked(() => !isActionLike(n))).filter((n) => filter?.(n, node) ?? true);
-  }
-  /**
-  * 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, { onlyLoaded } = {}) {
-    return [
-      ...this._getNodes({
-        node,
-        type: ACTION_GROUP_TYPE,
-        onlyLoaded
-      }),
-      ...this._getNodes({
-        node,
-        type: ACTION_TYPE,
-        onlyLoaded
-      })
-    ];
-  }
-  /**
-  * 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", onlyLoaded }, path = []) {
-    if (path.includes(node.id)) {
-      return;
-    }
-    const shouldContinue = visitor(node, [
-      ...path,
-      node.id
-    ]);
-    if (shouldContinue === false) {
-      return;
+  _getNodes({ id, direction = "outbound" }) {
+    const edges = this._edges[this.getEdgeKey(id, direction)];
+    if (!edges) {
+      return [];
     }
-    Object.values(this._getNodes({
-      node,
-      relation,
-      onlyLoaded
-    })).forEach((child) => this.traverse({
-      node: child,
-      relation,
-      visitor,
-      onlyLoaded
-    }, [
-      ...path,
-      node.id
-    ]));
+    return edges.map((id2) => this.findNode(id2)).filter(nonNullable);
   }
-  /**
-  * 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", onlyLoaded }, currentPath = []) {
-    return effect(() => {
-      const path = [
-        ...currentPath,
-        node.id
-      ];
-      const result = visitor(node, path);
-      if (result === false) {
-        return;
-      }
-      const nodes = this._getNodes({
-        node,
-        relation,
-        onlyLoaded
-      });
-      const nodeSubscriptions = nodes.map((n) => this.subscribeTraverse({
-        node: n,
-        visitor,
-        onlyLoaded
-      }, 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({
-      onlyLoaded: true,
-      node: start,
-      visitor: (node, path) => {
-        if (found) {
-          return false;
-        }
-        if (node.id === target) {
-          found = path;
-        }
-      }
-    });
-    return found;
+  getEdgeKey(id, direction) {
+    return `${id}-${direction}`;
   }
   /**
   * Add nodes to the graph.
-  *
-  * @internal
   */
-  _addNodes(nodes) {
-    return batch(() => nodes.map((node) => this._addNode(node)));
+  addNodes(...nodes) {
+    return nodes.map((node) => this._addNode(node));
   }
   _addNode({ nodes, edges, ..._node }) {
     return untracked(() => {
-      const existingNode = this._nodes[_node.id];
-      const node = existingNode ?? this._constructNode({
+      const node = {
         data: null,
         properties: {},
         ..._node
-      });
-      if (existingNode) {
-        const { data, properties, type } = _node;
-        if (data && 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];
-      }
+      };
+      this._nodes[node.id] = node;
       if (nodes) {
         nodes.forEach((subNode) => {
           this._addNode(subNode);
-          this._addEdge({
+          this.addEdge({
             source: node.id,
             target: subNode.id
           });
         });
       }
       if (edges) {
-        edges.forEach(([id, relation]) => relation === "outbound" ? this._addEdge({
+        edges.forEach(([id, direction]) => direction === "outbound" ? this.addEdge({
           source: node.id,
           target: id
-        }) : this._addEdge({
+        }) : this.addEdge({
           source: id,
           target: node.id
         }));
       }
-      return node;
+      return this._constructNode(node);
     });
   }
   /**
   * Remove nodes from the graph.
   *
-  * @param ids The id of the node to remove.
+  * @param id 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) {
+  removeNode(id, edges = false) {
     untracked(() => {
       const node = this.findNode(id);
       if (!node) {
         return;
       }
       if (edges) {
+        delete this._edges[this.getEdgeKey(id, "outbound")];
+        delete this._edges[this.getEdgeKey(id, "inbound")];
         this._getNodes({
-          node,
-          onlyLoaded: true
-        }).forEach((node2) => {
-          this._removeEdge({
-            source: id,
-            target: node2.id
-          });
-        });
+          id
+        }).forEach((node2) => this.removeEdge({
+          source: id,
+          target: node2.id
+        }));
         this._getNodes({
-          node,
-          relation: "inbound",
-          onlyLoaded: true
-        }).forEach((node2) => {
-          this._removeEdge({
-            source: node2.id,
-            target: id
-          });
-        });
-        delete this._edges[id];
+          id,
+          direction: "inbound"
+        }).forEach((node2) => this.removeEdge({
+          source: node2.id,
+          target: id
+        }));
       }
       delete this._nodes[id];
-      this._onRemoveNode?.(id);
     });
   }
   /**
-  * Add edges to the graph.
-  *
-  * @internal
+  * Add an edge to the graph.
   */
-  _addEdges(edges) {
-    batch(() => edges.forEach((edge) => this._addEdge(edge)));
-  }
-  _addEdge({ source, target }) {
+  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 outbound = this._edges[this.getEdgeKey(source, "outbound")];
+      if (!outbound) {
+        this._edges[this.getEdgeKey(source, "outbound")] = [
+          target
+        ];
+      } else if (!outbound.includes(target)) {
+        outbound.push(target);
       }
-      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);
+      const inbound = this._edges[this.getEdgeKey(target, "inbound")];
+      if (!inbound) {
+        this._edges[this.getEdgeKey(target, "inbound")] = [
+          source
+        ];
+      } else if (!inbound.includes(source)) {
+        inbound.push(source);
       }
     });
   }
   /**
-  * Remove edges from the graph.
-  * @internal
-  */
-  _removeEdges(edges) {
-    batch(() => edges.forEach((edge) => this._removeEdge(edge)));
-  }
-  _removeEdge({ source, target }) {
-    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);
-        }
-      });
-    });
-  }
-  /**
   * 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 direction The direction of the edges from the node to sort.
   * @param edges The ordered list of edges.
-  * @ignore
   */
-  _sortEdges(nodeId, relation, edges) {
+  sortEdges(nodeId, direction, 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
-          ]);
-        }
-      });
+      const current = this._edges[this.getEdgeKey(nodeId, direction)];
+      if (current) {
+        const unsorted = current.filter((id) => !edges.includes(id)) ?? [];
+        const sorted = edges.filter((id) => current.includes(id)) ?? [];
+        current.splice(0, current.length, ...[
+          ...sorted,
+          ...unsorted
+        ]);
+      }
     });
   }
-  _getNodes({ node, relation = "outbound", type, onlyLoaded }) {
-    const key = `${node.id}-${relation}-${type}`;
-    const initialized = this._initialized[key];
-    if (!initialized && !onlyLoaded && this._onInitialNodes) {
-      const args = this._onInitialNodes(node, relation, type)?.filter((n) => !type || n.type === type);
-      this._initialized[key] = true;
-      if (args && args.length > 0) {
-        const nodes = this._addNodes(args);
-        this._addEdges(nodes.map(({ id }) => relation === "outbound" ? {
-          source: node.id,
-          target: id
-        } : {
-          source: id,
-          target: node.id
-        }));
+  /**
+  * Remove an edge from the graph.
+  */
+  removeEdge({ source, target }) {
+    untracked(() => {
+      const outboundIndex = this._edges[this.getEdgeKey(source, "outbound")]?.findIndex((id) => id === target);
+      if (outboundIndex !== -1) {
+        this._edges[this.getEdgeKey(source, "outbound")].splice(outboundIndex, 1);
       }
+      const inboundIndex = this._edges[this.getEdgeKey(target, "inbound")]?.findIndex((id) => id === source);
+      if (inboundIndex !== -1) {
+        this._edges[this.getEdgeKey(target, "inbound")].splice(inboundIndex, 1);
+      }
+    });
+  }
+  /**
+  * Recursive depth-first traversal.
+  *
+  * @param options.node The node to start traversing from.
+  * @param options.direction The direction to traverse graph edges.
+  * @param options.filter A predicate to filter nodes which are passed to the `visitor` callback.
+  * @param options.visitor A callback which is called for each node visited during traversal.
+  */
+  traverse({ node = this.root, direction = "outbound", filter, visitor }, path = []) {
+    if (path.includes(node.id)) {
+      return;
     }
-    const edges = this._edges[node.id];
-    if (!edges) {
-      return [];
-    } else {
-      return edges[relation].map((id) => this._nodes[id]).filter(nonNullable).filter((n) => !type || n.type === type);
+    if (!filter || filter(node)) {
+      visitor?.(node, [
+        ...path,
+        node.id
+      ]);
     }
+    Object.values(this._getNodes({
+      id: node.id,
+      direction
+    })).forEach((child) => this.traverse({
+      node: child,
+      direction,
+      filter,
+      visitor
+    }, [
+      ...path,
+      node.id
+    ]));
   }
-};
-
-// packages/sdk/app-graph/src/graph-builder.ts
-import { effect as effect2, signal } from "@preact/signals-core";
-import { create as create2 } from "@dxos/echo-schema";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { nonNullable as nonNullable2 } from "@dxos/util";
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/sdk/app-graph/src/graph-builder.ts";
-var createExtension = (extension) => {
-  const { id, resolver, connector, actions, actionGroups, ...rest } = extension;
-  const getId = (key) => `${id}/${key}`;
-  return [
-    resolver ? {
-      id: getId("resolver"),
-      resolver
-    } : void 0,
-    connector ? {
-      ...rest,
-      id: getId("connector"),
-      connector
-    } : void 0,
-    actionGroups ? {
-      ...rest,
-      id: getId("actionGroups"),
-      type: ACTION_GROUP_TYPE,
-      relation: "outbound",
-      connector: ({ node }) => actionGroups({
-        node
-      })?.map((arg) => ({
-        ...arg,
-        data: actionGroupSymbol,
-        type: ACTION_GROUP_TYPE
-      }))
-    } : void 0,
-    actions ? {
-      ...rest,
-      id: getId("actions"),
-      type: ACTION_TYPE,
-      relation: "outbound",
-      connector: ({ node }) => actions({
-        node
-      })?.map((arg) => ({
-        ...arg,
-        type: ACTION_TYPE
-      }))
-    } : void 0
-  ].filter(nonNullable2);
-};
-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: 129,
-    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
+  /**
+  * Get the path between two nodes in the graph.
+  */
+  getPath({ source = "root", target }) {
+    const start = this.findNode(source);
+    if (!start) {
+      return void 0;
     }
-  };
-  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: 144,
-      S: void 0,
-      A: [
-        "dispatcher",
-        "'cleanup must be called within an extension'"
-      ]
+    let found;
+    this.traverse({
+      node: start,
+      filter: () => !found,
+      visitor: (node, path) => {
+        if (node.id === target) {
+          found = path;
+        }
+      }
     });
-    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;
+    return found;
+  }
 };
+
+// packages/sdk/app-graph/src/graph-builder.ts
+import { EventSubscriptions } from "@dxos/async";
 var GraphBuilder = class {
   constructor() {
-    this._dispatcher = new Dispatcher();
-    this._extensions = create2({});
-    this._resolverSubscriptions = /* @__PURE__ */ new Map();
-    this._connectorSubscriptions = /* @__PURE__ */ new Map();
-    this._nodeChanged = {};
-    this._graph = new Graph({
-      onInitialNode: (id, type) => this._onInitialNode(id, type),
-      onInitialNodes: (node, relation, type) => this._onInitialNodes(node, relation, type),
-      onRemoveNode: (id) => this._onRemoveNode(id)
-    });
-  }
-  get graph() {
-    return this._graph;
+    this._extensions = /* @__PURE__ */ new Map();
+    this._unsubscribe = new EventSubscriptions();
   }
   /**
   * Register a node builder which will be called in order to construct the graph.
   */
-  addExtension(extension) {
-    if (Array.isArray(extension)) {
-      extension.forEach((ext) => this.addExtension(ext));
-      return this;
-    }
-    this._dispatcher.state[extension.id] = [];
-    this._extensions[extension.id] = extension;
+  addExtension(id, extension) {
+    this._extensions.set(id, extension);
     return this;
   }
   /**
   * Remove a node builder from the graph builder.
   */
   removeExtension(id) {
-    delete this._extensions[id];
+    this._extensions.delete(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();
-  }
   /**
-  * Traverse a graph using just the connector extensions, without subscribing to any signals or persisting any nodes.
+  * Construct the graph, starting by calling all registered extensions.
+  * @param previousGraph If provided, the graph will be updated in place.
   */
-  // TODO(wittjosiah): Rename? This is not traversing the graph proper.
-  async traverse({ node, relation = "outbound", visitor }, path = []) {
-    if (path.includes(node.id)) {
-      return;
-    }
-    visitor(node, [
-      ...path,
-      node.id
-    ]);
-    const nodes = Object.values(this._extensions).filter((extension) => relation === (extension.relation ?? "outbound")).flatMap((extension) => extension.connector?.({
-      node
-    }) ?? []).map((arg) => ({
-      id: arg.id,
-      type: arg.type,
-      data: arg.data ?? null,
-      properties: arg.properties ?? {}
-    }));
-    await Promise.all(nodes.map((n) => this.traverse({
-      node: n,
-      relation,
-      visitor
-    }, [
-      ...path,
-      node.id
-    ])));
-  }
-  _onInitialNode(nodeId, nodeType) {
-    this._nodeChanged[nodeId] = this._nodeChanged[nodeId] ?? signal({});
-    let initialized;
-    for (const { id, type, resolver } of Object.values(this._extensions)) {
-      if (!resolver || nodeType && type !== nodeType) {
-        continue;
-      }
-      const unsubscribe = effect2(() => {
-        this._dispatcher.currentExtension = id;
-        this._dispatcher.stateIndex = 0;
-        BuilderInternal.currentDispatcher = this._dispatcher;
-        const node = resolver({
-          id: nodeId
-        });
-        BuilderInternal.currentDispatcher = void 0;
-        if (node && initialized) {
-          this.graph._addNodes([
-            node
-          ]);
-          if (this._nodeChanged[initialized.id]) {
-            this._nodeChanged[initialized.id].value = {};
-          }
-        } else if (node) {
-          initialized = node;
-        }
-      });
-      if (initialized) {
-        this._resolverSubscriptions.set(nodeId, unsubscribe);
-        break;
-      } else {
-        unsubscribe();
-      }
-    }
-    return initialized;
-  }
-  _onInitialNodes(node, nodesRelation, nodesType) {
-    this._nodeChanged[node.id] = this._nodeChanged[node.id] ?? signal({});
-    let initialized;
-    let previous = [];
-    this._connectorSubscriptions.set(node.id, effect2(() => {
-      Object.keys(this._extensions);
-      this._nodeChanged[node.id].value;
-      const nodes = [];
-      for (const { id, connector, filter, type, relation = "outbound" } of Object.values(this._extensions)) {
-        if (!connector || relation !== nodesRelation || nodesType && type !== nodesType || filter && !filter(node)) {
-          continue;
-        }
-        this._dispatcher.currentExtension = id;
-        this._dispatcher.stateIndex = 0;
-        BuilderInternal.currentDispatcher = this._dispatcher;
-        nodes.push(...connector({
-          node
-        }) ?? []);
-        BuilderInternal.currentDispatcher = void 0;
-      }
-      const ids = nodes.map((n) => n.id);
-      const removed = previous.filter((id) => !ids.includes(id));
-      previous = ids;
-      if (initialized) {
-        this.graph._removeNodes(removed, true);
-        this.graph._addNodes(nodes);
-        this.graph._addEdges(nodes.map(({ id }) => ({
-          source: node.id,
-          target: id
-        })));
-        this.graph._sortEdges(node.id, "outbound", nodes.map(({ id }) => id));
-        nodes.forEach((n) => {
-          if (this._nodeChanged[n.id]) {
-            this._nodeChanged[n.id].value = {};
-          }
-        });
-      } else {
-        initialized = nodes;
-      }
-    }));
-    return initialized;
+  build(previousGraph) {
+    this._unsubscribe.clear();
+    const graph = previousGraph ?? new Graph();
+    Array.from(this._extensions.values()).forEach((builder) => {
+      const unsubscribe = builder(graph);
+      unsubscribe && this._unsubscribe.add(unsubscribe);
+    });
+    return graph;
   }
-  _onRemoveNode(nodeId) {
-    this._resolverSubscriptions.get(nodeId)?.();
-    this._connectorSubscriptions.get(nodeId)?.();
-    this._resolverSubscriptions.delete(nodeId);
-    this._connectorSubscriptions.delete(nodeId);
+};
+
+// packages/sdk/app-graph/src/helpers.ts
+var manageNodes = ({ graph, condition, nodes, removeEdges }) => {
+  if (condition) {
+    return graph.addNodes(...nodes);
+  } else {
+    nodes.forEach(({ id }) => graph.removeNode(id, removeEdges));
   }
 };
 export {
-  ACTION_GROUP_TYPE,
-  ACTION_TYPE,
   Graph,
   GraphBuilder,
   ROOT_ID,
-  ROOT_TYPE,
   actionGroupSymbol,
-  cleanup,
-  createExtension,
-  getGraph,
   isAction,
   isActionGroup,
   isActionLike,
   isGraphNode,
-  memoize,
-  toSignal
+  manageNodes
 };
 //# sourceMappingURL=index.mjs.map