@dxos/app-graph 0.8.4-main.c1de068 → 0.8.4-main.c85a9c8dae

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

@@ -1,20 +1,135 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/atoms.ts
+var atoms_exports = {};
+__export(atoms_exports, {
+  fromObservable: () => fromObservable
+});
+import { Atom } from "@effect-atom/atom-react";
+var observableFamily = Atom.family((observable) => {
+  return Atom.make((get2) => {
+    const subscription = observable.subscribe((value) => get2.setSelf(value));
+    get2.addFinalizer(() => subscription.unsubscribe());
+    return observable.get();
+  });
+});
+var fromObservable = (observable) => {
+  return observableFamily(observable);
+};
 
 // src/graph.ts
-import { Registry, Rx } from "@effect-rx/rx-react";
-import { Option, pipe, Record } from "effect";
+var graph_exports = {};
+__export(graph_exports, {
+  GraphKind: () => GraphKind,
+  GraphTypeId: () => GraphTypeId,
+  addEdge: () => addEdge,
+  addEdges: () => addEdges,
+  addNode: () => addNode,
+  addNodes: () => addNodes,
+  expand: () => expand,
+  getActions: () => getActions,
+  getConnections: () => getConnections,
+  getEdges: () => getEdges,
+  getGraph: () => getGraph,
+  getNode: () => getNode,
+  getNodeOrThrow: () => getNodeOrThrow,
+  getPath: () => getPath,
+  getRoot: () => getRoot,
+  initialize: () => initialize,
+  make: () => make,
+  relationFromKey: () => relationFromKey,
+  relationKey: () => relationKey,
+  removeEdge: () => removeEdge,
+  removeEdges: () => removeEdges,
+  removeNode: () => removeNode,
+  removeNodes: () => removeNodes,
+  sortEdges: () => sortEdges,
+  toJSON: () => toJSON,
+  traverse: () => traverse,
+  waitForPath: () => waitForPath
+});
+import { Atom as Atom2, Registry } from "@effect-atom/atom-react";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Pipeable from "effect/Pipeable";
+import * as Record from "effect/Record";
 import { Event, Trigger } from "@dxos/async";
 import { todo } from "@dxos/debug";
 import { invariant } from "@dxos/invariant";
 import { log } from "@dxos/log";
 import { isNonNullable } from "@dxos/util";
+
+// src/node.ts
+var node_exports = {};
+__export(node_exports, {
+  ActionGroupType: () => ActionGroupType,
+  ActionType: () => ActionType,
+  RootId: () => RootId,
+  RootType: () => RootType,
+  actionGroupSymbol: () => actionGroupSymbol,
+  actionRelation: () => actionRelation,
+  childRelation: () => childRelation,
+  isAction: () => isAction,
+  isActionGroup: () => isActionGroup,
+  isActionLike: () => isActionLike,
+  isGraphNode: () => isGraphNode,
+  relation: () => relation
+});
+var RootId = "root";
+var RootType = "dxos.org/type/GraphRoot";
+var ActionType = "dxos.org/type/GraphAction";
+var ActionGroupType = "dxos.org/type/GraphActionGroup";
+var relation = (kind, direction = "outbound") => ({
+  kind,
+  direction
+});
+var childRelation = (direction = "outbound") => relation("child", direction);
+var actionRelation = (direction = "outbound") => relation("action", direction);
+var isGraphNode = (data) => data && typeof data === "object" && "id" in data && "properties" in data && data.properties ? typeof data.properties === "object" && "data" in data : false;
+var isAction = (data) => isGraphNode(data) ? typeof data.data === "function" && data.type === ActionType : false;
+var actionGroupSymbol = /* @__PURE__ */ Symbol("ActionGroup");
+var isActionGroup = (data) => isGraphNode(data) ? data.data === actionGroupSymbol && data.type === ActionGroupType : false;
+var isActionLike = (data) => isAction(data) || isActionGroup(data);
+
+// src/util.ts
+var Separators = {
+  primary: "
",
+  secondary: ""
+};
+var normalizeRelation = (relation2) => relation2 == null ? childRelation() : typeof relation2 === "string" ? relation(relation2) : relation2;
+var shallowEqual = (a, b) => {
+  if (a === b) return true;
+  if (a == null || b == null || typeof a !== "object" || typeof b !== "object") return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  return keysA.every((k) => a[k] === b[k]);
+};
+var nodeArgsUnchanged = (prev, next) => {
+  if (prev.length !== next.length) {
+    return false;
+  }
+  return prev.every((prevNode, idx) => {
+    const nextNode = next[idx];
+    return prevNode.id === nextNode.id && prevNode.type === nextNode.type && shallowEqual(prevNode.data, nextNode.data) && shallowEqual(prevNode.properties, nextNode.properties);
+  });
+};
+
+// src/graph.ts
 var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-graph/src/graph.ts";
-var graphSymbol = Symbol("graph");
+var graphSymbol = /* @__PURE__ */ Symbol("graph");
 var getGraph = (node) => {
   const graph = node[graphSymbol];
   invariant(graph, "Node is not associated with a graph.", {
     F: __dxlog_file,
-    L: 25,
+    L: 33,
     S: void 0,
     A: [
       "graph",
@@ -23,95 +138,101 @@ var getGraph = (node) => {
   });
   return graph;
 };
-var ROOT_ID = "root";
-var ROOT_TYPE = "dxos.org/type/GraphRoot";
-var ACTION_TYPE = "dxos.org/type/GraphAction";
-var ACTION_GROUP_TYPE = "dxos.org/type/GraphActionGroup";
-var Graph = class {
-  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 GraphTypeId = /* @__PURE__ */ Symbol.for("@dxos/app-graph/Graph");
+var GraphKind = /* @__PURE__ */ Symbol.for("@dxos/app-graph/GraphKind");
+var GraphImpl = class {
+  [GraphTypeId] = GraphTypeId;
+  [GraphKind] = "writable";
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments);
+  }
+  onNodeChanged = new Event();
+  _onExpand;
+  _onInitialize;
+  _onRemoveNode;
+  _registry;
+  _expanded = Record.empty();
+  _pendingExpands = /* @__PURE__ */ new Set();
+  _initialized = Record.empty();
+  _initialEdges = Record.empty();
+  _initialNodes = Record.fromEntries([
+    [
+      RootId,
+      this._constructNode({
+        id: RootId,
+        type: RootType,
+        data: null,
+        properties: {}
+      })
+    ]
+  ]);
+  /** @internal */
+  _node = Atom2.family((id) => {
+    const initial = Option.flatten(Record.get(this._initialNodes, id));
+    return Atom2.make(initial).pipe(Atom2.keepAlive, Atom2.withLabel(`graph:node:${id}`));
+  });
+  _nodeOrThrow = Atom2.family((id) => {
+    return Atom2.make((get2) => {
+      const node = get2(this._node(id));
+      invariant(Option.isSome(node), `Node not available: ${id}`, {
+        F: __dxlog_file,
+        L: 172,
+        S: this,
+        A: [
+          "Option.isSome(node)",
+          "`Node not available: ${id}`"
+        ]
       });
+      return node.value;
     });
-    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;
+  });
+  _edges = Atom2.family((id) => {
+    const initial = Record.get(this._initialEdges, id).pipe(Option.getOrElse(() => ({})));
+    return Atom2.make(initial).pipe(Atom2.keepAlive, Atom2.withLabel(`graph:edges:${id}`));
+  });
+  // NOTE: Currently the argument to the family needs to be referentially stable for the atom to be referentially stable.
+  // TODO(wittjosiah): Atom feature request, support for something akin to `ComplexMap` to allow for complex arguments.
+  _connections = Atom2.family((key) => {
+    return Atom2.make((get2) => {
+      const { id, relation: relation2 } = relationFromConnectionKey(key);
+      const edges = get2(this._edges(id));
+      return (edges[relationKey(relation2)] ?? []).map((id2) => get2(this._node(id2))).filter(Option.isSome).map((o) => o.value);
+    }).pipe(Atom2.withLabel(`graph:connections:${key}`));
+  });
+  _actions = Atom2.family((id) => {
+    return Atom2.make((get2) => {
+      return get2(this._connections(connectionKey(id, actionRelation())));
+    }).pipe(Atom2.withLabel(`graph:actions:${id}`));
+  });
+  _json = Atom2.family((id) => {
+    return Atom2.make((get2) => {
+      const toJSON2 = (node, seen = []) => {
+        const nodes = get2(this._connections(connectionKey(node.id, "child")));
+        const obj = {
+          id: node.id,
+          type: node.type
         };
-        const root = get(this.nodeOrThrow(id));
-        return toJSON(root);
-      }).pipe(Rx.withLabel(`graph:json:${id}`));
-    });
+        if (node.properties.label) {
+          obj.label = node.properties.label;
+        }
+        if (nodes.length) {
+          obj.nodes = nodes.map((n) => {
+            const nextSeen = [
+              ...seen,
+              node.id
+            ];
+            return nextSeen.includes(n.id) ? void 0 : toJSON2(n, nextSeen);
+          }).filter(isNonNullable);
+        }
+        return obj;
+      };
+      const root = get2(this._nodeOrThrow(id));
+      return toJSON2(root);
+    }).pipe(Atom2.withLabel(`graph:json:${id}`));
+  });
+  constructor({ registry, nodes, edges, onInitialize, onExpand, onRemoveNode } = {}) {
     this._registry = registry ?? Registry.make();
+    this._onInitialize = onInitialize;
     this._onExpand = onExpand;
     this._onRemoveNode = onRemoveNode;
     if (nodes) {
@@ -125,447 +246,1262 @@ var Graph = class {
       });
     }
   }
