@dxos/app-graph 0.8.4-main.ef1bc66f44 → 0.8.4-main.f466a3d56e

package/dist/lib/{browser/index.mjs → neutral/chunk-32XXJE6M.mjs}

@@ -1,24 +1,99 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
 
-// src/atoms.ts
-var atoms_exports = {};
-__export(atoms_exports, {
-  fromObservable: () => fromObservable
+// 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,
+  make: () => make,
+  makeAction: () => makeAction,
+  makeActionGroup: () => makeActionGroup,
+  relation: () => relation
 });
-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 RootId = "root";
+var RootType = "org.dxos.type.graphRoot";
+var ActionType = "org.dxos.type.graphAction";
+var ActionGroupType = "org.dxos.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);
+var make = (arg) => arg;
+var makeAction = (arg) => ({
+  ...arg,
+  type: ActionType
+});
+var makeActionGroup = (arg) => ({
+  ...arg,
+  type: ActionGroupType,
+  data: actionGroupSymbol
 });
-var fromObservable = (observable) => {
-  return observableFamily(observable);
+
+// src/util.ts
+import { invariant } from "@dxos/invariant";
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-graph/src/util.ts";
+var PRIMARY = "
";
+var SECONDARY = "";
+var PATH = "/";
+var primaryKey = (...parts) => parts.join(PRIMARY);
+var primaryParts = (key) => key.split(PRIMARY);
+var secondaryKey = (...parts) => parts.join(SECONDARY);
+var secondaryParts = (key) => key.split(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) && nodeArgsUnchanged(prevNode.nodes ?? [], nextNode.nodes ?? []);
+  });
+};
+var qualifyId = (parentId, ...segmentIds) => [
+  parentId,
+  ...segmentIds
+].join(PATH);
+var validateSegmentId = (id) => {
+  invariant(!id.includes(PATH), `Node segment ID must not contain '${PATH}': ${id}`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 56, S: void 0, A: ["!id.includes(PATH)", "`Node segment ID must not contain '${PATH}': ${id}`"] });
+};
+var getParentId = (qualifiedId) => {
+  const lastSlash = qualifiedId.lastIndexOf(PATH);
+  return lastSlash > 0 ? qualifiedId.slice(0, lastSlash) : void 0;
+};
+var getSegmentId = (qualifiedId) => {
+  return qualifiedId.split(PATH).pop() ?? qualifiedId;
 };
 
 // src/graph.ts
@@ -40,7 +115,9 @@ __export(graph_exports, {
   getPath: () => getPath,
   getRoot: () => getRoot,
   initialize: () => initialize,
-  make: () => make,
+  make: () => make2,
+  relationFromKey: () => relationFromKey,
+  relationKey: () => relationKey,
   removeEdge: () => removeEdge,
   removeEdges: () => removeEdges,
   removeNode: () => removeNode,
@@ -50,58 +127,25 @@ __export(graph_exports, {
   traverse: () => traverse,
   waitForPath: () => waitForPath
 });
-import { Atom as Atom2, Registry } from "@effect-atom/atom-react";
+import { Atom, 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 { invariant as invariant2 } 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,
-  isAction: () => isAction,
-  isActionGroup: () => isActionGroup,
-  isActionLike: () => isActionLike,
-  isGraphNode: () => isGraphNode
-});
-var RootId = "root";
-var RootType = "dxos.org/type/GraphRoot";
-var ActionType = "dxos.org/type/GraphAction";
-var ActionGroupType = "dxos.org/type/GraphActionGroup";
-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 = Symbol("ActionGroup");
-var isActionGroup = (data) => isGraphNode(data) ? data.data === actionGroupSymbol && data.type === ActionGroupType : false;
-var isActionLike = (data) => isAction(data) || isActionGroup(data);
-
-// src/graph.ts
-var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-graph/src/graph.ts";
-var graphSymbol = Symbol("graph");
+var __dxlog_file2 = "/__w/dxos/dxos/packages/sdk/app-graph/src/graph.ts";
+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: 32,
-    S: void 0,
-    A: [
-      "graph",
-      "'Node is not associated with a graph.'"
-    ]
-  });
+  invariant2(graph, "Node is not associated with a graph.", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 21, S: void 0, A: ["graph", "'Node is not associated with a graph.'"] });
   return graph;
 };
