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

package/dist/lib/node/index.cjs

@@ -35,6 +35,7 @@ __export(node_exports, {
   ROOT_ID: () => ROOT_ID,
   ROOT_TYPE: () => ROOT_TYPE,
   actionGroupSymbol: () => actionGroupSymbol,
+  cleanup: () => cleanup,
   createExtension: () => createExtension,
   flattenExtensions: () => flattenExtensions,
   getGraph: () => getGraph,
@@ -42,29 +43,34 @@ __export(node_exports, {
   isActionGroup: () => isActionGroup,
   isActionLike: () => isActionLike,
   isGraphNode: () => isGraphNode,
-  rxFromObservable: () => rxFromObservable,
-  rxFromSignal: () => rxFromSignal
+  memoize: () => memoize,
+  toSignal: () => toSignal
 });
 module.exports = __toCommonJS(node_exports);
-var import_rx_react = require("@effect-rx/rx-react");
-var import_effect = require("effect");
+var import_signals_core = require("@preact/signals-core");
 var import_async = require("@dxos/async");
-var import_debug = require("@dxos/debug");
 var import_invariant = require("@dxos/invariant");
+var import_live_object = require("@dxos/live-object");
 var import_log = require("@dxos/log");
 var import_util = require("@dxos/util");
-var import_rx_react2 = require("@effect-rx/rx-react");
-var import_signals_core = require("@preact/signals-core");
-var import_effect2 = require("effect");
+var import_signals_core2 = require("@preact/signals-core");
+var import_async2 = require("@dxos/async");
+var import_invariant2 = require("@dxos/invariant");
+var import_live_object2 = require("@dxos/live-object");
 var import_log2 = require("@dxos/log");
 var import_util2 = require("@dxos/util");
+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);
 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];
   (0, import_invariant.invariant)(graph, "Node is not associated with a graph.", {
     F: __dxlog_file,
-    L: 25,
+    L: 21,
     S: void 0,
     A: [
       "graph",
@@ -77,484 +83,637 @@ 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 import_async.Event();
-    this._expanded = import_effect.Record.empty();
-    this._initialized = import_effect.Record.empty();
-    this._initialEdges = import_effect.Record.empty();
-    this._initialNodes = import_effect.Record.fromEntries([
-      [
-        ROOT_ID,
-        this._constructNode({
-          id: ROOT_ID,
-          type: ROOT_TYPE,
-          data: null,
-          properties: {}
-        })
-      ]
-    ]);
-    this._node = import_rx_react.Rx.family((id) => {
-      const initial = import_effect.Option.flatten(import_effect.Record.get(this._initialNodes, id));
-      return import_rx_react.Rx.make(initial).pipe(import_rx_react.Rx.keepAlive, import_rx_react.Rx.withLabel(`graph:node:${id}`));
-    });
-    this._nodeOrThrow = import_rx_react.Rx.family((id) => {
-      return import_rx_react.Rx.make((get) => {
-        const node = get(this._node(id));
-        (0, import_invariant.invariant)(import_effect.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) => (0, import_signals_core.untracked)(() => !isActionLike(node));
+var Graph = class _Graph {
+  constructor({ nodes, edges, onInitialNode, onInitialNodes, onRemoveNode } = {}) {
+    this._waitingForNodes = {};
+    this._initialized = {};
+    this._nodes = {};
+    this._edges = {};
+    this._constructNode = (node) => {
+      return (0, import_live_object.create)({
+        ...node,
+        [graphSymbol]: this
       });
-    });
-    this._edges = import_rx_react.Rx.family((id) => {
-      const initial = import_effect.Record.get(this._initialEdges, id).pipe(import_effect.Option.getOrElse(() => ({
-        inbound: [],
-        outbound: []
-      })));
-      return import_rx_react.Rx.make(initial).pipe(import_rx_react.Rx.keepAlive, import_rx_react.Rx.withLabel(`graph:edges:${id}`));
-    });
-    this._connections = import_rx_react.Rx.family((key) => {
-      return import_rx_react.Rx.make((get) => {
-        const [id, relation] = key.split("$");
-        const edges2 = get(this._edges(id));
-        return edges2[relation].map((id2) => get(this._node(id2))).filter(import_effect.Option.isSome).map((o) => o.value);
-      }).pipe(import_rx_react.Rx.withLabel(`graph:connections:${key}`));
-    });
-    this._actions = import_rx_react.Rx.family((id) => {
-      return import_rx_react.Rx.make((get) => {
-        return get(this._connections(`${id}$outbound`)).filter((node) => node.type === ACTION_TYPE || node.type === ACTION_GROUP_TYPE);
-      }).pipe(import_rx_react.Rx.withLabel(`graph:actions:${id}`));
-    });
-    this._json = import_rx_react.Rx.family((id) => {
-      return import_rx_react.Rx.make((get) => {
-        const toJSON = (node, seen = []) => {
-          const nodes2 = 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 (nodes2.length) {
-            obj.nodes = nodes2.map((n) => {
-              const nextSeen = [
-                ...seen,
-                node.id
-              ];
-              return nextSeen.includes(n.id) ? void 0 : toJSON(n, nextSeen);
-            }).filter(import_util.isNonNullable);
-          }
-          return obj;
-        };
-        const root = get(this.nodeOrThrow(id));
-        return toJSON(root);
-      }).pipe(import_rx_react.Rx.withLabel(`graph:json:${id}`));
-    });
-    this._registry = registry ?? import_rx_react.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) => {
-        import_effect.Record.set(this._initialNodes, node.id, this._constructNode(node));
+        const cacheable = Object.keys(node.properties ?? {});
+        if (node.type === ACTION_TYPE) {
+          this._addNode({
+            cacheable,
+            data: () => import_log.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] = (0, import_live_object.create)({
+      inbound: [],
+      outbound: []
+    });
     if (edges) {
       Object.entries(edges).forEach(([source, edges2]) => {
-        import_effect.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 = import_effect.Record.get(this._expanded, key).pipe(import_effect.Option.getOrElse(() => false));
-    (0, import_log.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(import_util.isNonNullable);
+      }
+      return obj;
+    };
+    const root = this.findNode(id);
+    (0, import_invariant.invariant)(root, `Node not found: ${id}`, {
       F: __dxlog_file,
-      L: 395,
+      L: 171,
       S: this,
-      C: (f, a) => f(...a)
-    });
-    if (!expanded) {
-      this._onExpand?.(id, relation);
-      import_effect.Record.set(this._expanded, key, true);
-    }
-  }
-  addNodes(nodes) {
-    import_rx_react.Rx.batch(() => {
-      nodes.map((node) => this.addNode(node));
-    });
-  }
-  addNode({ nodes, edges, ...nodeArg }) {
-    const { id, type, data = null, properties = {} } = nodeArg;
-    const nodeRx = this._node(id);
-    const node = this._registry.get(nodeRx);
-    import_effect.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]);
-        (0, import_log.log)("existing node", {
-          typeChanged,
-          dataChanged,
-          propertiesChanged
-        }, {
-          F: __dxlog_file,
-          L: 417,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (typeChanged || dataChanged || propertiesChanged) {
-          (0, import_log.log)("updating node", {
-            id,
-            type,
-            data,
-            properties
-          }, {
-            F: __dxlog_file,
-            L: 419,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          const newNode = import_effect.Option.some({
-            ...node2,
-            type,
-            data,
-            properties: {
-              ...node2.properties,
-              ...properties
-            }
-          });
-          this._registry.set(nodeRx, newNode);
-          this.onNodeChanged.emit({
-            id,
-            node: newNode
-          });
-        }
-      },
-      onNone: () => {
-        (0, import_log.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
-        });
-      }
+      A: [
+        "root",
+        "`Node not found: ${id}`"
+      ]
     });
-    if (nodes) {
-      this.addNodes(nodes);
-      const _edges = nodes.map((node2) => ({
-        source: id,
-        target: node2.id
-      }));
-      this.addEdges(_edges);
-    }
-    if (edges) {
-      (0, import_debug.todo)();
-    }
-  }
-  removeNodes(ids, edges = false) {
-    import_rx_react.Rx.batch(() => {
-      ids.map((id) => this.removeNode(id, edges));
+    return toJSON(root);
+  }
+  pickle() {
+    const nodes = Object.values(this._nodes).filter((node) => !!node.cacheable).map((node) => {
+      return {
+        id: node.id,
+        type: node.type,
+        properties: (0, import_util.pick)(node.properties, node.cacheable)
+      };
     });
-  }
-  removeNode(id, edges = false) {
-    const nodeRx = this._node(id);
-    this._registry.set(nodeRx, import_effect.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: import_effect.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) {
-    import_rx_react.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)) {
-      (0, import_log.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)) {
-      (0, import_log.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 import_async.Trigger());
+    const node = this.findNode(id);
+    if (node) {
+      delete this._waitingForNodes[id];
+      return node;
+    }
+    if (timeout === void 0) {
+      return trigger.wait();
+    } else {
+      return (0, import_async.asyncTimeout)(trigger.wait(), timeout, `Node not found: ${id}`);
     }
   }
-  removeEdges(edges, removeOrphans = false) {
-    import_rx_react.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 (0, import_signals_core.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 (0, import_effect.pipe)(this.getNode(source), import_effect.Option.flatMap((node) => {
-      let found = import_effect.Option.none();
-      this.traverse({
-        source: node.id,
-        visitor: (node2, path) => {
-          if (import_effect.Option.isSome(found)) {
-            return false;
-          }
-          if (node2.id === target) {
-            found = import_effect.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 (import_effect.Option.isSome(path)) {
-      return path.value;
+    if (path) {
+      return path;
     }
     const trigger = new import_async.Trigger();
     const i = setInterval(() => {
       const path2 = this.getPath(params);
-      if (import_effect.Option.isSome(path2)) {
-        trigger.wake(path2.value);
+      if (path2) {
+        trigger.wake(path2);
       }
     }, interval);
     return trigger.wait({
       timeout
     }).finally(() => clearInterval(i));
   }
-  /** @internal */
-  _constructNode(node) {
-    return import_effect.Option.some({
-      [graphSymbol]: this,
-      data: null,
-      properties: {},
-      ...node
+  /**
+  * Add nodes to the graph.
+  *
+  * @internal
+  */
+  _addNodes(nodes) {
+    return (0, import_signals_core.batch)(() => nodes.map((node) => this._addNode(node)));
+  }
+  _addNode({ nodes, edges, ..._node }) {
+    return (0, import_signals_core.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] = (0, import_live_object.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) {
+    (0, import_signals_core.batch)(() => ids.forEach((id) => this._removeNode(id, edges)));
+  }
+  _removeNode(id, edges = false) {
+    (0, import_signals_core.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) {
+    (0, import_signals_core.batch)(() => edges.forEach((edge) => this._addEdge(edge)));
+  }
+  _addEdge({ source, target }) {
+    (0, import_signals_core.untracked)(() => {
+      if (!this._edges[source]) {
+        this._edges[source] = (0, import_live_object.create)({
+          inbound: [],
+          outbound: []
+        });
+      }
+      if (!this._edges[target]) {
+        this._edges[target] = (0, import_live_object.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) {
+    (0, import_signals_core.batch)(() => edges.forEach((edge) => this._removeEdge(edge, removeOrphans)));
+  }
+  _removeEdge({ source, target }, removeOrphans = false) {
+    (0, import_signals_core.untracked)(() => {
+      (0, import_signals_core.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) {
+    (0, import_signals_core.untracked)(() => {
+      (0, import_signals_core.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(import_util.isNonNullable).filter((n) => !type || n.type === type);
+    }
+  }
 };
-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);
 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 && import_rx_react2.Rx.family((node) => _actionGroups(node).pipe(import_rx_react2.Rx.withLabel(`graph-builder:actionGroups:${id}`)));
-  const actions = _actions && import_rx_react2.Rx.family((node) => _actions(node).pipe(import_rx_react2.Rx.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: import_rx_react2.Rx.family((key) => connector(key).pipe(import_rx_react2.Rx.withLabel(`graph-builder:connector:${id}`)))
+      connector
     } : void 0,
     actionGroups ? {
+      ...rest,
       id: getId("actionGroups"),
       position,
+      type: ACTION_GROUP_TYPE,
       relation: "outbound",
-      connector: import_rx_react2.Rx.family((node) => import_rx_react2.Rx.make((get) => get(actionGroups(node)).map((arg) => ({
+      connector: ({ node }) => actionGroups({
+        node
+      })?.map((arg) => ({
         ...arg,
         data: actionGroupSymbol,
         type: ACTION_GROUP_TYPE
-      }))).pipe(import_rx_react2.Rx.withLabel(`graph-builder:connector:actionGroups:${id}`)))
+      }))
     } : void 0,
     actions ? {
+      ...rest,
       id: getId("actions"),
       position,
+      type: ACTION_TYPE,
       relation: "outbound",
-      connector: import_rx_react2.Rx.family((node) => import_rx_react2.Rx.make((get) => get(actions(node)).map((arg) => ({
+      connector: ({ node }) => actions({
+        node
+      })?.map((arg) => ({
         ...arg,
         type: ACTION_TYPE
-      }))).pipe(import_rx_react2.Rx.withLabel(`graph-builder:connector:actions:${id}`)))
+      }))
     } : void 0
   ].filter(import_util2.isNonNullable);
 };
+var Dispatcher = class {
+  constructor() {
+    this.stateIndex = 0;
+    this.state = {};
+    this.cleanup = [];
+  }
+};
+var BuilderInternal = class {
+};
+var memoize = (fn, key = "result") => {
+  const dispatcher = BuilderInternal.currentDispatcher;
+  (0, import_invariant2.invariant)(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;
+    (0, import_invariant2.invariant)(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 (0, import_signals_core2.signal)(get());
+  }, key);
+  const unsubscribe = memoize(() => {
+    return subscribe(() => thisSignal.value = get());
+  }, key);
+  cleanup(() => {
+    unsubscribe();
+  });
+  return thisSignal.value;
+};
 var flattenExtensions = (extension, acc = []) => {
-  if (import_effect2.Array.isArray(extension)) {
+  if (Array.isArray(extension)) {
     return [
       ...acc,
       ...extension.flatMap((ext) => flattenExtensions(ext, acc))
@@ -567,74 +726,107 @@ var flattenExtensions = (extension, acc = []) => {
   }
 };
 var GraphBuilder = class _GraphBuilder {
-  constructor({ registry, ...params } = {}) {
+  constructor(params = {}) {
+    this._dispatcher = new Dispatcher();
+    this._extensions = (0, import_live_object2.create)({});
+    this._resolverSubscriptions = /* @__PURE__ */ new Map();
     this._connectorSubscriptions = /* @__PURE__ */ new Map();
-    this._extensions = import_rx_react2.Rx.make(import_effect2.Record.empty()).pipe(import_rx_react2.Rx.keepAlive, import_rx_react2.Rx.withLabel("graph-builder:extensions"));
-    this._connectors = import_rx_react2.Rx.family((key) => {
-      return import_rx_react2.Rx.make((get) => {
-        const [id, relation] = key.split("+");
-        const node = this._graph.node(id);
-        return (0, import_effect2.pipe)(
-          get(this._extensions),
-          import_effect2.Record.values,
-          // TODO(wittjosiah): Sort on write rather than read.
-          import_effect2.Array.sortBy(import_util2.byPosition),
-          import_effect2.Array.filter(({ relation: _relation = "outbound" }) => _relation === relation),
-          import_effect2.Array.map(({ connector }) => connector?.(node)),
-          import_effect2.Array.filter(import_util2.isNonNullable),
-          import_effect2.Array.flatMap((result) => get(result))
-        );
-      }).pipe(import_rx_react2.Rx.withLabel(`graph-builder:connectors:${key}`));
-    });
-    this._registry = registry ?? import_rx_react2.Registry.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 import_async2.Trigger());
+    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 {
+        import_log2.log.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, import_effect2.Record.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);
+    (0, import_signals_core2.untracked)(() => {
+      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, import_effect2.Record.remove(extensions, id));
+    (0, import_signals_core2.untracked)(() => {
+      delete this._extensions[id];
+    });
     return this;
   }
-  async explore({ registry = import_rx_react2.Registry.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 (!(0, import_util2.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
@@ -642,104 +834,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(import_util2.isNonNullable).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) {
-    (0, import_log2.log)("onExpand", {
-      id,
+    await Promise.all(nodes.map((n) => this.explore({
+      node: n,
       relation,
-      registry: (0, import_util2.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] ?? (0, import_signals_core2.signal)({});
+    this._resolverSubscriptions.set(nodeId, (0, import_signals_core2.effect)(() => {
+      const extensions = Object.values(this._extensions).toSorted(import_util2.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) {
+          import_log2.log.catch(err, {
+            extension: id
+          }, {
+            F: __dxlog_file2,
+            L: 359,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          import_log2.log.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] ?? (0, import_signals_core2.signal)({});
+    let first = true;
     let previous = [];
-    const cancel = this._registry.subscribe(connectors, (nodes) => {
+    this._connectorSubscriptions.set(node.id, (0, import_signals_core2.effect)(() => {
+      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(import_util2.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) {
+          import_log2.log.catch(err, {
+            extension: id
+          }, {
+            F: __dxlog_file2,
+            L: 421,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          import_log2.log.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;
-      (0, import_log2.log)("update", {
-        id,
-        relation,
-        ids,
-        removed
-      }, {
-        F: __dxlog_file2,
-        L: 287,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      import_rx_react2.Rx.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 import_rx_react2.Rx.make((get) => {
-    const dispose = (0, import_signals_core.effect)(() => {
-      get.setSelf(cb());
-    });
-    get.addFinalizer(() => dispose());
-    return cb();
-  });
-};
-var observableFamily = import_rx_react2.Rx.family((observable) => {
-  return import_rx_react2.Rx.make((get) => {
-    const subscription = observable.subscribe((value) => get.setSelf(value));
-    get.addFinalizer(() => subscription.unsubscribe());
-    return observable.get();
-  });
-});
-var rxFromObservable = (observable) => {
-  return observableFamily(observable);
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACTION_GROUP_TYPE,
@@ -749,6 +995,7 @@ var rxFromObservable = (observable) => {
   ROOT_ID,
   ROOT_TYPE,
   actionGroupSymbol,
+  cleanup,
   createExtension,
   flattenExtensions,
   getGraph,
@@ -756,7 +1003,7 @@ var rxFromObservable = (observable) => {
   isActionGroup,
   isActionLike,
   isGraphNode,
-  rxFromObservable,
-  rxFromSignal
+  memoize,
+  toSignal
 });
 //# sourceMappingURL=index.cjs.map