-  toJSON(id = ROOT_ID) {
-    return this._registry.get(this._json(id));
-  }
-  json(id = ROOT_ID) {
-    return this._json(id);
+  json(id = RootId) {
+    return jsonImpl(this, id);
   }
   node(id) {
-    return this._node(id);
+    return nodeImpl(this, id);
   }
   nodeOrThrow(id) {
-    return this._nodeOrThrow(id);
+    return nodeOrThrowImpl(this, id);
   }
-  connections(id, relation = "outbound") {
-    return this._connections(`${id}$${relation}`);
+  connections(id, relation2) {
+    return connectionsImpl(this, id, relation2);
   }
   actions(id) {
-    return this._actions(id);
+    return actionsImpl(this, id);
   }
   edges(id) {
-    return this._edges(id);
-  }
-  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));
+    return edgesImpl(this, id);
+  }
+  /** @internal */
+  _constructNode(node) {
+    return Option.some({
+      [graphSymbol]: this,
+      data: null,
+      properties: {},
+      ...node
+    });
+  }
+};
+var getInternal = (graph) => {
+  return graph;
+};
+var toJSON = (graph, id = RootId) => {
+  const internal = getInternal(graph);
+  return internal._registry.get(internal._json(id));
+};
+var jsonImpl = (graph, id = RootId) => {
+  const internal = getInternal(graph);
+  return internal._json(id);
+};
+var nodeImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._node(id);
+};
+var nodeOrThrowImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._nodeOrThrow(id);
+};
+var connectionsImpl = (graph, id, relation2) => {
+  const internal = getInternal(graph);
+  return internal._connections(connectionKey(id, relation2));
+};
+var actionsImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._actions(id);
+};
+var edgesImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._edges(id);
+};
+var getNodeImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._registry.get(nodeImpl(graph, id));
+};
+function getNode(graphOrId, id) {
+  if (typeof graphOrId === "string") {
+    const id2 = graphOrId;
+    return (graph) => getNodeImpl(graph, id2);
+  } else {
+    const graph = graphOrId;
+    return getNodeImpl(graph, id);
+  }
+}
+var getNodeOrThrowImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._registry.get(nodeOrThrowImpl(graph, id));
+};
+function getNodeOrThrow(graphOrId, id) {
+  if (typeof graphOrId === "string") {
+    const id2 = graphOrId;
+    return (graph) => getNodeOrThrowImpl(graph, id2);
+  } else {
+    const graph = graphOrId;
+    return getNodeOrThrowImpl(graph, id);
+  }
+}
+function getRoot(graph) {
+  return getNodeOrThrowImpl(graph, RootId);
+}
+var getConnectionsImpl = (graph, id, relation2) => {
+  const internal = getInternal(graph);
+  return internal._registry.get(connectionsImpl(graph, id, relation2));
+};
+function getConnections(graphOrId, idOrRelation, relation2) {
+  if (typeof graphOrId === "string") {
+    const id = graphOrId;
+    const rel = idOrRelation;
+    return (graph) => getConnectionsImpl(graph, id, rel);
+  } else {
+    const graph = graphOrId;
+    const id = idOrRelation;
+    invariant(relation2 !== void 0, "Relation is required.", {
+      F: __dxlog_file,
+      L: 440,
+      S: this,
+      A: [
+        "relation !== undefined",
+        "'Relation is required.'"
+      ]
+    });
+    const rel = relation2;
+    return getConnectionsImpl(graph, id, rel);
+  }
+}
+var getActionsImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._registry.get(actionsImpl(graph, id));
+};
+function getActions(graphOrId, id) {
+  if (typeof graphOrId === "string") {
+    const id2 = graphOrId;
+    return (graph) => getActionsImpl(graph, id2);
+  } else {
+    const graph = graphOrId;
+    return getActionsImpl(graph, id);
+  }
+}
+var getEdgesImpl = (graph, id) => {
+  const internal = getInternal(graph);
+  return internal._registry.get(edgesImpl(graph, id));
+};
+function getEdges(graphOrId, id) {
+  if (typeof graphOrId === "string") {
+    const id2 = graphOrId;
+    return (graph) => getEdgesImpl(graph, id2);
+  } else {
+    const graph = graphOrId;
+    return getEdgesImpl(graph, id);
+  }
+}
+var traverseImpl = (graph, options, path = []) => {
+  const { visitor, source = RootId, relation: relation2 } = options;
+  if (path.includes(source)) {
+    return;
+  }
+  const node = getNodeOrThrow(graph, source);
+  const shouldContinue = visitor(node, [
+    ...path,
+    source
+  ]);
+  if (shouldContinue === false) {
+    return;
+  }
+  Object.values(getConnections(graph, source, relation2)).forEach((child) => traverseImpl(graph, {
+    source: child.id,
+    relation: relation2,
+    visitor
+  }, [
+    ...path,
+    source
+  ]));
+};
+function traverse(graphOrOptions, optionsOrPath, path) {
+  if (typeof graphOrOptions === "object" && "visitor" in graphOrOptions) {
+    const options = graphOrOptions;
+    const pathArg = Array.isArray(optionsOrPath) ? optionsOrPath : void 0;
+    return (graph) => traverseImpl(graph, options, pathArg);
+  } else {
+    const graph = graphOrOptions;
+    const options = optionsOrPath;
+    const pathArg = path ?? (Array.isArray(optionsOrPath) ? optionsOrPath : void 0);
+    return traverseImpl(graph, options, pathArg);
+  }
+}
+var getPathImpl = (graph, params) => {
+  return Function.pipe(getNode(graph, params.source ?? "root"), Option.flatMap((node) => {
+    let found = Option.none();
+    traverseImpl(graph, {
+      source: node.id,
+      relation: "child",
+      visitor: (node2, path) => {
+        if (Option.isSome(found)) {
+          return false;
+        }
+        if (node2.id === params.target) {
+          found = Option.some(path);
+        }
+      }
+    });
+    return found;
+  }));
+};
+function getPath(graphOrParams, params) {
+  if (params === void 0 && typeof graphOrParams === "object" && "target" in graphOrParams) {
+    const params2 = graphOrParams;
+    return (graph) => getPathImpl(graph, params2);
+  } else {
+    const graph = graphOrParams;
+    return getPathImpl(graph, params);
+  }
+}
+var waitForPathImpl = (graph, params, options) => {
+  const { timeout = 5e3, interval = 500 } = options ?? {};
+  const path = getPathImpl(graph, params);
+  if (Option.isSome(path)) {
+    return Promise.resolve(path.value);
+  }
+  const trigger = new Trigger();
+  const i = setInterval(() => {
+    const path2 = getPathImpl(graph, params);
+    if (Option.isSome(path2)) {
+      trigger.wake(path2.value);
+    }
+  }, interval);
+  return trigger.wait({
+    timeout
+  }).finally(() => clearInterval(i));
+};
+function waitForPath(graphOrParams, paramsOrOptions, options) {
+  if (typeof graphOrParams === "object" && "target" in graphOrParams) {
+    const params = graphOrParams;
+    const opts = typeof paramsOrOptions === "object" && !("target" in paramsOrOptions) ? paramsOrOptions : void 0;
+    return (graph) => waitForPathImpl(graph, params, opts);
+  } else {
+    const graph = graphOrParams;
+    const params = paramsOrOptions;
+    return waitForPathImpl(graph, params, options);
+  }
+}
+var initializeImpl = async (graph, id) => {
+  const internal = getInternal(graph);
+  const initialized = Record.get(internal._initialized, id).pipe(Option.getOrElse(() => false));
+  log("initialize", {
+    id,
+    initialized
+  }, {
+    F: __dxlog_file,
+    L: 655,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  if (!initialized) {
+    Record.set(internal._initialized, id, true);
+    await internal._onInitialize?.(id);
+  }
+  return graph;
+};
+function initialize(graphOrId, id) {
+  if (typeof graphOrId === "string") {
+    const id2 = graphOrId;
+    return (graph) => initializeImpl(graph, id2);
+  } else {
+    const graph = graphOrId;
+    return initializeImpl(graph, id);
+  }
+}
+var expandImpl = (graph, id, relation2) => {
+  const internal = getInternal(graph);
+  const normalizedRelation = normalizeRelation(relation2);
+  const key = `${id}${Separators.primary}${relationKey(normalizedRelation)}`;
+  const nodeOpt = internal._registry.get(internal._node(id));
+  if (Option.isNone(nodeOpt)) {
+    internal._pendingExpands.add(key);
     log("expand", {
       key,
-      expanded
+      deferred: true
     }, {
       F: __dxlog_file,
-      L: 395,
-      S: this,
+      L: 701,
+      S: void 0,
       C: (f, a) => f(...a)
     });
-    if (!expanded) {
-      this._onExpand?.(id, relation);
-      Record.set(this._expanded, key, true);
-    }
+    return graph;
   }
-  addNodes(nodes) {
-    Rx.batch(() => {
-      nodes.map((node) => this.addNode(node));
+  const expanded = Record.get(internal._expanded, key).pipe(Option.getOrElse(() => false));
+  log("expand", {
+    key,
+    expanded
+  }, {
+    F: __dxlog_file,
+    L: 706,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  if (!expanded) {
+    Record.set(internal._expanded, key, true);
+    internal._onExpand?.(id, normalizedRelation);
+  }
+  return graph;
+};
+function expand(graphOrId, idOrRelation, relation2) {
+  if (typeof graphOrId === "string") {
+    const id = graphOrId;
+    const rel = idOrRelation;
+    return (graph) => expandImpl(graph, id, rel);
+  } else {
+    const graph = graphOrId;
+    const id = idOrRelation;
+    invariant(relation2 !== void 0, "Relation is required.", {
+      F: __dxlog_file,
+      L: 742,
+      S: this,
+      A: [
+        "relation !== undefined",
+        "'Relation is required.'"
+      ]
     });
+    const rel = relation2;
+    return expandImpl(graph, id, rel);
   }
-  addNode({ nodes, edges, ...nodeArg }) {
-    const { id, type, data = null, properties = {} } = nodeArg;
-    const nodeRx = this._node(id);
-    const node = this._registry.get(nodeRx);
-    Option.match(node, {
-      onSome: (node2) => {
-        const typeChanged = node2.type !== type;
-        const dataChanged = node2.data !== data;
-        const propertiesChanged = Object.keys(properties).some((key) => node2.properties[key] !== properties[key]);
-        log("existing node", {
-          id,
-          typeChanged,
-          dataChanged,
-          propertiesChanged
-        }, {
-          F: __dxlog_file,
-          L: 417,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (typeChanged || dataChanged || propertiesChanged) {
-          log("updating node", {
-            id,
-            type,
-            data,
-            properties
-          }, {
-            F: __dxlog_file,
-            L: 419,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          const newNode = Option.some({
-            ...node2,
-            type,
-            data,
-            properties: {
-              ...node2.properties,
-              ...properties
-            }
-          });
-          this._registry.set(nodeRx, newNode);
-          this.onNodeChanged.emit({
-            id,
-            node: newNode
-          });
-        }
-      },
-      onNone: () => {
-        log("new node", {
+}
+var sortEdgesImpl = (graph, id, relation2, order) => {
+  const internal = getInternal(graph);
+  const edgesAtom = internal._edges(id);
+  const edges = internal._registry.get(edgesAtom);
+  const relationId = relationKey(relation2);
+  const current = edges[relationId] ?? [];
+  const unsorted = current.filter((id2) => !order.includes(id2));
+  const sorted = order.filter((id2) => current.includes(id2));
+  const newOrder = [
+    ...sorted,
+    ...unsorted
+  ];
+  if (newOrder.length === current.length && newOrder.every((id2, i) => id2 === current[i])) {
+    return graph;
+  }
+  internal._registry.set(edgesAtom, {
+    ...edges,
+    [relationId]: newOrder
+  });
+  return graph;
+};
+function sortEdges(graphOrId, idOrRelation, relationOrOrder, order) {
+  if (typeof graphOrId === "string") {
+    const id = graphOrId;
+    const relation2 = idOrRelation;
+    const order2 = relationOrOrder;
+    return (graph) => sortEdgesImpl(graph, id, relation2, order2);
+  } else {
+    const graph = graphOrId;
+    const id = idOrRelation;
+    const relation2 = relationOrOrder;
+    return sortEdgesImpl(graph, id, relation2, order);
+  }
+}
+var addNodesImpl = (graph, nodes) => {
+  Atom2.batch(() => {
+    nodes.map((node) => addNodeImpl(graph, node));
+  });
+  return graph;
+};
+function addNodes(graphOrNodes, nodes) {
+  if (nodes === void 0) {
+    const nodes2 = graphOrNodes;
+    return (graph) => addNodesImpl(graph, nodes2);
+  } else {
+    const graph = graphOrNodes;
+    return addNodesImpl(graph, nodes);
+  }
+}
+var addNodeImpl = (graph, nodeArg) => {
+  const internal = getInternal(graph);
+  const { nodes, edges, id, type, data = null, properties = {}, ...rest } = nodeArg;
+  const nodeAtom = internal._node(id);
+  const existingNode = internal._registry.get(nodeAtom);
+  Option.match(existingNode, {
+    onSome: (existing) => {
+      const typeChanged = existing.type !== type;
+      const dataChanged = !shallowEqual(existing.data, data);
+      const propertiesChanged = Object.keys(properties).some((key) => existing.properties[key] !== properties[key]);
+      log("existing node", {
+        id,
+        typeChanged,
+        dataChanged,
+        propertiesChanged
+      }, {
+        F: __dxlog_file,
+        L: 864,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      if (typeChanged || dataChanged || propertiesChanged) {
+        log("updating node", {
           id,
           type,
           data,
           properties
         }, {
           F: __dxlog_file,
-          L: 426,
-          S: this,
+          L: 871,
+          S: void 0,
           C: (f, a) => f(...a)
         });
-        const newNode = this._constructNode({
-          id,
+        const newNode = Option.some({
+          ...existing,
+          ...rest,
           type,
           data,
-          properties
+          properties: {
+            ...existing.properties,
+            ...properties
+          }
         });
-        this._registry.set(nodeRx, newNode);
-        this.onNodeChanged.emit({
+        internal._registry.set(nodeAtom, newNode);
+        graph.onNodeChanged.emit({
           id,
           node: newNode
         });
       }
-    });
-    if (nodes) {
-      this.addNodes(nodes);
-      const _edges = nodes.map((node2) => ({
-        source: id,
-        target: node2.id
-      }));
-      this.addEdges(_edges);
+    },
+    onNone: () => {
+      log("new node", {
+        id,
+        type,
+        data,
+        properties
+      }, {
+        F: __dxlog_file,
+        L: 884,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      const newNode = internal._constructNode({
+        id,
+        type,
+        data,
+        properties,
+        ...rest
+      });
+      internal._registry.set(nodeAtom, newNode);
+      graph.onNodeChanged.emit({
+        id,
+        node: newNode
+      });
+      const prefix = `${id}${Separators.primary}`;
+      const toApply = [
+        ...internal._pendingExpands
+      ].filter((k) => k.startsWith(prefix));
+      for (const pendingKey of toApply) {
+        internal._pendingExpands.delete(pendingKey);
+        const relation2 = relationFromKey(pendingKey.slice(prefix.length));
+        Record.set(internal._expanded, pendingKey, true);
+        internal._onExpand?.(id, relation2);
+      }
     }
-    if (edges) {
-      todo();
+  });
+  if (nodes) {
+    addNodesImpl(graph, nodes);
+    const _edges = nodes.map((node) => ({
+      source: id,
+      target: node.id,
+      relation: "child"
+    }));
+    addEdgesImpl(graph, _edges);
+  }
+  if (edges) {
+    todo();
+  }
+  return graph;
+};
+function addNode(graphOrNodeArg, nodeArg) {
+  if (nodeArg === void 0) {
+    const nodeArg2 = graphOrNodeArg;
+    return (graph) => addNodeImpl(graph, nodeArg2);
+  } else {
+    const graph = graphOrNodeArg;
+    return addNodeImpl(graph, nodeArg);
+  }
+}
+var removeNodesImpl = (graph, ids, edges = false) => {
+  Atom2.batch(() => {
+    ids.map((id) => removeNodeImpl(graph, id, edges));
+  });
+  return graph;
+};
+function removeNodes(graphOrIds, idsOrEdges, edges) {
+  if (Array.isArray(graphOrIds)) {
+    const ids = graphOrIds;
+    const edgesArg = typeof idsOrEdges === "boolean" ? idsOrEdges : false;
+    return (graph) => removeNodesImpl(graph, ids, edgesArg);
+  } else {
+    const graph = graphOrIds;
+    const ids = idsOrEdges;
+    const edgesArg = edges ?? false;
+    return removeNodesImpl(graph, ids, edgesArg);
+  }
+}
+var removeNodeImpl = (graph, id, edges = false) => {
+  const internal = getInternal(graph);
+  const nodeAtom = internal._node(id);
+  internal._registry.set(nodeAtom, Option.none());
+  graph.onNodeChanged.emit({
+    id,
+    node: Option.none()
+  });
+  if (edges) {
+    const nodeEdges = internal._registry.get(internal._edges(id));
+    const edgesToRemove = [];
+    for (const [relationKeyValue, relatedIds] of Object.entries(nodeEdges)) {
+      const relation2 = relationFromKey(relationKeyValue);
+      const isInboundRelation = relation2.direction === "inbound";
+      for (const relatedId of relatedIds) {
+        if (isInboundRelation) {
+          edgesToRemove.push({
+            source: relatedId,
+            target: id,
+            relation: inverseRelation(relation2)
+          });
+        } else {
+          edgesToRemove.push({
+            source: id,
+            target: relatedId,
+            relation: relation2
+          });
+        }
+      }
     }
+    removeEdgesImpl(graph, edgesToRemove);
   }
-  removeNodes(ids, edges = false) {
-    Rx.batch(() => {
-      ids.map((id) => this.removeNode(id, edges));
+  internal._onRemoveNode?.(id);
+  return graph;
+};
+function removeNode(graphOrId, idOrEdges, edges) {
+  if (typeof graphOrId === "string") {
+    const id = graphOrId;
+    const edgesArg = typeof idOrEdges === "boolean" ? idOrEdges : false;
+    return (graph) => removeNodeImpl(graph, id, edgesArg);
+  } else {
+    const graph = graphOrId;
+    const id = idOrEdges;
+    const edgesArg = edges ?? false;
+    return removeNodeImpl(graph, id, edgesArg);
+  }
+}
+var addEdgesImpl = (graph, edges) => {
+  Atom2.batch(() => {
+    edges.map((edge) => addEdgeImpl(graph, edge));
+  });
+  return graph;
+};
+function addEdges(graphOrEdges, edges) {
+  if (edges === void 0) {
+    const edges2 = graphOrEdges;
+    return (graph) => addEdgesImpl(graph, edges2);
+  } else {
+    const graph = graphOrEdges;
+    return addEdgesImpl(graph, edges);
+  }
+}
+var addEdgeImpl = (graph, edgeArg) => {
+  const relation2 = normalizeRelation(edgeArg.relation);
+  const relationId = relationKey(relation2);
+  const inverse = inverseRelation(relation2);
+  const inverseId = relationKey(inverse);
+  const internal = getInternal(graph);
+  const sourceAtom = internal._edges(edgeArg.source);
+  const source = internal._registry.get(sourceAtom);
+  const sourceList = source[relationId] ?? [];
+  if (!sourceList.includes(edgeArg.target)) {
+    log("add edge", {
+      source: edgeArg.source,
+      target: edgeArg.target,
+      relation: relationId
+    }, {
+      F: __dxlog_file,
+      L: 1068,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    internal._registry.set(sourceAtom, {
+      ...source,
+      [relationId]: [
+        ...sourceList,
+        edgeArg.target
+      ]
     });
   }
-  removeNode(id, edges = false) {
-    const nodeRx = this._node(id);
-    this._registry.set(nodeRx, Option.none());
-    this.onNodeChanged.emit({
-      id,
-      node: Option.none()
+  const targetAtom = internal._edges(edgeArg.target);
+  const target = internal._registry.get(targetAtom);
+  const targetList = target[inverseId] ?? [];
+  if (!targetList.includes(edgeArg.source)) {
+    log("add inverse edge", {
+      source: edgeArg.source,
+      target: edgeArg.target,
+      relation: inverseId
+    }, {
+      F: __dxlog_file,
+      L: 1076,
+      S: void 0,
+      C: (f, a) => f(...a)
     });
-    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);
+    internal._registry.set(targetAtom, {
+      ...target,
+      [inverseId]: [
+        ...targetList,
+        edgeArg.source
+      ]
+    });
+  }
+  return graph;
+};
+function addEdge(graphOrEdgeArg, edgeArg) {
+  if (edgeArg === void 0) {
+    const edgeArg2 = graphOrEdgeArg;
+    return (graph) => addEdgeImpl(graph, edgeArg2);
+  } else {
+    const graph = graphOrEdgeArg;
+    return addEdgeImpl(graph, edgeArg);
+  }
+}
+var removeEdgesImpl = (graph, edges, removeOrphans = false) => {
+  Atom2.batch(() => {
+    edges.map((edge) => removeEdgeImpl(graph, edge, removeOrphans));
+  });
+  return graph;
+};
+function removeEdges(graphOrEdges, edgesOrRemoveOrphans, removeOrphans) {
+  if (Array.isArray(graphOrEdges)) {
+    const edges = graphOrEdges;
+    const removeOrphansArg = typeof edgesOrRemoveOrphans === "boolean" ? edgesOrRemoveOrphans : false;
+    return (graph) => removeEdgesImpl(graph, edges, removeOrphansArg);
+  } else {
+    const graph = graphOrEdges;
+    const edges = edgesOrRemoveOrphans;
+    const removeOrphansArg = removeOrphans ?? false;
+    return removeEdgesImpl(graph, edges, removeOrphansArg);
+  }
+}
+var removeEdgeImpl = (graph, edgeArg, removeOrphans = false) => {
+  const relation2 = normalizeRelation(edgeArg.relation);
+  const relationId = relationKey(relation2);
+  const inverse = inverseRelation(relation2);
+  const inverseId = relationKey(inverse);
+  const internal = getInternal(graph);
+  const sourceAtom = internal._edges(edgeArg.source);
+  const source = internal._registry.get(sourceAtom);
+  const sourceList = source[relationId] ?? [];
+  if (sourceList.includes(edgeArg.target)) {
+    internal._registry.set(sourceAtom, {
+      ...source,
+      [relationId]: sourceList.filter((id) => id !== edgeArg.target)
+    });
+  }
+  const targetAtom = internal._edges(edgeArg.target);
+  const target = internal._registry.get(targetAtom);
+  const targetList = target[inverseId] ?? [];
+  if (targetList.includes(edgeArg.source)) {
+    internal._registry.set(targetAtom, {
+      ...target,
+      [inverseId]: targetList.filter((id) => id !== edgeArg.source)
+    });
+  }
+  if (removeOrphans) {
+    const sourceAfter = internal._registry.get(sourceAtom);
+    const targetAfter = internal._registry.get(targetAtom);
+    const isEmpty = (edges) => Object.values(edges).every((ids) => ids.length === 0);
+    if (isEmpty(sourceAfter) && edgeArg.source !== RootId) {
+      removeNodesImpl(graph, [
+        edgeArg.source
+      ]);
+    }
+    if (isEmpty(targetAfter) && edgeArg.target !== RootId) {
+      removeNodesImpl(graph, [
+        edgeArg.target
+      ]);
+    }
+  }
+  return graph;
+};
+function removeEdge(graphOrEdgeArg, edgeArgOrRemoveOrphans, removeOrphans) {
+  if (edgeArgOrRemoveOrphans === void 0 || typeof edgeArgOrRemoveOrphans === "boolean" || "source" in graphOrEdgeArg) {
+    const edgeArg = graphOrEdgeArg;
+    const removeOrphansArg = typeof edgeArgOrRemoveOrphans === "boolean" ? edgeArgOrRemoveOrphans : false;
+    return (graph) => removeEdgeImpl(graph, edgeArg, removeOrphansArg);
+  } else {
+    const graph = graphOrEdgeArg;
+    const edgeArg = edgeArgOrRemoveOrphans;
+    const removeOrphansArg = removeOrphans ?? false;
+    return removeEdgeImpl(graph, edgeArg, removeOrphansArg);
+  }
+}
+var make = (params) => {
+  return new GraphImpl(params);
+};
+var relationKey = (relation2) => {
+  const normalized = normalizeRelation(relation2);
+  return `${normalized.kind}${Separators.secondary}${normalized.direction}`;
+};
+var relationFromKey = (encoded) => {
+  const separatorIndex = encoded.lastIndexOf(Separators.secondary);
+  invariant(separatorIndex > 0 && separatorIndex < encoded.length - 1, `Invalid relation key: ${encoded}`, {
+    F: __dxlog_file,
+    L: 1221,
+    S: void 0,
+    A: [
+      "separatorIndex > 0 && separatorIndex < encoded.length - 1",
+      "`Invalid relation key: ${encoded}`"
+    ]
+  });
+  const kind = encoded.slice(0, separatorIndex);
+  const directionRaw = encoded.slice(separatorIndex + 1);
+  invariant(directionRaw === "outbound" || directionRaw === "inbound", `Invalid relation direction: ${directionRaw}`, {
+    F: __dxlog_file,
+    L: 1224,
+    S: void 0,
+    A: [
+      "directionRaw === 'outbound' || directionRaw === 'inbound'",
+      "`Invalid relation direction: ${directionRaw}`"
+    ]
+  });
+  return relation(kind, directionRaw);
+};
+var connectionKey = (id, relation2) => `${id}${Separators.primary}${relationKey(relation2)}`;
+var relationFromConnectionKey = (key) => {
+  const separatorIndex = key.indexOf(Separators.primary);
+  invariant(separatorIndex > 0 && separatorIndex < key.length - 1, `Invalid connection key: ${key}`, {
+    F: __dxlog_file,
+    L: 1233,
+    S: void 0,
+    A: [
+      "separatorIndex > 0 && separatorIndex < key.length - 1",
+      "`Invalid connection key: ${key}`"
+    ]
+  });
+  const id = key.slice(0, separatorIndex);
+  const encodedRelation = key.slice(separatorIndex + 1);
+  return {
+    id,
+    relation: relationFromKey(encodedRelation)
+  };
+};
+var inverseRelation = (relation2) => {
+  const normalized = normalizeRelation(relation2);
+  return relation(normalized.kind, normalized.direction === "outbound" ? "inbound" : "outbound");
+};
+
+// src/graph-builder.ts
+var graph_builder_exports = {};
+__export(graph_builder_exports, {
+  GraphBuilderTypeId: () => GraphBuilderTypeId,
+  addExtension: () => addExtension,
+  createConnector: () => createConnector,
+  createExtension: () => createExtension,
+  createExtensionRaw: () => createExtensionRaw,
+  createTypeExtension: () => createTypeExtension,
+  destroy: () => destroy,
+  explore: () => explore,
+  flattenExtensions: () => flattenExtensions,
+  flush: () => flush,
+  from: () => from,
+  make: () => make2,
+  removeExtension: () => removeExtension
+});
+import { Atom as Atom3, Registry as Registry2 } from "@effect-atom/atom-react";
+import * as Array2 from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Function2 from "effect/Function";
+import * as Option3 from "effect/Option";
+import * as Pipeable2 from "effect/Pipeable";
+import * as Record2 from "effect/Record";
+import { scheduleTask, yieldOrContinue } from "main-thread-scheduling";
+import { log as log2 } from "@dxos/log";
+import { byPosition, getDebugName, isNonNullable as isNonNullable2 } from "@dxos/util";
+
+// src/node-matcher.ts
+var node_matcher_exports = {};
+__export(node_matcher_exports, {
+  whenAll: () => whenAll,
+  whenAny: () => whenAny,
+  whenEchoObject: () => whenEchoObject,
+  whenEchoObjectMatches: () => whenEchoObjectMatches,
+  whenEchoType: () => whenEchoType,
+  whenEchoTypeMatches: () => whenEchoTypeMatches,
+  whenId: () => whenId,
+  whenNodeType: () => whenNodeType,
+  whenNot: () => whenNot,
+  whenRoot: () => whenRoot
+});
+import * as Option2 from "effect/Option";
+import { Obj } from "@dxos/echo";
+var whenRoot = (node) => node.id === RootId ? Option2.some(node) : Option2.none();
+var whenId = (id) => (node) => node.id === id ? Option2.some(node) : Option2.none();
+var whenNodeType = (type) => (node) => node.type === type ? Option2.some(node) : Option2.none();
+var whenEchoType = (type) => (node) => Obj.instanceOf(type, node.data) ? Option2.some(node.data) : Option2.none();
+var whenEchoObject = (node) => Obj.isObject(node.data) ? Option2.some(node.data) : Option2.none();
+var whenAll = (...matchers) => (node) => {
+  for (const candidate of matchers) {
+    if (Option2.isNone(candidate(node))) {
+      return Option2.none();
     }
-    this._onRemoveNode?.(id);
   }
-  addEdges(edges) {
-    Rx.batch(() => {
-      edges.map((edge) => this.addEdge(edge));
+  return Option2.some(node);
+};
+var whenAny = (...matchers) => (node) => {
+  for (const candidate of matchers) {
+    if (Option2.isSome(candidate(node))) {
+      return Option2.some(node);
+    }
+  }
+  return Option2.none();
+};
+var whenEchoTypeMatches = (type) => (node) => Obj.instanceOf(type, node.data) ? Option2.some(node) : Option2.none();
+var whenEchoObjectMatches = (node) => Obj.isObject(node.data) ? Option2.some(node) : Option2.none();
+var whenNot = (matcher) => (node) => Option2.isNone(matcher(node)) ? Option2.some(node) : Option2.none();
+
+// src/graph-builder.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/sdk/app-graph/src/graph-builder.ts";
+var GraphBuilderTypeId = /* @__PURE__ */ Symbol.for("@dxos/app-graph/GraphBuilder");
+var GraphBuilderImpl = class {
+  [GraphBuilderTypeId] = GraphBuilderTypeId;
+  pipe() {
+    return Pipeable2.pipeArguments(this, arguments);
+  }
+  // TODO(wittjosiah): Use Context.
+  _subscriptions = /* @__PURE__ */ new Map();
+  _dirtyConnectors = /* @__PURE__ */ new Map();
+  _connectorPrevious = /* @__PURE__ */ new Map();
+  _connectorPreviousArgs = /* @__PURE__ */ new Map();
+  _flushScheduled = false;
+  _flushPromise = Promise.resolve();
+  _extensions = Atom3.make(Record2.empty()).pipe(Atom3.keepAlive, Atom3.withLabel("graph-builder:extensions"));
+  _initialized = {};
+  _registry;
+  _graph;
+  constructor({ registry, ...params } = {}) {
+    this._registry = registry ?? Registry2.make();
+    const graph = make({
+      ...params,
+      registry: this._registry,
+      onExpand: (id, relation2) => this._onExpand(id, relation2),
+      onInitialize: (id) => this._onInitialize(id),
+      onRemoveNode: (id) => this._onRemoveNode(id)
     });
+    this._graph = graph;
+  }
+  get graph() {
+    return this._graph;
+  }
+  get extensions() {
+    return this._extensions;
   }
-  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
+  /** Apply a set of node changes for a single connector key. */
+  _applyConnectorUpdate(key, nodes, previous) {
+    const { id, relation: relation2 } = relationFromConnectorKey(key);
+    const ids = nodes.map((node) => node.id);
+    const removed = previous.filter((pid) => !ids.includes(pid));
+    this._connectorPrevious.set(key, ids);
+    this._connectorPreviousArgs.set(key, nodes);
+    removeEdges(this._graph, removed.map((target) => ({
+      source: id,
+      target,
+      relation: relation2
+    })), true);
+    addNodes(this._graph, nodes);
+    addEdges(this._graph, nodes.map((node) => ({
+      source: id,
+      target: node.id,
+      relation: relation2
+    })));
+    if (ids.length > 0) {
+      const sortedIds = [
+        ...nodes
+      ].sort((a, b) => byPosition(a.properties ?? {}, b.properties ?? {})).map((n) => n.id);
+      sortEdges(this._graph, id, relation2, sortedIds);
+    }
+  }
+  _scheduleDirtyFlush() {
+    if (!this._flushScheduled) {
+      this._flushScheduled = true;
+      this._flushPromise = scheduleTask(() => {
+        this._flushScheduled = false;
+        while (this._dirtyConnectors.size > 0) {
+          const entries = [
+            ...this._dirtyConnectors.entries()
+          ];
+          this._dirtyConnectors.clear();
+          Atom3.batch(() => {
+            for (const [key, { nodes, previous }] of entries) {
+              this._applyConnectorUpdate(key, nodes, previous);
+            }
+          });
+        }
       }, {
-        F: __dxlog_file,
-        L: 481,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._registry.set(sourceRx, {
-        inbound: source.inbound,
-        outbound: [
-          ...source.outbound,
-          edgeArg.target
-        ]
+        strategy: "smooth"
       });
     }
-    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
+  }
+  _resolvers = Atom3.family((id) => {
+    return Atom3.make((get2) => {
+      return Function2.pipe(get2(this._extensions), Record2.values, Array2.sortBy(byPosition), Array2.map(({ resolver }) => resolver), Array2.filter(isNonNullable2), Array2.map((resolver) => get2(resolver(id))), Array2.filter(isNonNullable2), Array2.head);
+    });
+  });
+  _connectors = Atom3.family((key) => {
+    return Atom3.make((get2) => {
+      const { id, relation: relation2 } = relationFromConnectorKey(key);
+      const node = this._graph.node(id);
+      const sourceNode = Option3.getOrElse(get2(node), () => void 0);
+      if (!sourceNode) {
+        return [];
+      }
+      const extensions = Function2.pipe(get2(this._extensions), Record2.values, Array2.sortBy(byPosition), Array2.filter((ext) => relationKey(ext.relation ?? "child") === relationKey(relation2) && ext.connector != null));
+      const nodes = [];
+      for (const ext of extensions) {
+        const result = get2(ext.connector(node));
+        nodes.push(...result);
+      }
+      return nodes;
+    }).pipe(Atom3.withLabel(`graph-builder:connectors:${key}`));
+  });
+  _onExpand(id, relation2) {
+    log2("onExpand", {
+      id,
+      relation: relation2,
+      registry: getDebugName(this._registry)
+    }, {
+      F: __dxlog_file2,
+      L: 251,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._expandRelation(id, relation2);
+    if (relation2.kind === "child" && relation2.direction === "outbound") {
+      expand(this._graph, id, "action");
+    }
+  }
+  _expandRelation(id, relation2) {
+    const key = connectorKey(id, relation2);
+    const connectors = this._connectors(key);
+    const cancel = this._registry.subscribe(connectors, (nodes) => {
+      const previous = this._connectorPrevious.get(key) ?? [];
+      const ids = nodes.map((n) => n.id);
+      if (ids.length === previous.length && ids.every((nodeId, idx) => nodeId === previous[idx])) {
+        const prevArgs = this._connectorPreviousArgs.get(key);
+        if (prevArgs && nodeArgsUnchanged(prevArgs, nodes)) {
+          return;
+        }
+      }
+      log2("update", {
+        id,
+        relation: relation2,
+        ids
       }, {
-        F: __dxlog_file,
-        L: 488,
+        F: __dxlog_file2,
+        L: 277,
         S: this,
         C: (f, a) => f(...a)
       });
-      this._registry.set(targetRx, {
-        inbound: [
-          ...target.inbound,
-          edgeArg.source
-        ],
-        outbound: target.outbound
+      this._dirtyConnectors.set(key, {
+        nodes,
+        previous
       });
-    }
-  }
-  removeEdges(edges, removeOrphans = false) {
-    Rx.batch(() => {
-      edges.map((edge) => this.removeEdge(edge, removeOrphans));
+      this._scheduleDirtyFlush();
+    }, {
+      immediate: true
     });
+    this._subscriptions.set(subscriptionKey(id, "expand", key), cancel);
   }
-  removeEdge(edgeArg, removeOrphans = false) {
-    const sourceRx = this._edges(edgeArg.source);
-    const source = this._registry.get(sourceRx);
-    if (source.outbound.includes(edgeArg.target)) {
-      this._registry.set(sourceRx, {
-        inbound: source.inbound,
-        outbound: source.outbound.filter((id) => id !== edgeArg.target)
-      });
-    }
-    const targetRx = this._edges(edgeArg.target);
-    const target = this._registry.get(targetRx);
-    if (target.inbound.includes(edgeArg.source)) {
-      this._registry.set(targetRx, {
-        inbound: target.inbound.filter((id) => id !== edgeArg.source),
-        outbound: target.outbound
+  // TODO(wittjosiah): If the same node is added by a connector, the resolver should probably cancel itself?
+  async _onInitialize(id) {
+    log2("onInitialize", {
+      id
+    }, {
+      F: __dxlog_file2,
+      L: 289,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const resolver = this._resolvers(id);
+    const cancel = this._registry.subscribe(resolver, (node) => {
+      const trigger = this._initialized[id];
+      Option3.match(node, {
+        onSome: (node2) => {
+          addNodes(this._graph, [
+            node2
+          ]);
+          trigger?.wake();
+        },
+        onNone: () => {
+          trigger?.wake();
+          removeNodes(this._graph, [
+            id
+          ]);
+        }
       });
-    }
-    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
-        ]);
+    }, {
+      immediate: true
+    });
+    this._subscriptions.set(subscriptionKey(id, "init"), cancel);
+  }
+  _onRemoveNode(id) {
+    const prefix = `${id}${Separators.primary}`;
+    for (const [key, cleanup] of this._subscriptions) {
+      if (key.startsWith(prefix)) {
+        cleanup();
+        this._subscriptions.delete(key);
       }
     }
   }
-  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);
+};
+var make2 = (params) => {
+  return new GraphBuilderImpl(params);
+};
+var from = (pickle, registry) => {
+  if (!pickle) {
+    return make2({
+      registry
+    });
   }
-  traverse({ visitor, source = ROOT_ID, relation = "outbound" }, path = []) {
-    if (path.includes(source)) {
-      return;
-    }
-    const node = this.getNodeOrThrow(source);
-    const shouldContinue = visitor(node, [
-      ...path,
-      source
-    ]);
-    if (shouldContinue === false) {
-      return;
-    }
-    Object.values(this.getConnections(source, relation)).forEach((child) => this.traverse({
-      source: child.id,
-      relation,
+  const { nodes, edges } = JSON.parse(pickle);
+  return make2({
+    nodes,
+    edges,
+    registry
+  });
+};
+var addExtensionImpl = (builder, extensions) => {
+  const internal = builder;
+  flattenExtensions(extensions).forEach((extension) => {
+    const extensions2 = internal._registry.get(internal._extensions);
+    internal._registry.set(internal._extensions, Record2.set(extensions2, extension.id, extension));
+  });
+  return builder;
+};
+function addExtension(builderOrExtensions, extensions) {
+  if (extensions === void 0) {
+    const extensions2 = builderOrExtensions;
+    return (builder) => addExtensionImpl(builder, extensions2);
+  } else {
+    const builder = builderOrExtensions;
+    return addExtensionImpl(builder, extensions);
+  }
+}
+var removeExtensionImpl = (builder, id) => {
+  const internal = builder;
+  const extensions = internal._registry.get(internal._extensions);
+  internal._registry.set(internal._extensions, Record2.remove(extensions, id));
+  return builder;
+};
+function removeExtension(builderOrId, id) {
+  if (typeof builderOrId === "string") {
+    const id2 = builderOrId;
+    return (builder) => removeExtensionImpl(builder, id2);
+  } else {
+    const builder = builderOrId;
+    return removeExtensionImpl(builder, id);
+  }
+}
+var exploreImpl = async (builder, options, path = []) => {
+  const internal = builder;
+  const { registry = Registry2.make(), source = RootId, relation: relation2, visitor } = options;
+  if (path.includes(source)) {
+    return;
+  }
+  await yieldOrContinue("idle");
+  const node = registry.get(internal._graph.nodeOrThrow(source));
+  const shouldContinue = await visitor(node, [
+    ...path,
+    node.id
+  ]);
+  if (shouldContinue === false) {
+    return;
+  }
+  const nodes = Object.values(internal._registry.get(internal._extensions)).filter((extension) => relationKey(extension.relation ?? "child") === relationKey(relation2)).map((extension) => extension.connector).filter(isNonNullable2).flatMap((connector) => registry.get(connector(internal._graph.node(source))));
+  await Promise.all(nodes.map((nodeArg) => {
+    registry.set(internal._graph._node(nodeArg.id), internal._graph._constructNode(nodeArg));
+    return exploreImpl(builder, {
+      registry,
+      source: nodeArg.id,
+      relation: relation2,
       visitor
     }, [
       ...path,
-      source
-    ]));
-  }
-  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);
-          }
-        }
-      });
-      return found;
-    }));
+      node.id
+    ]);
+  }));
+  if (registry !== internal._registry) {
+    registry.reset();
+    registry.dispose();
   }
-  async waitForPath(params, { timeout = 5e3, interval = 500 } = {}) {
-    const path = this.getPath(params);
-    if (Option.isSome(path)) {
-      return path.value;
-    }
-    const trigger = new Trigger();
-    const i = setInterval(() => {
-      const path2 = this.getPath(params);
-      if (Option.isSome(path2)) {
-        trigger.wake(path2.value);
-      }
-    }, interval);
-    return trigger.wait({
-      timeout
-    }).finally(() => clearInterval(i));
+};
+function explore(builderOrOptions, optionsOrPath, path) {
+  if (typeof builderOrOptions === "object" && "visitor" in builderOrOptions) {
+    const options = builderOrOptions;
+    const path2 = Array2.isArray(optionsOrPath) ? optionsOrPath : void 0;
+    return (builder) => exploreImpl(builder, options, path2);
+  } else {
+    const builder = builderOrOptions;
+    const options = optionsOrPath;
+    const pathArg = path ?? (Array2.isArray(optionsOrPath) ? optionsOrPath : void 0);
+    return exploreImpl(builder, options, pathArg);
   }
-  /** @internal */
-  _constructNode(node) {
-    return Option.some({
-      [graphSymbol]: this,
-      data: null,
-      properties: {},
-      ...node
-    });
+}
+var destroyImpl = (builder) => {
+  const internal = builder;
+  internal._subscriptions.forEach((unsubscribe) => unsubscribe());
+  internal._subscriptions.clear();
+};
+function destroy(builder) {
+  if (builder === void 0) {
+    return (builder2) => destroyImpl(builder2);
+  } else {
+    return destroyImpl(builder);
   }
+}
+var flush = (builder) => {
+  return builder._flushPromise;
 };
-
-// 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 { log as log2 } from "@dxos/log";
-import { byPosition, getDebugName, isNode, isNonNullable as isNonNullable2 } from "@dxos/util";
-
-// src/node.ts
-var isGraphNode = (data) => data && typeof data === "object" && "id" in data && "properties" in data && data.properties ? typeof data.properties === "object" && "data" in data : false;
-var isAction = (data) => isGraphNode(data) ? typeof data.data === "function" && data.type === ACTION_TYPE : false;
-var actionGroupSymbol = Symbol("ActionGroup");
-var isActionGroup = (data) => isGraphNode(data) ? data.data === actionGroupSymbol && data.type === ACTION_GROUP_TYPE : false;
-var isActionLike = (data) => isAction(data) || isActionGroup(data);
-
-// src/graph-builder.ts
-var __dxlog_file2 = "/__w/dxos/dxos/packages/sdk/app-graph/src/graph-builder.ts";
-var createExtension = (extension) => {
-  const { id, position = "static", relation = "outbound", connector: _connector, actions: _actions, actionGroups: _actionGroups } = extension;
+var createExtensionRaw = (extension) => {
+  const { id, position = "static", relation: relation2 = "child", resolver: _resolver, connector: _connector, actions: _actions, actionGroups: _actionGroups } = extension;
+  const normalizedRelation = normalizeRelation(relation2);
   const getId = (key) => `${id}/${key}`;
-  const connector = _connector && Rx2.family((node) => _connector(node).pipe(Rx2.withLabel(`graph-builder:_connector:${id}`)));
-  const actionGroups = _actionGroups && Rx2.family((node) => _actionGroups(node).pipe(Rx2.withLabel(`graph-builder:_actionGroups:${id}`)));
-  const actions = _actions && Rx2.family((node) => _actions(node).pipe(Rx2.withLabel(`graph-builder:_actions:${id}`)));
+  const resolver = _resolver && Atom3.family((id2) => _resolver(id2).pipe(Atom3.withLabel(`graph-builder:_resolver:${id2}`)));
+  const connector = _connector && Atom3.family((node) => _connector(node).pipe(Atom3.withLabel(`graph-builder:_connector:${id}`)));
+  const actionGroups = _actionGroups && Atom3.family((node) => _actionGroups(node).pipe(Atom3.withLabel(`graph-builder:_actionGroups:${id}`)));
+  const actions = _actions && Atom3.family((node) => _actions(node).pipe(Atom3.withLabel(`graph-builder:_actions:${id}`)));
   return [
-    // resolver ? { id: getId('resolver'), position, resolver } : undefined,
+    resolver ? {
+      id: getId("resolver"),
+      position,
+      resolver
+    } : void 0,
     connector ? {
       id: getId("connector"),
       position,
-      relation,
-      connector: Rx2.family((node) => Rx2.make((get) => {
+      relation: normalizedRelation,
+      connector: Atom3.family((node) => Atom3.make((get2) => {
         try {
-          return get(connector(node));
-        } catch {
+          return get2(connector(node));
+        } catch (error) {
           log2.warn("Error in connector", {
             id: getId("connector"),
-            node
+            node,
+            error
           }, {
             F: __dxlog_file2,
-            L: 101,
+            L: 579,
             S: void 0,
             C: (f, a) => f(...a)
           });
           return [];
         }
-      }).pipe(Rx2.withLabel(`graph-builder:connector:${id}`)))
+      }).pipe(Atom3.withLabel(`graph-builder:connector:${id}`)))
     } : void 0,
     actionGroups ? {
       id: getId("actionGroups"),
       position,
-      relation: "outbound",
-      connector: Rx2.family((node) => Rx2.make((get) => {
+      relation: actionRelation(),
+      connector: Atom3.family((node) => Atom3.make((get2) => {
         try {
-          return get(actionGroups(node)).map((arg) => ({
+          return get2(actionGroups(node)).map((arg) => ({
             ...arg,
             data: actionGroupSymbol,
-            type: ACTION_GROUP_TYPE
+            type: ActionGroupType
           }));
-        } catch {
+        } catch (error) {
           log2.warn("Error in actionGroups", {
             id: getId("actionGroups"),
-            node
+            node,
+            error
           }, {
             F: __dxlog_file2,
-            L: 122,
+            L: 600,
             S: void 0,
             C: (f, a) => f(...a)
           });
           return [];
         }
-      }).pipe(Rx2.withLabel(`graph-builder:connector:actionGroups:${id}`)))
+      }).pipe(Atom3.withLabel(`graph-builder:connector:actionGroups:${id}`)))
     } : void 0,
     actions ? {
       id: getId("actions"),
       position,
-      relation: "outbound",
-      connector: Rx2.family((node) => Rx2.make((get) => {
+      relation: actionRelation(),
+      connector: Atom3.family((node) => Atom3.make((get2) => {
         try {
-          return get(actions(node)).map((arg) => ({
+          return get2(actions(node)).map((arg) => ({
             ...arg,
-            type: ACTION_TYPE
+            type: ActionType
           }));
-        } catch {
+        } catch (error) {
           log2.warn("Error in actions", {
             id: getId("actions"),
-            node
+            node,
+            error
           }, {
             F: __dxlog_file2,
-            L: 139,
+            L: 617,
             S: void 0,
             C: (f, a) => f(...a)
           });
           return [];
         }
-      }).pipe(Rx2.withLabel(`graph-builder:connector:actions:${id}`)))
+      }).pipe(Atom3.withLabel(`graph-builder:connector:actions:${id}`)))
     } : void 0
   ].filter(isNonNullable2);
 };
+var runEffectSyncWithFallback = (effect, context2, extensionId, fallback) => {
+  return Effect.runSync(effect.pipe(Effect.provide(context2), Effect.catchAll((error) => {
+    log2.warn("Extension failed", {
+      extension: extensionId,
+      error
+    }, {
+      F: __dxlog_file2,
+      L: 660,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return Effect.succeed(fallback);
+  })));
+};
+var createExtension = (options) => Effect.map(Effect.context(), (context2) => {
+  const { id, match: match3, actions, connector, resolver, relation: relation2, position } = options;
+  const connectorExtension = connector ? createConnectorWithRuntime(id, match3, connector, context2) : void 0;
+  const actionsExtension = actions ? (node) => Atom3.make((get2) => Function2.pipe(get2(node), Option3.flatMap(match3), Option3.map((matched) => runEffectSyncWithFallback(actions(matched, get2), context2, id, []).map((action) => ({
+    ...action,
+    // Attach captured context for action execution.
+    _actionContext: context2
+  }))), Option3.getOrElse(() => []))) : void 0;
+  const resolverExtension = resolver ? (nodeId) => Atom3.make((get2) => runEffectSyncWithFallback(resolver(nodeId, get2), context2, id, null) ?? null) : void 0;
+  return createExtensionRaw({
+    id,
+    relation: relation2,
+    position,
+    connector: connectorExtension,
+    actions: actionsExtension,
+    resolver: resolverExtension
+  });
+});
+var createConnector = (matcher, factory) => {
+  return (node) => Atom3.make((get2) => Function2.pipe(get2(node), Option3.flatMap(matcher), Option3.map((data) => factory(data, get2)), Option3.getOrElse(() => [])));
+};
+var createConnectorWithRuntime = (extensionId, matcher, factory, context2) => {
+  return (node) => Atom3.make((get2) => Function2.pipe(get2(node), Option3.flatMap(matcher), Option3.map((data) => runEffectSyncWithFallback(factory(data, get2), context2, extensionId, [])), Option3.getOrElse(() => [])));
+};
+var createTypeExtension = (options) => {
+  const { id, type, actions, connector, relation: relation2, position } = options;
+  return createExtension({
+    id,
+    match: whenEchoType(type),
+    actions,
+    connector,
+    relation: relation2,
+    position
+  });
+};
+var connectorKey = (id, relation2) => `${id}${Separators.primary}${relationKey(relation2)}`;
+var relationFromConnectorKey = (key) => {
+  const separatorIndex = key.indexOf(Separators.primary);
+  const id = key.slice(0, separatorIndex);
+  return {
+    id,
+    relation: relationFromKey(key.slice(separatorIndex + 1))
+  };
+};
+var subscriptionKey = (id, kind, detail) => detail != null ? `${id}${Separators.primary}${kind}${Separators.primary}${detail}` : `${id}${Separators.primary}${kind}`;
 var flattenExtensions = (extension, acc = []) => {
-  if (Array.isArray(extension)) {
+  if (Array2.isArray(extension)) {
     return [
       ...acc,
       ...extension.flatMap((ext) => flattenExtensions(ext, acc))
@@ -577,204 +1513,11 @@ var flattenExtensions = (extension, acc = []) => {
     ];
   }
 };
-var GraphBuilder = class _GraphBuilder {
-  constructor({ registry, ...params } = {}) {
-    // TODO(wittjosiah): Use Context.
-    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._graph = new Graph({
-      ...params,
-      registry: this._registry,
-      onExpand: (id, relation) => this._onExpand(id, relation),
-      // onInitialize: (id) => this._onInitialize(id),
-      onRemoveNode: (id) => this._onRemoveNode(id)
-    });
-  }
-  static from(pickle, registry) {
-    if (!pickle) {
-      return new _GraphBuilder({
-        registry
-      });
-    }
-    const { nodes, edges } = JSON.parse(pickle);
-    return new _GraphBuilder({
-      nodes,
-      edges,
-      registry
-    });
-  }
-  get graph() {
-    return this._graph;
-  }
-  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 this;
-  }
-  removeExtension(id) {
-    const extensions = this._registry.get(this._extensions);
-    this._registry.set(this._extensions, Record2.remove(extensions, id));
-    return this;
-  }
-  async explore({ registry = Registry2.make(), source = ROOT_ID, relation = "outbound", visitor }, path = []) {
-    if (path.includes(source)) {
-      return;
-    }
-    if (!isNode()) {
-      const { yieldOrContinue } = await import("main-thread-scheduling");
-      await yieldOrContinue("idle");
-    }
-    const node = registry.get(this._graph.nodeOrThrow(source));
-    const shouldContinue = await visitor(node, [
-      ...path,
-      node.id
-    ]);
-    if (shouldContinue === false) {
-      return;
-    }
-    const nodes = Object.values(this._registry.get(this._extensions)).filter((extension) => relation === (extension.relation ?? "outbound")).map((extension) => extension.connector).filter(isNonNullable2).flatMap((connector) => registry.get(connector(this._graph.node(source))));
-    await Promise.all(nodes.map((nodeArg) => {
-      registry.set(this._graph._node(nodeArg.id), this._graph._constructNode(nodeArg));
-      return this.explore({
-        registry,
-        source: nodeArg.id,
-        relation,
-        visitor
-      }, [
-        ...path,
-        node.id
-      ]);
-    }));
-    if (registry !== this._registry) {
-      registry.reset();
-      registry.dispose();
-    }
-  }
-  destroy() {
-    this._connectorSubscriptions.forEach((unsubscribe) => unsubscribe());
-    this._connectorSubscriptions.clear();
-  }
-  _onExpand(id, relation) {
-    log2("onExpand", {
-      id,
-      relation,
-      registry: getDebugName(this._registry)
-    }, {
-      F: __dxlog_file2,
-      L: 301,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const connectors = this._connectors(`${id}+${relation}`);
-    let previous = [];
-    const cancel = this._registry.subscribe(connectors, (nodes) => {
-      const ids = nodes.map((n) => n.id);
-      const removed = previous.filter((id2) => !ids.includes(id2));
-      previous = ids;
-      log2("update", {
-        id,
-        relation,
-        ids,
-        removed
-      }, {
-        F: __dxlog_file2,
-        L: 312,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const update = () => {
-        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));
-        });
-      };
-      if (typeof requestAnimationFrame === "function") {
-        requestAnimationFrame(update);
-      } else {
-        update();
-      }
-    }, {
-      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);
-  }
-};
-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,
-  Graph,
-  GraphBuilder,
-  ROOT_ID,
-  ROOT_TYPE,
-  actionGroupSymbol,
-  createExtension,
-  flattenExtensions,
-  getGraph,
-  isAction,
-  isActionGroup,
-  isActionLike,
-  isGraphNode,
-  rxFromObservable,
-  rxFromSignal
+  atoms_exports as CreateAtom,
+  graph_exports as Graph,
+  graph_builder_exports as GraphBuilder,
+  node_exports as Node,
+  node_matcher_exports as NodeMatcher
 };
 //# sourceMappingURL=index.mjs.map