-var GraphTypeId = Symbol.for("@dxos/app-graph/Graph");
-var GraphKind = Symbol.for("@dxos/app-graph/GraphKind");
+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";
@@ -114,6 +158,7 @@ var GraphImpl = class {
   _onRemoveNode;
   _registry;
   _expanded = Record.empty();
+  _pendingExpands = /* @__PURE__ */ new Set();
   _initialized = Record.empty();
   _initialEdges = Record.empty();
   _initialNodes = Record.fromEntries([
@@ -128,50 +173,46 @@ var GraphImpl = class {
     ]
   ]);
   /** @internal */
-  _node = Atom2.family((id) => {
+  _node = Atom.family((id) => {
     const initial = Option.flatten(Record.get(this._initialNodes, id));
-    return Atom2.make(initial).pipe(Atom2.keepAlive, Atom2.withLabel(`graph:node:${id}`));
+    return Atom.make(initial).pipe(Atom.keepAlive, Atom.withLabel(`graph:node:${id}`));
   });
-  _nodeOrThrow = Atom2.family((id) => {
-    return Atom2.make((get2) => {
+  _nodeOrThrow = Atom.family((id) => {
+    return Atom.make((get2) => {
       const node = get2(this._node(id));
-      invariant(Option.isSome(node), `Node not available: ${id}`, {
-        F: __dxlog_file,
-        L: 174,
-        S: this,
-        A: [
-          "Option.isSome(node)",
-          "`Node not available: ${id}`"
-        ]
-      });
+      invariant2(Option.isSome(node), `Node not available: ${id}`, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 67, S: this, A: ["Option.isSome(node)", "`Node not available: ${id}`"] });
       return node.value;
     });
   });
-  _edges = Atom2.family((id) => {
-    const initial = Record.get(this._initialEdges, id).pipe(Option.getOrElse(() => ({
-      inbound: [],
-      outbound: []
-    })));
-    return Atom2.make(initial).pipe(Atom2.keepAlive, Atom2.withLabel(`graph:edges:${id}`));
+  _edges = Atom.family((id) => {
+    const initial = Record.get(this._initialEdges, id).pipe(Option.getOrElse(() => ({})));
+    return Atom.make(initial).pipe(Atom.keepAlive, Atom.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] = key.split("$");
+  _connections = Atom.family((key) => {
+    return Atom.make((get2) => {
+      const parts = key ? primaryParts(key) : [];
+      if (parts.length < 2 || !parts[0]) {
+        return [];
+      }
+      const { id, relation: relation2 } = relationFromConnectionKey(key);
       const edges = get2(this._edges(id));
-      return edges[relation].map((id2) => get2(this._node(id2))).filter(Option.isSome).map((o) => o.value);
-    }).pipe(Atom2.withLabel(`graph:connections:${key}`));
+      return (edges[relationKey(relation2)] ?? []).map((id2) => get2(this._node(id2))).filter(Option.isSome).map((o) => o.value);
+    }).pipe(Atom.withLabel(`graph:connections:${key}`));
   });
-  _actions = Atom2.family((id) => {
-    return Atom2.make((get2) => {
-      return get2(this._connections(`${id}$outbound`)).filter((node) => node.type === ActionType || node.type === ActionGroupType);
-    }).pipe(Atom2.withLabel(`graph:actions:${id}`));
+  _actions = Atom.family((id) => {
+    return Atom.make((get2) => {
+      if (!id) {
+        return [];
+      }
+      return get2(this._connections(connectionKey(id, actionRelation())));
+    }).pipe(Atom.withLabel(`graph:actions:${id}`));
   });
-  _json = Atom2.family((id) => {
-    return Atom2.make((get2) => {
+  _json = Atom.family((id) => {
+    return Atom.make((get2) => {
       const toJSON2 = (node, seen = []) => {
-        const nodes = get2(this._connections(`${node.id}$outbound`));
+        const nodes = get2(this._connections(connectionKey(node.id, "child")));
         const obj = {
           id: node.id,
           type: node.type
@@ -192,7 +233,7 @@ var GraphImpl = class {
       };
       const root = get2(this._nodeOrThrow(id));
       return toJSON2(root);
-    }).pipe(Atom2.withLabel(`graph:json:${id}`));
+    }).pipe(Atom.withLabel(`graph:json:${id}`));
   });
   constructor({ registry, nodes, edges, onInitialize, onExpand, onRemoveNode } = {}) {
     this._registry = registry ?? Registry.make();
@@ -219,8 +260,8 @@ var GraphImpl = class {
   nodeOrThrow(id) {
     return nodeOrThrowImpl(this, id);
   }
-  connections(id, relation = "outbound") {
-    return connectionsImpl(this, id, relation);
+  connections(id, relation2) {
+    return connectionsImpl(this, id, relation2);
   }
   actions(id) {
     return actionsImpl(this, id);
@@ -257,9 +298,9 @@ var nodeOrThrowImpl = (graph, id) => {
   const internal = getInternal(graph);
   return internal._nodeOrThrow(id);
 };
-var connectionsImpl = (graph, id, relation = "outbound") => {
+var connectionsImpl = (graph, id, relation2) => {
   const internal = getInternal(graph);
-  return internal._connections(`${id}$${relation}`);
+  return internal._connections(connectionKey(id, relation2));
 };
 var actionsImpl = (graph, id) => {
   const internal = getInternal(graph);
@@ -298,19 +339,20 @@ function getNodeOrThrow(graphOrId, id) {
 function getRoot(graph) {
   return getNodeOrThrowImpl(graph, RootId);
 }
-var getConnectionsImpl = (graph, id, relation = "outbound") => {
+var getConnectionsImpl = (graph, id, relation2) => {
   const internal = getInternal(graph);
-  return internal._registry.get(connectionsImpl(graph, id, relation));
+  return internal._registry.get(connectionsImpl(graph, id, relation2));
 };
-function getConnections(graphOrId, idOrRelation, relation) {
+function getConnections(graphOrId, idOrRelation, relation2) {
   if (typeof graphOrId === "string") {
     const id = graphOrId;
-    const rel = (typeof idOrRelation === "string" ? "outbound" : idOrRelation) ?? "outbound";
+    const rel = idOrRelation;
     return (graph) => getConnectionsImpl(graph, id, rel);
   } else {
     const graph = graphOrId;
     const id = idOrRelation;
-    const rel = relation ?? "outbound";
+    invariant2(relation2 !== void 0, "Relation is required.", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 272, S: this, A: ["relation !== undefined", "'Relation is required.'"] });
+    const rel = relation2;
     return getConnectionsImpl(graph, id, rel);
   }
 }
@@ -341,7 +383,7 @@ function getEdges(graphOrId, id) {
   }
 }
 var traverseImpl = (graph, options, path = []) => {
-  const { visitor, source = RootId, relation = "outbound" } = options;
+  const { visitor, source = RootId, relation: relation2 } = options;
   if (path.includes(source)) {
     return;
   }
@@ -353,14 +395,25 @@ var traverseImpl = (graph, options, path = []) => {
   if (shouldContinue === false) {
     return;
   }
-  Object.values(getConnections(graph, source, relation)).forEach((child) => traverseImpl(graph, {
-    source: child.id,
-    relation,
-    visitor
-  }, [
-    ...path,
-    source
-  ]));
+  const relations = Array.isArray(relation2) ? relation2 : [
+    relation2
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rel of relations) {
+    for (const connected of getConnections(graph, source, rel)) {
+      if (!seen.has(connected.id)) {
+        seen.add(connected.id);
+        traverseImpl(graph, {
+          source: connected.id,
+          relation: relation2,
+          visitor
+        }, [
+          ...path,
+          source
+        ]);
+      }
+    }
+  }
 };
 function traverse(graphOrOptions, optionsOrPath, path) {
   if (typeof graphOrOptions === "object" && "visitor" in graphOrOptions) {
@@ -379,6 +432,7 @@ var getPathImpl = (graph, params) => {
     let found = Option.none();
     traverseImpl(graph, {
       source: node.id,
+      relation: "child",
       visitor: (node2, path) => {
         if (Option.isSome(found)) {
           return false;
@@ -434,15 +488,10 @@ var initializeImpl = async (graph, id) => {
   log("initialize", {
     id,
     initialized
-  }, {
-    F: __dxlog_file,
-    L: 661,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 431, S: void 0 });
   if (!initialized) {
-    await internal._onInitialize?.(id);
     Record.set(internal._initialized, id, true);
+    await internal._onInitialize?.(id);
   }
   return graph;
 };
@@ -455,65 +504,79 @@ function initialize(graphOrId, id) {
     return initializeImpl(graph, id);
   }
 }
-var expandImpl = (graph, id, relation = "outbound") => {
+var expandImpl = (graph, id, relation2) => {
   const internal = getInternal(graph);
-  const key = `${id}$${relation}`;
+  const normalizedRelation = normalizeRelation(relation2);
+  const key = primaryKey(id, relationKey(normalizedRelation));
+  const nodeOpt = internal._registry.get(internal._node(id));
+  if (Option.isNone(nodeOpt)) {
+    internal._pendingExpands.add(key);
+    log("expand", {
+      key,
+      deferred: true
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 463, S: void 0 });
+    return graph;
+  }
   const expanded = Record.get(internal._expanded, key).pipe(Option.getOrElse(() => false));
   log("expand", {
     key,
     expanded
-  }, {
-    F: __dxlog_file,
-    L: 702,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 470, S: void 0 });
   if (!expanded) {
-    internal._onExpand?.(id, relation);
     Record.set(internal._expanded, key, true);
+    internal._onExpand?.(id, normalizedRelation);
   }
   return graph;
 };
-function expand(graphOrId, idOrRelation, relation) {
+function expand(graphOrId, idOrRelation, relation2) {
   if (typeof graphOrId === "string") {
     const id = graphOrId;
-    const rel = (typeof idOrRelation === "string" ? "outbound" : idOrRelation) ?? "outbound";
+    const rel = idOrRelation;
     return (graph) => expandImpl(graph, id, rel);
   } else {
     const graph = graphOrId;
     const id = idOrRelation;
-    const rel = relation ?? "outbound";
+    invariant2(relation2 !== void 0, "Relation is required.", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 490, S: this, A: ["relation !== undefined", "'Relation is required.'"] });
+    const rel = relation2;
     return expandImpl(graph, id, rel);
   }
 }
-var sortEdgesImpl = (graph, id, relation, order) => {
+var sortEdgesImpl = (graph, id, relation2, order) => {
   const internal = getInternal(graph);
   const edgesAtom = internal._edges(id);
   const edges = internal._registry.get(edgesAtom);
-  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, ...[
+  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
-  ]);
-  internal._registry.set(edgesAtom, edges);
+  ];
+  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 relation = idOrRelation;
+    const relation2 = idOrRelation;
     const order2 = relationOrOrder;
-    return (graph) => sortEdgesImpl(graph, id, relation, order2);
+    return (graph) => sortEdgesImpl(graph, id, relation2, order2);
   } else {
     const graph = graphOrId;
     const id = idOrRelation;
-    const relation = relationOrOrder;
-    return sortEdgesImpl(graph, id, relation, order);
+    const relation2 = relationOrOrder;
+    return sortEdgesImpl(graph, id, relation2, order);
   }
 }
 var addNodesImpl = (graph, nodes) => {
-  Atom2.batch(() => {
+  Atom.batch(() => {
     nodes.map((node) => addNodeImpl(graph, node));
   });
   return graph;
@@ -535,31 +598,21 @@ var addNodeImpl = (graph, nodeArg) => {
   Option.match(existingNode, {
     onSome: (existing) => {
       const typeChanged = existing.type !== type;
-      const dataChanged = existing.data !== data;
+      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: 847,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 565, S: void 0 });
       if (typeChanged || dataChanged || propertiesChanged) {
         log("updating node", {
           id,
           type,
           data,
           properties
-        }, {
-          F: __dxlog_file,
-          L: 854,
-          S: void 0,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 572, S: void 0 });
         const newNode = Option.some({
           ...existing,
           ...rest,
@@ -583,12 +636,7 @@ var addNodeImpl = (graph, nodeArg) => {
         type,
         data,
         properties
-      }, {
-        F: __dxlog_file,
-        L: 867,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 596, S: void 0 });
       const newNode = internal._constructNode({
         id,
         type,
@@ -601,13 +649,23 @@ var addNodeImpl = (graph, nodeArg) => {
         id,
         node: newNode
       });
+      const toApply = [
+        ...internal._pendingExpands
+      ].filter((k) => primaryParts(k)[0] === id);
+      for (const pendingKey of toApply) {
+        internal._pendingExpands.delete(pendingKey);
+        const relation2 = relationFromKey(primaryParts(pendingKey)[1]);
+        Record.set(internal._expanded, pendingKey, true);
+        internal._onExpand?.(id, relation2);
+      }
     }
   });
   if (nodes) {
     addNodesImpl(graph, nodes);
     const _edges = nodes.map((node) => ({
       source: id,
-      target: node.id
+      target: node.id,
+      relation: "child"
     }));
     addEdgesImpl(graph, _edges);
   }
@@ -626,7 +684,7 @@ function addNode(graphOrNodeArg, nodeArg) {
   }
 }
 var removeNodesImpl = (graph, ids, edges = false) => {
-  Atom2.batch(() => {
+  Atom.batch(() => {
     ids.map((id) => removeNodeImpl(graph, id, edges));
   });
   return graph;
@@ -652,17 +710,27 @@ var removeNodeImpl = (graph, id, edges = false) => {
     node: Option.none()
   });
   if (edges) {
-    const { inbound, outbound } = internal._registry.get(internal._edges(id));
-    const edgesToRemove = [
-      ...inbound.map((source) => ({
-        source,
-        target: id
-      })),
-      ...outbound.map((target) => ({
-        source: id,
-        target
-      }))
-    ];
+    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);
   }
   internal._onRemoveNode?.(id);
@@ -681,7 +749,7 @@ function removeNode(graphOrId, idOrEdges, edges) {
   }
 }
 var addEdgesImpl = (graph, edges) => {
-  Atom2.batch(() => {
+  Atom.batch(() => {
     edges.map((edge) => addEdgeImpl(graph, edge));
   });
   return graph;
@@ -696,45 +764,43 @@ function addEdges(graphOrEdges, 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);
-  if (!source.outbound.includes(edgeArg.target)) {
-    log("add outbound edge", {
+  const sourceList = source[relationId] ?? [];
+  if (!sourceList.includes(edgeArg.target)) {
+    log("add edge", {
       source: edgeArg.source,
-      target: edgeArg.target
-    }, {
-      F: __dxlog_file,
-      L: 1026,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
+      target: edgeArg.target,
+      relation: relationId
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 758, S: void 0 });
     internal._registry.set(sourceAtom, {
-      inbound: source.inbound,
-      outbound: [
-        ...source.outbound,
+      ...source,
+      [relationId]: [
+        ...sourceList,
         edgeArg.target
       ]
     });
   }
   const targetAtom = internal._edges(edgeArg.target);
   const target = internal._registry.get(targetAtom);
-  if (!target.inbound.includes(edgeArg.source)) {
-    log("add inbound edge", {
+  const targetList = target[inverseId] ?? [];
+  if (!targetList.includes(edgeArg.source)) {
+    log("add inverse edge", {
       source: edgeArg.source,
-      target: edgeArg.target
-    }, {
-      F: __dxlog_file,
-      L: 1039,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
+      target: edgeArg.target,
+      relation: inverseId
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 775, S: void 0 });
     internal._registry.set(targetAtom, {
-      inbound: [
-        ...target.inbound,
+      ...target,
+      [inverseId]: [
+        ...targetList,
         edgeArg.source
-      ],
-      outbound: target.outbound
+      ]
     });
   }
   return graph;
@@ -749,7 +815,7 @@ function addEdge(graphOrEdgeArg, edgeArg) {
   }
 }
 var removeEdgesImpl = (graph, edges, removeOrphans = false) => {
-  Atom2.batch(() => {
+  Atom.batch(() => {
     edges.map((edge) => removeEdgeImpl(graph, edge, removeOrphans));
   });
   return graph;
@@ -767,32 +833,39 @@ function removeEdges(graphOrEdges, edgesOrRemoveOrphans, removeOrphans) {
   }
 }
 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);
-  if (source.outbound.includes(edgeArg.target)) {
+  const sourceList = source[relationId] ?? [];
+  if (sourceList.includes(edgeArg.target)) {
     internal._registry.set(sourceAtom, {
-      inbound: source.inbound,
-      outbound: source.outbound.filter((id) => id !== edgeArg.target)
+      ...source,
+      [relationId]: sourceList.filter((id) => id !== edgeArg.target)
     });
   }
   const targetAtom = internal._edges(edgeArg.target);
   const target = internal._registry.get(targetAtom);
-  if (target.inbound.includes(edgeArg.source)) {
+  const targetList = target[inverseId] ?? [];
+  if (targetList.includes(edgeArg.source)) {
     internal._registry.set(targetAtom, {
-      inbound: target.inbound.filter((id) => id !== edgeArg.source),
-      outbound: target.outbound
+      ...target,
+      [inverseId]: targetList.filter((id) => id !== edgeArg.source)
     });
   }
   if (removeOrphans) {
-    const source2 = internal._registry.get(sourceAtom);
-    const target2 = internal._registry.get(targetAtom);
-    if (source2.outbound.length === 0 && source2.inbound.length === 0 && edgeArg.source !== RootId) {
+    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 (target2.outbound.length === 0 && target2.inbound.length === 0 && edgeArg.target !== RootId) {
+    if (isEmpty(targetAfter) && edgeArg.target !== RootId) {
       removeNodesImpl(graph, [
         edgeArg.target
       ]);
@@ -812,35 +885,33 @@ function removeEdge(graphOrEdgeArg, edgeArgOrRemoveOrphans, removeOrphans) {
     return removeEdgeImpl(graph, edgeArg, removeOrphansArg);
   }
 }
-var make = (params) => {
+var make2 = (params) => {
   return new GraphImpl(params);
 };
-
-// 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,
-  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 { log as log2 } from "@dxos/log";
-import { byPosition, getDebugName, isNode, isNonNullable as isNonNullable2 } from "@dxos/util";
+var relationKey = (relation2) => {
+  const normalized = normalizeRelation(relation2);
+  return secondaryKey(normalized.kind, normalized.direction);
+};
+var relationFromKey = (encoded) => {
+  const parts = secondaryParts(encoded);
+  invariant2(parts.length === 2 && parts[0].length > 0 && parts[1].length > 0, `Invalid relation key: ${encoded}`, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 894, S: void 0, A: ["parts.length === 2 && parts[0].length > 0 && parts[1].length > 0", "`Invalid relation key: ${encoded}`"] });
+  const [kind, directionRaw] = parts;
+  invariant2(directionRaw === "outbound" || directionRaw === "inbound", `Invalid relation direction: ${directionRaw}`, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 896, S: void 0, A: ["directionRaw === 'outbound' || directionRaw === 'inbound'", "`Invalid relation direction: ${directionRaw}`"] });
+  return relation(kind, directionRaw);
+};
+var connectionKey = (id, relation2) => primaryKey(id, relationKey(relation2));
+var relationFromConnectionKey = (key) => {
+  const [id, encodedRelation] = primaryParts(key);
+  invariant2(id && encodedRelation, `Invalid connection key: ${key}`, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 902, S: void 0, A: ["id && encodedRelation", "`Invalid connection key: ${key}`"] });
+  return {
+    id,
+    relation: relationFromKey(encodedRelation)
+  };
+};
+var inverseRelation = (relation2) => {
+  const normalized = normalizeRelation(relation2);
+  return relation(normalized.kind, normalized.direction === "outbound" ? "inbound" : "outbound");
+};
 
 // src/node-matcher.ts
 var node_matcher_exports = {};
@@ -864,19 +935,23 @@ var whenNodeType = (type) => (node) => node.type === type ? Option2.some(node) :
 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 matcher of matchers) {
-    const result = matcher(node);
+  let first = Option2.none();
+  for (const candidate of matchers) {
+    const result = candidate(node);
     if (Option2.isNone(result)) {
       return Option2.none();
     }
+    if (Option2.isNone(first)) {
+      first = result;
+    }
   }
-  return Option2.some(node);
+  return first;
 };
 var whenAny = (...matchers) => (node) => {
-  for (const matcher of matchers) {
-    const result = matcher(node);
+  for (const candidate of matchers) {
+    const result = candidate(node);
     if (Option2.isSome(result)) {
-      return Option2.some(node);
+      return result;
     }
   }
   return Option2.none();
@@ -886,25 +961,68 @@ var whenEchoObjectMatches = (node) => Obj.isObject(node.data) ? Option2.some(nod
 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 = Symbol.for("@dxos/app-graph/GraphBuilder");
+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: () => make3,
+  removeExtension: () => removeExtension
+});
+import { Atom as Atom2, 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 { log as log2 } from "@dxos/log";
+import { byPosition, getDebugName, isNonNullable as isNonNullable2 } from "@dxos/util";
+import { scheduleTask, yieldOrContinue } from "#scheduler";
+var __dxlog_file3 = "/__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.
+  /** Active subscriptions keyed by composite ID, cleaned up on node removal. */
   _subscriptions = /* @__PURE__ */ new Map();
-  _extensions = Atom3.make(Record2.empty()).pipe(Atom3.keepAlive, Atom3.withLabel("graph-builder:extensions"));
+  /** Connector updates pending flush, keyed by connector key. */
+  _dirtyConnectors = /* @__PURE__ */ new Map();
+  /** Last-flushed node IDs per connector key, used for edge removal on update. */
+  _connectorPrevious = /* @__PURE__ */ new Map();
+  /** All inline-descendant IDs per connector key, used to remove stale inline nodes on update. */
+  _connectorPreviousInlineIds = /* @__PURE__ */ new Map();
+  /** Last-flushed node args per connector key, used for change detection. */
+  _connectorPreviousArgs = /* @__PURE__ */ new Map();
+  /** Whether a dirty-flush task is already scheduled. */
+  _flushScheduled = false;
+  /** Resolves when the current flush completes. */
+  _flushPromise = Promise.resolve();
+  /** Registered builder extensions keyed by extension ID. */
+  _extensions = Atom2.make(Record2.empty()).pipe(Atom2.keepAlive, Atom2.withLabel("graph-builder:extensions"));
+  /** Triggers signalling that a node's resolver has fired at least once. */
   _initialized = {};
+  /** Shared atom registry for reactive subscriptions. */
   _registry;
+  /** Backing graph with internal accessors for node atoms and construction. */
   _graph;
   constructor({ registry, ...params } = {}) {
     this._registry = registry ?? Registry2.make();
-    const graph = make({
+    const graph = make2({
       ...params,
       registry: this._registry,
-      onExpand: (id, relation) => this._onExpand(id, relation),
+      onExpand: (id, relation2) => this._onExpand(id, relation2),
       onInitialize: (id) => this._onInitialize(id),
       onRemoveNode: (id) => this._onRemoveNode(id)
     });
@@ -916,130 +1034,181 @@ var GraphBuilderImpl = class {
   get extensions() {
     return this._extensions;
   }
-  _resolvers = Atom3.family((id) => {
-    return Atom3.make((get2) => {
+  /** 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);
+    const currentInlineIds = collectAllInlineIds(nodes);
+    const previousInlineIds = this._connectorPreviousInlineIds.get(key) ?? [];
+    const staleInlineIds = previousInlineIds.filter((pid) => !currentInlineIds.includes(pid));
+    this._connectorPreviousInlineIds.set(key, currentInlineIds);
+    removeNodes(this._graph, staleInlineIds, true);
+    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();
+          Atom2.batch(() => {
+            for (const [key, { nodes, previous }] of entries) {
+              this._applyConnectorUpdate(key, nodes, previous);
+            }
+          });
+        }
+      }, {
+        strategy: "smooth"
+      });
+    }
+  }
+  _resolvers = Atom2.family((id) => {
+    return Atom2.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] = key.split("+");
+  _connectors = Atom2.family((key) => {
+    return Atom2.make((get2) => {
+      const { id, relation: relation2 } = relationFromConnectorKey(key);
       const node = this._graph.node(id);
-      return Function2.pipe(
-        get2(this._extensions),
-        Record2.values,
-        // TODO(wittjosiah): Sort on write rather than read.
-        Array2.sortBy(byPosition),
-        Array2.filter(({ relation: _relation = "outbound" }) => _relation === relation),
-        Array2.map(({ connector }) => connector?.(node)),
-        Array2.filter(isNonNullable2),
-        Array2.flatMap((result) => get2(result))
-      );
-    }).pipe(Atom3.withLabel(`graph-builder:connectors:${key}`));
+      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(Atom2.withLabel(`graph-builder:connectors:${key}`));
   });
-  _onExpand(id, relation) {
+  _onExpand(id, relation2) {
     log2("onExpand", {
       id,
-      relation,
+      relation: relation2,
       registry: getDebugName(this._registry)
-    }, {
-      F: __dxlog_file2,
-      L: 176,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const connectors = this._connectors(`${id}+${relation}`);
-    let previous = [];
-    const cancel = this._registry.subscribe(connectors, (nodes) => {
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 136, S: this });
+    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, (rawNodes) => {
+      const nodes = qualifyNodeArgs(id)(rawNodes);
+      const previous = this._connectorPrevious.get(key) ?? [];
       const ids = nodes.map((n) => n.id);
-      const removed = previous.filter((id2) => !ids.includes(id2));
-      previous = ids;
+      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,
-        ids,
-        removed
-      }, {
-        F: __dxlog_file2,
-        L: 187,
-        S: this,
-        C: (f, a) => f(...a)
+        relation: relation2,
+        ids
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 160, S: this });
+      this._dirtyConnectors.set(key, {
+        nodes,
+        previous
       });
-      const update = () => {
-        Atom3.batch(() => {
-          removeEdges(this._graph, removed.map((target) => ({
-            source: id,
-            target
-          })), true);
-          addNodes(this._graph, nodes);
-          addEdges(this._graph, nodes.map((node) => relation === "outbound" ? {
-            source: id,
-            target: node.id
-          } : {
-            source: node.id,
-            target: id
-          }));
-          sortEdges(this._graph, id, relation, nodes.map(({ id: id2 }) => id2));
-        });
-      };
-      if (typeof requestAnimationFrame === "function") {
-        requestAnimationFrame(update);
-      } else {
-        update();
-      }
+      this._scheduleDirtyFlush();
     }, {
       immediate: true
     });
-    this._subscriptions.set(id, cancel);
+    this._subscriptions.set(subscriptionKey(id, "expand", key), cancel);
   }
-  // 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: 227,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 176, S: this });
     const resolver = this._resolvers(id);
     const cancel = this._registry.subscribe(resolver, (node) => {
       const trigger = this._initialized[id];
+      const connectorOwned = [
+        ...this._connectorPrevious.values()
+      ].some((ids) => ids.includes(id));
       Option3.match(node, {
         onSome: (node2) => {
-          addNodes(this._graph, [
-            node2
-          ]);
+          if (!connectorOwned) {
+            addNodes(this._graph, [
+              node2
+            ]);
+            const parentId = getParentId(id);
+            if (parentId) {
+              addEdges(this._graph, [
+                {
+                  source: parentId,
+                  target: id,
+                  relation: "child"
+                }
+              ]);
+            }
+          }
           trigger?.wake();
         },
         onNone: () => {
           trigger?.wake();
-          removeNodes(this._graph, [
-            id
-          ]);
+          if (!connectorOwned) {
+            removeNodes(this._graph, [
+              id
+            ]);
+          }
         }
       });
     }, {
       immediate: true
     });
-    this._subscriptions.set(id, cancel);
+    this._subscriptions.set(subscriptionKey(id, "init"), cancel);
   }
   _onRemoveNode(id) {
-    this._subscriptions.get(id)?.();
-    this._subscriptions.delete(id);
+    for (const [key, cleanup] of this._subscriptions) {
+      if (primaryParts(key)[0] === id) {
+        cleanup();
+        this._subscriptions.delete(key);
+      }
+    }
   }
 };
-var make2 = (params) => {
+var make3 = (params) => {
   return new GraphBuilderImpl(params);
 };
 var from = (pickle, registry) => {
   if (!pickle) {
-    return make2({
+    return make3({
       registry
     });
   }
   const { nodes, edges } = JSON.parse(pickle);
-  return make2({
+  return make3({
     nodes,
     edges,
     registry
@@ -1079,14 +1248,11 @@ function removeExtension(builderOrId, id) {
 }
 var exploreImpl = async (builder, options, path = []) => {
   const internal = builder;
-  const { registry = Registry2.make(), source = RootId, relation = "outbound", visitor } = options;
+  const { registry = Registry2.make(), source = RootId, relation: relation2, visitor } = options;
   if (path.includes(source)) {
     return;
   }
-  if (!isNode()) {
-    const { yieldOrContinue } = await import("main-thread-scheduling");
-    await yieldOrContinue("idle");
-  }
+  await yieldOrContinue("idle");
   const node = registry.get(internal._graph.nodeOrThrow(source));
   const shouldContinue = await visitor(node, [
     ...path,
@@ -1095,13 +1261,13 @@ var exploreImpl = async (builder, options, path = []) => {
   if (shouldContinue === false) {
     return;
   }
-  const nodes = Object.values(internal._registry.get(internal._extensions)).filter((extension) => relation === (extension.relation ?? "outbound")).map((extension) => extension.connector).filter(isNonNullable2).flatMap((connector) => registry.get(connector(internal._graph.node(source))));
+  const nodes = Function2.pipe(internal._registry.get(internal._extensions), Record2.values, Array2.map((extension) => extension.connector), Array2.filter(isNonNullable2), Array2.flatMap((connector) => registry.get(connector(internal._graph.node(source)))), qualifyNodeArgs(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,
+      relation: relation2,
       visitor
     }, [
       ...path,
@@ -1137,13 +1303,17 @@ function destroy(builder) {
     return destroyImpl(builder);
   }
 }
+var flush = (builder) => {
+  return builder._flushPromise;
+};
 var createExtensionRaw = (extension) => {
-  const { id, position = "static", relation = "outbound", resolver: _resolver, connector: _connector, actions: _actions, actionGroups: _actionGroups } = extension;
+  const { id, position, relation: relation2 = "child", resolver: _resolver, connector: _connector, actions: _actions, actionGroups: _actionGroups } = extension;
+  const normalizedRelation = normalizeRelation(relation2);
   const getId = (key) => `${id}/${key}`;
-  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}`)));
+  const resolver = _resolver && Atom2.family((id2) => _resolver(id2).pipe(Atom2.withLabel(`graph-builder:_resolver:${id2}`)));
+  const connector = _connector && Atom2.family((node) => _connector(node).pipe(Atom2.withLabel(`graph-builder:_connector:${id}`)));
+  const actionGroups = _actionGroups && Atom2.family((node) => _actionGroups(node).pipe(Atom2.withLabel(`graph-builder:_actionGroups:${id}`)));
+  const actions = _actions && Atom2.family((node) => _actions(node).pipe(Atom2.withLabel(`graph-builder:_actions:${id}`)));
   return [
     resolver ? {
       id: getId("resolver"),
@@ -1153,8 +1323,8 @@ var createExtensionRaw = (extension) => {
     connector ? {
       id: getId("connector"),
       position,
-      relation,
-      connector: Atom3.family((node) => Atom3.make((get2) => {
+      relation: normalizedRelation,
+      connector: Atom2.family((node) => Atom2.make((get2) => {
         try {
           return get2(connector(node));
         } catch (error) {
@@ -1162,21 +1332,16 @@ var createExtensionRaw = (extension) => {
             id: getId("connector"),
             node,
             error
-          }, {
-            F: __dxlog_file2,
-            L: 509,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 383, S: void 0 });
           return [];
         }
-      }).pipe(Atom3.withLabel(`graph-builder:connector:${id}`)))
+      }).pipe(Atom2.withLabel(`graph-builder:connector:${id}`)))
     } : void 0,
     actionGroups ? {
       id: getId("actionGroups"),
       position,
-      relation: "outbound",
-      connector: Atom3.family((node) => Atom3.make((get2) => {
+      relation: actionRelation(),
+      connector: Atom2.family((node) => Atom2.make((get2) => {
         try {
           return get2(actionGroups(node)).map((arg) => ({
             ...arg,
@@ -1188,21 +1353,16 @@ var createExtensionRaw = (extension) => {
             id: getId("actionGroups"),
             node,
             error
-          }, {
-            F: __dxlog_file2,
-            L: 530,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 404, S: void 0 });
           return [];
         }
-      }).pipe(Atom3.withLabel(`graph-builder:connector:actionGroups:${id}`)))
+      }).pipe(Atom2.withLabel(`graph-builder:connector:actionGroups:${id}`)))
     } : void 0,
     actions ? {
       id: getId("actions"),
       position,
-      relation: "outbound",
-      connector: Atom3.family((node) => Atom3.make((get2) => {
+      relation: actionRelation(),
+      connector: Atom2.family((node) => Atom2.make((get2) => {
         try {
           return get2(actions(node)).map((arg) => ({
             ...arg,
@@ -1213,15 +1373,10 @@ var createExtensionRaw = (extension) => {
             id: getId("actions"),
             node,
             error
-          }, {
-            F: __dxlog_file2,
-            L: 547,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 424, S: void 0 });
           return [];
         }
-      }).pipe(Atom3.withLabel(`graph-builder:connector:actions:${id}`)))
+      }).pipe(Atom2.withLabel(`graph-builder:connector:actions:${id}`)))
     } : void 0
   ].filter(isNonNullable2);
 };
@@ -1230,27 +1385,22 @@ var runEffectSyncWithFallback = (effect, context2, extensionId, fallback) => {
     log2.warn("Extension failed", {
       extension: extensionId,
       error
-    }, {
-      F: __dxlog_file2,
-      L: 590,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 441, S: void 0 });
     return Effect.succeed(fallback);
   })));
 };
 var createExtension = (options) => Effect.map(Effect.context(), (context2) => {
-  const { id, match: match3, actions, connector, resolver, relation, position } = options;
+  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) => ({
+  const actionsExtension = actions ? (node) => Atom2.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;
+  const resolverExtension = resolver ? (nodeId) => Atom2.make((get2) => runEffectSyncWithFallback(resolver(nodeId, get2), context2, id, null) ?? null) : void 0;
   return createExtensionRaw({
     id,
-    relation,
+    relation: relation2,
     position,
     connector: connectorExtension,
     actions: actionsExtension,
@@ -1258,22 +1408,44 @@ var createExtension = (options) => Effect.map(Effect.context(), (context2) => {
   });
 });
 var createConnector = (matcher, factory) => {
-  return (node) => Atom3.make((get2) => Function2.pipe(get2(node), Option3.flatMap(matcher), Option3.map((data) => factory(data, get2)), Option3.getOrElse(() => [])));
+  return (node) => Atom2.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(() => [])));
+  return (node) => Atom2.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, position } = options;
+  const { id, type, actions, connector, relation: relation2, position } = options;
   return createExtension({
     id,
     match: whenEchoType(type),
     actions,
     connector,
-    relation,
+    relation: relation2,
     position
   });
 };
+var qualifyNodeArgs = (parentId) => (nodes) => nodes.map((node) => {
+  validateSegmentId(node.id);
+  const qualified = qualifyId(parentId, node.id);
+  return {
+    ...node,
+    id: qualified,
+    nodes: node.nodes ? qualifyNodeArgs(qualified)(node.nodes) : void 0
+  };
+});
+var collectAllInlineIds = (nodes) => nodes.flatMap((node) => node.nodes ? [
+  ...node.nodes.map((child) => child.id),
+  ...collectAllInlineIds(node.nodes)
+] : []);
+var connectorKey = (id, relation2) => primaryKey(id, relationKey(relation2));
+var relationFromConnectorKey = (key) => {
+  const [id, encodedRelation] = primaryParts(key);
+  return {
+    id,
+    relation: relationFromKey(encodedRelation)
+  };
+};
+var subscriptionKey = (id, kind, detail) => detail != null ? primaryKey(id, kind, detail) : primaryKey(id, kind);
 var flattenExtensions = (extension, acc = []) => {
   if (Array2.isArray(extension)) {
     return [
@@ -1287,11 +1459,19 @@ var flattenExtensions = (extension, acc = []) => {
     ];
   }
 };
+
 export {
-  atoms_exports as CreateAtom,
-  graph_exports as Graph,
-  graph_builder_exports as GraphBuilder,
-  node_exports as Node,
-  node_matcher_exports as NodeMatcher
+  node_exports,
+  qualifyId,
+  getParentId,
+  getSegmentId,
+  getNode,
+  expand,
+  graph_exports,
+  node_matcher_exports,
+  make3 as make,
+  addExtension,
+  flush,
+  graph_builder_exports
 };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=chunk-32XXJE6M.mjs.map